~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to strings/ctype-czech.c

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
ImportĀ upstreamĀ versionĀ 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* Copyright (C) 2000 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
/* File strings/ctype-czech.c for MySQL.
 
17
 
 
18
        This file implements the Czech sorting for the MySQL database
 
19
        server (www.mysql.com). Due to some complicated rules the
 
20
        Czech language has for sorting strings, a more complex
 
21
        solution was needed than the one-to-one conversion table. To
 
22
        note a few, here is an example of a Czech sorting sequence:
 
23
 
 
24
                co < hlaska < hlļæ½ska < hlava < chlapec < krtek
 
25
 
 
26
        It because some of the rules are: double char 'ch' is sorted
 
27
        between 'h' and 'i'. Accented character 'ļæ½' (a with acute) is
 
28
        sorted after 'a' and before 'b', but only if the word is
 
29
        otherwise the same. However, because 's' is sorted before 'v'
 
30
        in hlava, the accentness of 'ļæ½' is overridden. There are many
 
31
        more rules.
 
32
 
 
33
        This file defines functions my_strxfrm and my_strcoll for
 
34
        C-like zero terminated strings and my_strnxfrm and my_strnncoll
 
35
        for strings where the length comes as an parameter. Also
 
36
        defined here you will find function my_like_range that returns
 
37
        index range strings for LIKE expression and the
 
38
        MY_STRXFRM_MULTIPLY set to value 4 -- this is the ratio the
 
39
        strings grows during my_strxfrm. The algorithm has four
 
40
        passes, that's why we need four times more space for expanded
 
41
        string.
 
42
 
 
43
        This file also contains the ISO-Latin-2 definitions of
 
44
        characters.
 
45
 
 
46
        Author: (c) 1997--1998 Jan Pazdziora, adelton@fi.muni.cz
 
47
        Jan Pazdziora has a shared copyright for this code
 
48
 
 
49
        The original of this file can also be found at
 
50
        http://www.fi.muni.cz/~adelton/l10n/
 
51
 
 
52
        Bug reports and suggestions are always welcome.
 
53
*/
 
54
 
 
55
/*
 
56
 * This comment is parsed by configure to create ctype.c,
 
57
 * so don't change it unless you know what you are doing.
 
58
 *
 
59
 * .configure. strxfrm_multiply_czech=4
 
60
 */
 
61
 
 
62
#define SKIP_TRAILING_SPACES 1
 
63
 
 
64
#define REAL_MYSQL
 
65
 
 
66
#ifdef REAL_MYSQL
 
67
 
 
68
#include <my_global.h>
 
69
#include "m_string.h"
 
70
#include "m_ctype.h"
 
71
 
 
72
#else
 
73
 
 
74
#include <stdio.h>
 
75
#define uchar unsigned char
 
76
 
 
77
#endif
 
78
 
 
79
#ifdef HAVE_CHARSET_latin2
 
80
 
 
81
/*
 
82
        These are four tables for four passes of the algorithm. Please see
 
83
        below for what are the "special values"
 
84
*/
 
85
 
 
86
static uchar *CZ_SORT_TABLE[] = {
 
87
  (uchar*) "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\043\044\045\046\047\050\051\052\053\054\000\000\000\000\000\000\000\003\004\377\007\010\011\012\013\015\016\017\020\022\023\024\025\026\027\031\033\034\035\036\037\040\041\000\000\000\000\000\000\003\004\377\007\010\011\012\013\015\016\017\020\022\023\024\025\026\027\031\033\034\035\036\037\040\041\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\021\000\020\032\000\000\032\032\033\042\000\042\042\000\003\000\021\000\020\032\000\000\032\032\033\042\000\042\042\027\003\003\003\003\020\006\006\006\010\010\010\010\015\015\007\007\023\023\024\024\024\024\000\030\034\034\034\034\040\033\000\027\003\003\003\003\020\006\006\006\010\010\010\010\015\015\007\007\023\023\024\024\024\024\000\030\034\034\034\034\040\033\000",
 
88
  (uchar*) "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\106\107\110\111\112\113\114\115\116\117\000\000\000\000\000\000\000\003\011\377\016\021\026\027\030\032\035\036\037\043\044\047\054\055\056\061\065\070\075\076\077\100\102\000\000\000\000\000\000\003\011\377\016\021\026\027\030\032\035\036\037\043\044\047\054\055\056\061\065\070\075\076\077\100\102\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000\042\000\041\063\000\000\062\064\066\104\000\103\105\000\010\000\042\000\041\063\000\000\062\064\066\104\000\103\105\057\004\005\007\006\040\014\015\013\022\025\024\023\033\034\017\020\046\045\050\051\053\052\000\060\072\071\074\073\101\067\000\057\004\005\007\006\040\014\015\013\022\025\024\023\033\034\017\020\046\045\050\051\053\052\000\060\072\071\074\073\101\067\000",
 
89
(uchar*) "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\213\214\215\216\217\220\221\222\223\000\000\000\000\000\000\000\004\020\377\032\040\052\054\056\063\071\073\075\105\107\115\127\131\133\141\151\157\171\173\175\177\203\000\000\000\000\000\000\003\017\377\031\037\051\053\055\062\070\072\074\104\106\114\126\130\132\140\150\156\170\172\174\176\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\103\000\101\145\000\000\143\147\153\207\000\205\211\000\015\000\102\000\100\144\000\000\142\146\152\206\000\204\210\135\006\010\014\012\077\026\030\024\042\050\046\044\065\067\034\036\113\111\117\121\125\123\000\137\163\161\167\165\201\155\000\134\005\007\013\011\076\025\027\023\041\047\045\043\064\066\033\035\112\110\116\120\124\122\000\136\162\160\166\164\200\154\000",
 
90
(uchar*) "\264\265\266\267\270\271\272\273\274\002\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\002\230\232\253\324\252\251\234\240\241\261\260\225\262\224\235\212\213\214\215\216\217\220\221\222\223\231\226\244\257\245\227\250\004\020\377\032\040\052\054\056\063\071\073\075\105\107\115\127\131\133\141\151\157\171\173\175\177\203\242\237\243\254\255\233\003\017\377\031\037\051\053\055\062\070\072\074\104\106\114\126\130\132\140\150\156\170\172\174\176\202\246\236\247\256\325\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\326\016\327\103\330\101\145\331\332\143\147\153\207\333\205\211\334\015\335\102\336\100\144\337\340\142\146\152\206\341\204\210\135\006\010\014\012\077\026\030\024\042\050\046\044\065\067\034\036\113\111\117\121\125\123\263\137\163\161\167\165\201\155\342\134\005\007\013\011\076\025\027\023\041\047\045\043\064\066\033\035\112\110\116\120\124\122\343\136\162\160\166\164\200\154\344",
 
91
};
 
92
 
 
93
/*
 
94
        These define the valuse for the double chars that need to be
 
95
        sorted as they were single characters -- in Czech these are
 
96
        'ch', 'Ch' and 'CH'.
 
97
*/
 
98
 
 
99
struct wordvalue
 
100
        {
 
101
          const char * word;
 
102
          uchar *outvalue;
 
103
        };
 
104
static struct wordvalue doubles[] = {
 
105
        { "ch", (uchar*) "\014\031\057\057" },
 
106
        { "Ch", (uchar*) "\014\031\060\060" },
 
107
        { "CH", (uchar*) "\014\031\061\061" },
 
108
        { "c",  (uchar*) "\005\012\021\021" },
 
109
        { "C",  (uchar*) "\005\012\022\022" },
 
110
        };
 
111
 
 
112
/*
 
113
        Unformal description of the algorithm:
 
114
 
 
115
        We walk the string left to right.
 
116
 
 
117
        The end of the string is either passed as parameter, or is
 
118
        *p == 0. This is hidden in the IS_END macro.
 
119
 
 
120
        In the first two passes, we compare word by word. So we make
 
121
        first and second pass on the first word, first and second pass
 
122
        on the second word, etc. If we come to the end of the string
 
123
        during the first pass, we need to jump to the last word of the
 
124
        second pass.
 
125
 
 
126
        End of pass is marked with value 1 on the output.
 
127
 
 
128
        For each character, we read it's value from the table.
 
129
 
 
130
        If the value is ignore (0), we go straight to the next character.
 
131
 
 
132
        If the value is space/end of word (2) and we are in the first
 
133
        or second pass, we skip all characters having value 0 -- 2 and
 
134
        switch the passwd.
 
135
 
 
136
        If it's the compose character (255), we check if the double
 
137
        exists behind it, find its value.
 
138
 
 
139
        We append 0 to the end.
 
140
---
 
141
        Neformļæ½lnļæ½ popis algoritmu:
 
142
 
 
143
        Prochļæ½zļæ½me ļæ½etļæ½zec zleva doprava.
 
144
 
 
145
        Konec ļæ½etļæ½zce je pļæ½edļæ½n buļæ½ jako parametr, nebo je to *p == 0.
 
146
        Toto je oļæ½etļæ½eno makrem IS_END.
 
147
 
 
148
        Pokud jsme doļæ½li na konec ļæ½etļæ½zce pļæ½i prļæ½chodu 0, nejdeme na
 
149
        zaļæ½ļæ½tek, ale na uloļæ½enou pozici, protoļæ½e prvnļæ½ a druhļæ½ prļæ½chod
 
150
        bļæ½ļæ½ souļæ½asnļæ½.
 
151
 
 
152
        Konec vstupu (prļæ½chodu) oznaļæ½ļæ½me na vļæ½stupu hodnotou 1.
 
153
 
 
154
        Pro kaļæ½dļæ½ znak ļæ½etļæ½zce naļæ½teme hodnotu z tļæ½ļæ½dļæ½cļæ½ tabulky.
 
155
 
 
156
        Jde-li o hodnotu ignorovat (0), skoļæ½ļæ½me ihned na dalļæ½ļæ½ znak..
 
157
 
 
158
        Jde-li o hodnotu konec slova (2) a je to prļæ½chod 0 nebo 1,
 
159
        pļæ½eskoļæ½ļæ½me vļæ½echny dalļæ½ļæ½ 0 -- 2 a prohodļæ½me prļæ½chody.
 
160
 
 
161
        Jde-li o kompozitnļæ½ znak (255), otestujeme, zda nļæ½sleduje
 
162
        sprļæ½vnļæ½ do dvojice, dohledļæ½me sprļæ½vnou hodnotu.
 
163
 
 
164
        Na konci pļæ½ipojļæ½me znak 0
 
165
 */
 
166
 
 
167
#define ADD_TO_RESULT(dest, len, totlen, value)                 \
 
168
if ((totlen) < (len)) { dest[totlen] = value; } (totlen++);
 
169
#define IS_END(p, src, len)     (((char *)p - (char *)src) >= (len))
 
170
 
 
171
#define NEXT_CMP_VALUE(src, p, store, pass, value, len)         \
 
172
while (1)                                               \
 
173
{                                                       \
 
174
  if (IS_END(p, src, len))                              \
 
175
  {                                                     \
 
176
    /* when we are at the end of string */              \
 
177
    /* return either 0 for end of string */             \
 
178
   /* or 1 for end of pass */                           \
 
179
   value= 0;                                            \
 
180
   if (pass != 3)                                       \
 
181
   {                                                    \
 
182
     p= (pass++ == 0) ? store : src;                    \
 
183
     value = 1;                                         \
 
184
   }                                                    \
 
185
   break;                                               \
 
186
  }                                                     \
 
187
  /* not at end of string */                            \
 
188
  value = CZ_SORT_TABLE[pass][*p];                      \
 
189
  if (value == 0)                                       \
 
190
  { p++; continue; } /* ignore value */                 \
 
191
  if (value == 2) /* space */                           \
 
192
  {                                                     \
 
193
    const uchar *tmp;                                   \
 
194
    const uchar *runner = ++p;                          \
 
195
    while (!(IS_END(runner, src, len)) && (CZ_SORT_TABLE[pass][*runner] == 2)) \
 
196
     runner++;  /* skip all spaces */                   \
 
197
    if (IS_END(runner, src, len) && SKIP_TRAILING_SPACES) \
 
198
      p = runner;                                       \
 
199
    if ((pass <= 2) && !(IS_END(runner, src, len)))     \
 
200
      p = runner;                                       \
 
201
    if (IS_END(p, src, len))                            \
 
202
      continue;                                         \
 
203
    /* we switch passes */                              \
 
204
    if (pass > 1)                                       \
 
205
      break;                                            \
 
206
    tmp = p;                                            \
 
207
    pass= 1-pass;                                       \
 
208
    p = store; store = tmp;                             \
 
209
    break;                                              \
 
210
  }                                                     \
 
211
  if (value == 255)                                     \
 
212
  {                                                     \
 
213
    int i;                                              \
 
214
    for (i = 0; i < (int) sizeof(doubles); i++)         \
 
215
    {                                                   \
 
216
      const char * pattern = doubles[i].word;           \
 
217
      const char * q = (const char *) p;                \
 
218
      int j = 0;                                        \
 
219
      while (pattern[j])                                \
 
220
      {                                                 \
 
221
        if (IS_END(q, src, len) || (*q != pattern[j]))  \
 
222
         break;                                         \
 
223
        j++; q++;                                       \
 
224
      }                                                 \
 
225
      if (!(pattern[j]))                                \
 
226
      {                                                 \
 
227
        value = (int)(doubles[i].outvalue[pass]);       \
 
228
        p= (const uchar *) q - 1;                       \
 
229
        break;                                          \
 
230
      }                                                 \
 
231
    }                                                   \
 
232
  }                                                     \
 
233
  p++;                                                  \
 
234
  break;                                                \
 
235
}
 
236
 
 
237
/*
 
238
  Function strnncoll, actually strcoll, with Czech sorting, which expect
 
239
  the length of the strings being specified
 
240
*/
 
241
 
 
242
static int my_strnncoll_czech(CHARSET_INFO *cs __attribute__((unused)),
 
243
                              const uchar *s1, size_t len1, 
 
244
                              const uchar *s2, size_t len2,
 
245
                              my_bool s2_is_prefix)
 
246
{
 
247
  int v1, v2;
 
248
  const uchar *p1, * p2, * store1, * store2;
 
249
  int pass1 = 0, pass2 = 0;
 
250
 
 
251
  if (s2_is_prefix && len1 > len2)
 
252
    len1=len2;
 
253
 
 
254
  p1 = s1;      p2 = s2;
 
255
  store1 = s1;  store2 = s2;
 
256
 
 
257
  do
 
258
  {
 
259
    int diff;
 
260
    NEXT_CMP_VALUE(s1, p1, store1, pass1, v1, (int)len1);
 
261
    NEXT_CMP_VALUE(s2, p2, store2, pass2, v2, (int)len2);
 
262
    if ((diff = v1 - v2))
 
263
      return diff;
 
264
  }
 
265
  while (v1);
 
266
  return 0;
 
267
}
 
268
 
 
269
 
 
270
 
 
271
/*
 
272
  TODO: Fix this one to compare strings as they are done in ctype-simple1
 
273
*/
 
274
 
 
275
static
 
276
int my_strnncollsp_czech(CHARSET_INFO * cs, 
 
277
                         const uchar *s, size_t slen, 
 
278
                         const uchar *t, size_t tlen,
 
279
                         my_bool diff_if_only_endspace_difference
 
280
                         __attribute__((unused)))
 
281
{
 
282
  for ( ; slen && s[slen-1] == ' ' ; slen--);
 
283
  for ( ; tlen && t[tlen-1] == ' ' ; tlen--);
 
284
  return my_strnncoll_czech(cs,s,slen,t,tlen,0);
 
285
}
 
286
 
 
287
 
 
288
/*
 
289
  Function strnxfrm, actually strxfrm, with Czech sorting, which expect
 
290
  the length of the strings being specified
 
291
*/
 
292
 
 
293
static size_t my_strnxfrm_czech(CHARSET_INFO *cs __attribute__((unused)), 
 
294
                                uchar *dest, size_t len,
 
295
                                const uchar *src, size_t srclen)
 
296
{
 
297
  int value;
 
298
  const uchar *p, * store;
 
299
  int pass = 0;
 
300
  size_t totlen = 0;
 
301
  p = src;      store = src;
 
302
 
 
303
  do
 
304
  {
 
305
    NEXT_CMP_VALUE(src, p, store, pass, value, (int)srclen);
 
306
    ADD_TO_RESULT(dest, len, totlen, value);
 
307
  }
 
308
  while (value);
 
309
  if (len > totlen)
 
310
    bfill(dest + totlen, len - totlen, ' ');
 
311
  return len;
 
312
}
 
313
 
 
314
#undef IS_END
 
315
 
 
316
 
 
317
/*
 
318
        Neformļæ½lnļæ½ popis algoritmu:
 
319
 
 
320
        prochļæ½zļæ½me ļæ½etļæ½zec zleva doprava
 
321
        konec ļæ½etļæ½zce poznļæ½me podle *p == 0
 
322
        pokud jsme doļæ½li na konec ļæ½etļæ½zce pļæ½i prļæ½chodu 0, nejdeme na
 
323
                zaļæ½ļæ½tek, ale na uloļæ½enou pozici, protoļæ½e prvnļæ½ a druhļæ½
 
324
                prļæ½chod bļæ½ļæ½ souļæ½asnļæ½
 
325
        konec vstupu (prļæ½chodu) oznaļæ½ļæ½me na vļæ½stupu hodnotou 1
 
326
 
 
327
        naļæ½teme hodnotu z tļæ½ļæ½dļæ½cļæ½ tabulky
 
328
        jde-li o hodnotu ignorovat (0), skoļæ½ļæ½me na dalļæ½ļæ½ prļæ½chod
 
329
        jde-li o hodnotu konec slova (2) a je to prļæ½chod 0 nebo 1,
 
330
                pļæ½eskoļæ½ļæ½me vļæ½echny dalļæ½ļæ½ 0 -- 2 a prohodļæ½me
 
331
                prļæ½chody
 
332
        jde-li o kompozitnļæ½ znak (255), otestujeme, zda nļæ½sleduje
 
333
                sprļæ½vnļæ½ do dvojice, dohledļæ½me sprļæ½vnou hodnotu
 
334
 
 
335
        na konci pļæ½ipojļæ½me znak 0
 
336
 */
 
337
 
 
338
 
 
339
/*
 
340
** Calculate min_str and max_str that ranges a LIKE string.
 
341
** Arguments:
 
342
** ptr          Pointer to LIKE string.
 
343
** ptr_length   Length of LIKE string.
 
344
** escape       Escape character in LIKE.  (Normally '\').
 
345
**              All escape characters should be removed from min_str and max_str
 
346
** res_length   Length of min_str and max_str.
 
347
** min_str      Smallest case sensitive string that ranges LIKE.
 
348
**              Should be space padded to res_length.
 
349
** max_str      Largest case sensitive string that ranges LIKE.
 
350
**              Normally padded with the biggest character sort value.
 
351
**
 
352
** The function should return 0 if ok and 1 if the LIKE string can't be
 
353
** optimized !
 
354
*/
 
355
 
 
356
#ifdef REAL_MYSQL
 
357
 
 
358
#define min_sort_char ' '
 
359
#define max_sort_char '9'
 
360
 
 
361
#define EXAMPLE
 
362
 
 
363
static my_bool my_like_range_czech(CHARSET_INFO *cs __attribute__((unused)),
 
364
                                   const char *ptr,size_t ptr_length,
 
365
                                   pbool escape, pbool w_one, pbool w_many,
 
366
                                   size_t res_length, char *min_str,
 
367
                                   char *max_str,
 
368
                                   size_t *min_length,size_t *max_length)
 
369
{
 
370
#ifdef EXAMPLE
 
371
  uchar value;
 
372
  const char *end=ptr+ptr_length;
 
373
  char *min_org=min_str;
 
374
  char *min_end=min_str+res_length;
 
375
 
 
376
  for (; ptr != end && min_str != min_end ; ptr++)
 
377
  {
 
378
    if (*ptr == w_one)          /* '_' in SQL */
 
379
    { break; }
 
380
    if (*ptr == w_many)         /* '%' in SQL */
 
381
    { break; }
 
382
 
 
383
    if (*ptr == escape && ptr+1 != end)
 
384
    { ptr++; }                  /* Skip escape */
 
385
 
 
386
    value = CZ_SORT_TABLE[0][(int) (uchar) *ptr];
 
387
 
 
388
    if (value == 0)                     /* Ignore in the first pass */
 
389
    { continue; }
 
390
    if (value <= 2)                     /* End of pass or end of string */
 
391
    { break; }
 
392
    if (value == 255)           /* Double char too compicated */
 
393
    { break; }
 
394
 
 
395
    *min_str++= *max_str++ = *ptr;
 
396
  }
 
397
 
 
398
  if (cs->state & MY_CS_BINSORT)
 
399
    *min_length= (size_t) (min_str - min_org);
 
400
  else
 
401
  {
 
402
    /* 'a\0\0... is the smallest possible string */
 
403
    *min_length= res_length;
 
404
  }
 
405
  /* a\ff\ff... is the biggest possible string */
 
406
  *max_length= res_length;
 
407
 
 
408
  while (min_str != min_end)
 
409
  {
 
410
    *min_str++ = min_sort_char; /* Because of key compression */
 
411
    *max_str++ = max_sort_char;
 
412
  }
 
413
  return 0;
 
414
#else
 
415
  return 1;
 
416
#endif
 
417
}
 
418
 
 
419
#endif
 
420
 
 
421
#ifdef REAL_MYSQL
 
422
/* This is a latin2 file */
 
423
 
 
424
/*
 
425
 * File generated by cset
 
426
 * (C) Abandoned 1997 Zarko Mocnik <zarko.mocnik@dem.si>
 
427
 *
 
428
 * definition table reworked by Jaromir Dolecek <dolecek@ics.muni.cz>
 
429
 */
 
430
#include <my_global.h>
 
431
#include "m_string.h"
 
432
 
 
433
static uchar NEAR ctype_czech[257] = {
 
434
0,
 
435
 32, 32, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 32, 32,
 
436
 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 
437
 72, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 
438
132,132,132,132,132,132,132,132,132,132, 16, 16, 16, 16, 16, 16,
 
439
 16,129,129,129,129,129,129,  1,  1,  1,  1,  1,  1,  1,  1,  1,
 
440
  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 16, 16, 16, 16, 16,
 
441
 16,130,130,130,130,130,130,  2,  2,  2,  2,  2,  2,  2,  2,  2,
 
442
  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2, 16, 16, 16, 16, 32,
 
443
 32, 32, 32, 32, 32, 32, 32, 32, 40, 40, 40, 40, 40, 32, 32, 32,
 
444
 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 72,
 
445
  1, 16,  1, 16,  1,  1, 16,  0,  0,  1,  1,  1,  1, 16,  1,  1,
 
446
 16,  2, 16,  2, 16,  2,  2, 16, 16,  2,  2,  2,  2, 16,  2,  2,
 
447
  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
 
448
 16,  1,  1,  1,  1,  1,  1, 16,  1,  1,  1,  1,  1,  1,  1, 16,
 
449
  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
 
450
  2,  2,  2,  2,  2,  2,  2, 16,  2,  2,  2,  2,  2,  2,  2, 16,
 
451
};
 
452
 
 
453
static uchar NEAR to_lower_czech[] = {
 
454
  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 
455
 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 
456
 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 
457
 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 
458
 64, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
 
459
112,113,114,115,116,117,118,119,120,121,122, 91, 92, 93, 94, 95,
 
460
 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
 
461
112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,
 
462
128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
 
463
144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
 
464
177,161,179,163,181,182,166,167,168,185,186,187,188,173,190,191,
 
465
176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
 
466
224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
 
467
208,241,242,243,244,245,246,215,248,249,250,251,252,253,254,223,
 
468
224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
 
469
240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,
 
470
};
 
471
 
 
472
static uchar NEAR to_upper_czech[] = {
 
473
  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 
474
 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 
475
 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 
476
 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 
477
 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 
478
 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
 
479
 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 
480
 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,123,124,125,126,127,
 
481
128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
 
482
144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
 
483
160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
 
484
176,160,178,162,180,164,165,183,184,169,170,171,172,189,174,175,
 
485
192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 
486
208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
 
487
192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 
488
240,209,210,211,212,213,214,247,216,217,218,219,220,221,222,255,
 
489
};
 
490
 
 
491
static uchar NEAR sort_order_czech[] = {
 
492
  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 
493
 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 
494
 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 
495
 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 
496
 64, 65, 71, 72, 76, 78, 83, 84, 85, 86, 90, 91, 92, 96, 97,100,
 
497
105,106,107,110,114,117,122,123,124,125,127,131,132,133,134,135,
 
498
136, 65, 71, 72, 76, 78, 83, 84, 85, 86, 90, 91, 92, 96, 97,100,
 
499
105,106,107,110,114,117,122,123,124,125,127,137,138,139,140,  0,
 
500
  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
 
501
 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,255,
 
502
 66,255, 93,255, 94,111,255,255,255,112,113,115,128,255,129,130,
 
503
255, 66,255, 93,255, 94,111,255,255,112,113,115,128,255,129,130,
 
504
108, 67, 68, 69, 70, 95, 73, 75, 74, 79, 81, 82, 80, 89, 87, 77,
 
505
255, 98, 99,101,102,103,104,255,109,119,118,120,121,126,116,255,
 
506
108, 67, 68, 69, 70, 95, 73, 75, 74, 79, 81, 82, 80, 89, 88, 77,
 
507
255, 98, 99,101,102,103,104,255,109,119,118,120,121,126,116,255,
 
508
};
 
509
 
 
510
static uint16 tab_8859_2_uni[256]={
 
511
     0,0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,
 
512
0x0008,0x0009,0x000A,0x000B,0x000C,0x000D,0x000E,0x000F,
 
513
0x0010,0x0011,0x0012,0x0013,0x0014,0x0015,0x0016,0x0017,
 
514
0x0018,0x0019,0x001A,0x001B,0x001C,0x001D,0x001E,0x001F,
 
515
0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,
 
516
0x0028,0x0029,0x002A,0x002B,0x002C,0x002D,0x002E,0x002F,
 
517
0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,
 
518
0x0038,0x0039,0x003A,0x003B,0x003C,0x003D,0x003E,0x003F,
 
519
0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,
 
520
0x0048,0x0049,0x004A,0x004B,0x004C,0x004D,0x004E,0x004F,
 
521
0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057,
 
522
0x0058,0x0059,0x005A,0x005B,0x005C,0x005D,0x005E,0x005F,
 
523
0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067,
 
524
0x0068,0x0069,0x006A,0x006B,0x006C,0x006D,0x006E,0x006F,
 
525
0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,
 
526
0x0078,0x0079,0x007A,0x007B,0x007C,0x007D,0x007E,     0,
 
527
     0,     0,     0,     0,     0,     0,     0,     0,
 
528
     0,     0,     0,     0,     0,     0,     0,     0,
 
529
     0,     0,     0,     0,     0,     0,     0,     0,
 
530
     0,     0,     0,     0,     0,     0,     0,     0,
 
531
0x00A0,0x0104,0x02D8,0x0141,0x00A4,0x013D,0x015A,0x00A7,
 
532
0x00A8,0x0160,0x015E,0x0164,0x0179,0x00AD,0x017D,0x017B,
 
533
0x00B0,0x0105,0x02DB,0x0142,0x00B4,0x013E,0x015B,0x02C7,
 
534
0x00B8,0x0161,0x015F,0x0165,0x017A,0x02DD,0x017E,0x017C,
 
535
0x0154,0x00C1,0x00C2,0x0102,0x00C4,0x0139,0x0106,0x00C7,
 
536
0x010C,0x00C9,0x0118,0x00CB,0x011A,0x00CD,0x00CE,0x010E,
 
537
0x0110,0x0143,0x0147,0x00D3,0x00D4,0x0150,0x00D6,0x00D7,
 
538
0x0158,0x016E,0x00DA,0x0170,0x00DC,0x00DD,0x0162,0x00DF,
 
539
0x0155,0x00E1,0x00E2,0x0103,0x00E4,0x013A,0x0107,0x00E7,
 
540
0x010D,0x00E9,0x0119,0x00EB,0x011B,0x00ED,0x00EE,0x010F,
 
541
0x0111,0x0144,0x0148,0x00F3,0x00F4,0x0151,0x00F6,0x00F7,
 
542
0x0159,0x016F,0x00FA,0x0171,0x00FC,0x00FD,0x0163,0x02D9
 
543
};
 
544
 
 
545
 
 
546
/* 0000-00FD , 254 chars */
 
547
static uchar tab_uni_8859_2_plane00[]={
 
548
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
 
549
0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
 
550
0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
 
551
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
 
552
0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
 
553
0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
 
554
0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
 
555
0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x00,
 
556
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 
557
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 
558
0xA0,0x00,0x00,0x00,0xA4,0x00,0x00,0xA7,0xA8,0x00,0x00,0x00,0x00,0xAD,0x00,0x00,
 
559
0xB0,0x00,0x00,0x00,0xB4,0x00,0x00,0x00,0xB8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 
560
0x00,0xC1,0xC2,0x00,0xC4,0x00,0x00,0xC7,0x00,0xC9,0x00,0xCB,0x00,0xCD,0xCE,0x00,
 
561
0x00,0x00,0x00,0xD3,0xD4,0x00,0xD6,0xD7,0x00,0x00,0xDA,0x00,0xDC,0xDD,0x00,0xDF,
 
562
0x00,0xE1,0xE2,0x00,0xE4,0x00,0x00,0xE7,0x00,0xE9,0x00,0xEB,0x00,0xED,0xEE,0x00,
 
563
0x00,0x00,0x00,0xF3,0xF4,0x00,0xF6,0xF7,0x00,0x00,0xFA,0x00,0xFC,0xFD};
 
564
 
 
565
/* 0102-017E , 125 chars */
 
566
static uchar tab_uni_8859_2_plane01[]={
 
567
0xC3,0xE3,0xA1,0xB1,0xC6,0xE6,0x00,0x00,0x00,0x00,0xC8,0xE8,0xCF,0xEF,0xD0,0xF0,
 
568
0x00,0x00,0x00,0x00,0x00,0x00,0xCA,0xEA,0xCC,0xEC,0x00,0x00,0x00,0x00,0x00,0x00,
 
569
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 
570
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC5,0xE5,0x00,0x00,0xA5,0xB5,0x00,0x00,0xA3,
 
571
0xB3,0xD1,0xF1,0x00,0x00,0xD2,0xF2,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xD5,0xF5,
 
572
0x00,0x00,0xC0,0xE0,0x00,0x00,0xD8,0xF8,0xA6,0xB6,0x00,0x00,0xAA,0xBA,0xA9,0xB9,
 
573
0xDE,0xFE,0xAB,0xBB,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xD9,0xF9,0xDB,0xFB,
 
574
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xAC,0xBC,0xAF,0xBF,0xAE,0xBE};
 
575
 
 
576
/* 02C7-02DD ,  23 chars */
 
577
static uchar tab_uni_8859_2_plane02[]={
 
578
0xB7,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 
579
0x00,0xA2,0xFF,0x00,0xB2,0x00,0xBD};
 
580
 
 
581
static MY_UNI_IDX idx_uni_8859_2[]={
 
582
  {0x0000,0x00FD,tab_uni_8859_2_plane00},
 
583
  {0x0102,0x017E,tab_uni_8859_2_plane01},
 
584
  {0x02C7,0x02DD,tab_uni_8859_2_plane02},
 
585
  {0,0,NULL}
 
586
};
 
587
 
 
588
 
 
589
static MY_COLLATION_HANDLER my_collation_latin2_czech_ci_handler =
 
590
{
 
591
  NULL,                 /* init */
 
592
  my_strnncoll_czech,
 
593
  my_strnncollsp_czech,
 
594
  my_strnxfrm_czech,
 
595
  my_strnxfrmlen_simple,
 
596
  my_like_range_czech,
 
597
  my_wildcmp_bin,
 
598
  my_strcasecmp_8bit,
 
599
  my_instr_simple,
 
600
  my_hash_sort_simple,
 
601
  my_propagate_simple
 
602
};
 
603
 
 
604
CHARSET_INFO my_charset_latin2_czech_ci =
 
605
{
 
606
    2,0,0,                                      /* number    */
 
607
    MY_CS_COMPILED|MY_CS_STRNXFRM|MY_CS_CSSORT, /* state     */
 
608
    "latin2",                                   /* cs name   */
 
609
    "latin2_czech_cs",                          /* name      */
 
610
    "",                                         /* comment   */
 
611
    NULL,                                       /* tailoring */
 
612
    ctype_czech,
 
613
    to_lower_czech,
 
614
    to_upper_czech,
 
615
    sort_order_czech,
 
616
    NULL,               /* contractions */
 
617
    NULL,               /* sort_order_big*/
 
618
    tab_8859_2_uni,     /* tab_to_uni   */
 
619
    idx_uni_8859_2,     /* tab_from_uni */
 
620
    my_unicase_default, /* caseinfo     */
 
621
    NULL,               /* state_map    */
 
622
    NULL,               /* ident_map    */
 
623
    4,                  /* strxfrm_multiply */
 
624
    1,                  /* caseup_multiply  */
 
625
    1,                  /* casedn_multiply  */
 
626
    1,                  /* mbminlen   */
 
627
    1,                  /* mbmaxlen  */
 
628
    0,                  /* min_sort_char */
 
629
    0,                  /* max_sort_char */
 
630
    ' ',                /* pad char      */
 
631
    0,                  /* escape_with_backslash_is_dangerous */
 
632
    &my_charset_8bit_handler,
 
633
    &my_collation_latin2_czech_ci_handler
 
634
};
 
635
 
 
636
 
 
637
#endif
 
638
 
 
639
#endif