?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed sz
[AROS.git] / workbench / locale / languages / templates / english.c
blob3ca707c4399756b31d497f4e8c9be453ce24ce3d
1 /*
2 Copyright © 1995-2013, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: english.language description file.
6 */
7 /*
8 Language description file for english.language.
9
10 So what is this thing?
11 Well basically it's a template for you to write
12 description files for your own language.
13
14 How is it done?
15 A language file is simply a shared library that
16 the locale.library loads into memory. The language
17 must define at least one function, which tells locale
18 which other functions it defines. This function has an
19 an LVO number of 5 (-30 on m68k/amiga). The function
20 has to return a mask which has a bit set for each
21 function that this library defines. Functions which
22 this library does not define are filled in by the
23 functions from the english.language definition
24 (which is essentially what this file defines).
25
26 What do I have to do?
27 You have to write functions for all the locale
28 functions which would be different for your
29 language. Typically this would be just function 3,
30 GetLangString(), which returns the string
31 returned by the locale.library function
32 GetLocaleStr().
33
34 There are some parts of this file which will also need to
35 be altered (language names and versions), but these will
36 be pointed out.
37
38 NOTE: This file should ideally be self-contained,
39 not relying upon any third party shared libraries.
40
41 In fact it is impossible to make library function
42 calls inside the locale support functions since you
43 will actually have no library base to work with.
44 */
45
46 #include <exec/types.h>
47 #include <exec/resident.h>
48 #include <exec/libraries.h>
49 #include <libraries/locale.h>
50
51 #include <proto/exec.h>
52 #include <aros/libcall.h>
53 #include <aros/asmcall.h>
54
55 /* -----------------------------------------------------------------------
56 CHANGES:
57 You will have to change all of these to suit your language,
58 these will be used in many definitions below.
59 */
60
61 #define LANGSTR "english" /* String version of above */
62 #define NLANGSTR "English" /* Native version of LANGSTR */
63 #define LANGVER 41 /* Version number of language */
64 #define LANGREV 2 /* Revision number of language */
65 #define LANGTAG "\0$VER: " LANGSTR ".language 41.2 (14.04.2013)"
66 #define NLANGTAG "$NLANG:" NLANGSTR
67
68 AROS_LD1(STRPTR, getlangstring,
69 AROS_LHA(ULONG, id, D0),
70 struct LocaleBase *, LocaleBase, 9, language);
71
72 /* ----------------------------------------------------------------------- */
73
74 /* Bit masks for locale .language functions. */
75 #define LF_ConvToLower (1L << 0)
76 #define LF_ConvToUpper (1L << 1)
77 #define LF_Private2 (1L << 2)
78 #define LF_GetLangStr (1L << 3)
79 #define LF_IsAlNum (1L << 4)
80 #define LF_IsAlpha (1L << 5)
81 #define LF_IsCntrl (1L << 6)
82 #define LF_IsDigit (1L << 7)
83 #define LF_IsGraph (1L << 8)
84 #define LF_IsLower (1L << 9)
85 #define LF_IsPrint (1L << 10)
86 #define LF_IsPunct (1L << 11)
87 #define LF_IsSpace (1L << 12)
88 #define LF_IsUpper (1L << 13)
89 #define LF_IsXDigit (1L << 14)
90 #define LF_ToUpper (1L << 15)
91 #define LF_StringComp (1L << 16)
92
93 /* Arrays for english/Latin1 character type/conversion, defined later */
94 extern const UWORD __eng_ctype_array[];
95 extern const ULONG __eng_to_lower[];
96 extern const ULONG __eng_to_upper[];
97 extern const STRPTR __eng_strings[];
98 extern const ULONG __eng_collate_tab[];
99
100 /* We use these to indicate whether a character is a certain type in the
101 character array.
102 */
103 #define iAlpha (1 << 0)
104 #define iCntrl (1 << 1)
105 #define iDigit (1 << 2)
106 #define iGraph (1 << 3)
107 #define iLower (1 << 4)
108 #define iPrint (1 << 5)
109 #define iPunct (1 << 6)
110 #define iSpace (1 << 7)
111 #define iUpper (1 << 8)
112 #define iXDigit (1 << 9)
113
114 /* -------------------------------------------------------------------------
115 Library definition, you should not need to change any of this.
116 ------------------------------------------------------------------------- */
117
118 struct Language
119 {
120 struct Library library;
121 APTR sysbase;
122 BPTR seglist;
123 };
124
125 extern const UBYTE name[];
126 extern const UBYTE version[];
127 extern const APTR inittabl[4];
128 extern void *const functable[];
129 extern const ULONG datatable;
130 extern struct Language *AROS_SLIB_ENTRY(init,language,0)();
131 AROS_LD1(struct Language *, open,
132 AROS_LHA(ULONG, version, D0),
133 struct Language *, language, 1, language);
134 AROS_LD0(BPTR, close, struct Language *, language, 2, language);
135 AROS_LD0(BPTR, expunge, struct Language *, language, 3, language);
136 AROS_LD0I(int, null, struct Language *, language, 0, language);
137 AROS_LD0(ULONG, mask, struct Language *, language, 5, language);
138 extern const char end;
139
140 int entry(void)
141 {
142 return -1;
143 }
144
145 const struct Resident languageTag =
146 {
147 RTC_MATCHWORD,
148 (struct Resident *)&languageTag,
149 (APTR)&end,
150 RTF_AUTOINIT,
151 LANGVER,
152 NT_LIBRARY,
153 -120,
154 (STRPTR)name,
155 (STRPTR)&version[6],
156 (ULONG *)inittabl
157 };
158
159 const UBYTE name[]=LANGSTR ".language";
160 const UBYTE nativelang[]=NLANGTAG; /* N.B - MUST come before $VER: */
161 const UBYTE version[]=LANGTAG;
162
163 const ULONG datatable = 0;
164
165 const APTR inittabl[4] =
166 {
167 (APTR)sizeof(struct Language),
168 (APTR)functable,
169 (APTR)datatable,
170 &AROS_SLIB_ENTRY(init,language,0)
171 };
172
173 AROS_UFH3(struct Language *, AROS_SLIB_ENTRY(init,language,0),
174 AROS_UFHA(struct Language *, language, D0),
175 AROS_UFHA(BPTR, segList, A0),
176 AROS_UFHA(struct ExecBase *, _SysBase, A6)
177 )
178 {
179 AROS_USERFUNC_INIT
180
181 /*
182 You could just as easily do this bit as the InitResident()
183 datatable, however this works just as well.
184 */
185 language->library.lib_Node.ln_Type = NT_LIBRARY;
186 language->library.lib_Node.ln_Pri = -120;
187 language->library.lib_Node.ln_Name = (char *)name;
188 language->library.lib_Flags = LIBF_SUMUSED | LIBF_CHANGED;
189 language->library.lib_Version = LANGVER;
190 language->library.lib_Revision = LANGREV;
191 language->library.lib_IdString = (APTR)&version[6];
192
193 language->seglist = segList;
194 language->sysbase = _SysBase;
195
196 /*
197 Although it is unlikely, you would return NULL if you for some
198 unknown reason couldn't open.
199 */
200
201 return language;
202
203 AROS_USERFUNC_EXIT
204 }
205
206 #define SysBase language->sysbase
207
208 AROS_LH1(struct Language *, open,
209 AROS_LHA(ULONG, version, D0),
210 struct Language *, language, 1, language)
211 {
212 AROS_LIBFUNC_INIT
213
214 language->library.lib_OpenCnt++;
215 language->library.lib_Flags &= ~LIBF_DELEXP;
216
217 /* Again return NULL if you could not open */
218 return language;
219
220 AROS_LIBFUNC_EXIT
221 }
222
223 AROS_LH0(BPTR, close, struct Language *, language, 2, language)
224 {
225 AROS_LIBFUNC_INIT
226 if(! --language->library.lib_OpenCnt)
227 {
228 /* Delayed expunge pending? */
229 if(language->library.lib_Flags & LIBF_DELEXP)
230 {
231 /* Yes, expunge the library */
232 return AROS_LC0(BPTR, expunge, struct Language *, language, 3, language);
233 }
234 return NULL;
235 }
236 AROS_LIBFUNC_EXIT
237 }
238
239 AROS_LH0(BPTR, expunge, struct Language *, language, 3, language)
240 {
241 AROS_LIBFUNC_INIT
242
243 struct ExecBase *SysBase = language->sysbase;
244
245 BPTR ret;
246 if(language->library.lib_OpenCnt)
247 {
248 /* Can't expunge, we are still open */
249 language->library.lib_Flags |= LIBF_DELEXP;
250 return 0;
251 }
252
253 Remove(&language->library.lib_Node);
254 ret = language->seglist;
255
256 FreeMem((UBYTE *)language - language->library.lib_NegSize,
257 language->library.lib_PosSize + language->library.lib_NegSize);
258
259 return ret;
260
261 AROS_LIBFUNC_EXIT
262 }
263
264 AROS_LH0I(int, null, struct Language *, language, 4, language)
265 {
266 AROS_LIBFUNC_INIT
267
268 return 0;
269
270 AROS_LIBFUNC_EXIT
271 }
272
273 /* ------------------------------------------------------------------------
274 Language specific functions
275 ------------------------------------------------------------------------ */
276
277 /* ULONG LanguageMask():
278 This function is to inform locale.library what functions it should
279 use from this library. This is done by returning a bitmask containing
280 1's for functions to use, and 0's for functions to ignore.
281
282 Unused bits MUST be 0 for future compatibility.
283 */
284 AROS_LH0(ULONG, mask, struct Language *, language, 5, language)
285 {
286 AROS_LIBFUNC_INIT
287
288 /* CHANGES:
289 This is where you list which functions that this language
290 specifies. There are some bit masks which can be used for
291 simplicity.
292
293 Most languages will probably only need to implement
294 LF_GetLangStr
295 */
296 return ( LF_ConvToLower | LF_ConvToUpper
297 | LF_GetLangStr
298 | LF_IsAlNum | LF_IsAlpha | LF_IsCntrl | LF_IsDigit
299 | LF_IsGraph | LF_IsLower | LF_IsPrint | LF_IsPunct
300 | LF_IsSpace | LF_IsXDigit
301 | LF_StringConv | LF_StringComp
302 );
303
304 AROS_LIBFUNC_EXIT
305 }
306
307 /* ULONG ConvToLower(ULONG char): Language function 0
308 This function converts the character char to the equivalent
309 lower case value.
310 */
311 AROS_LH1(ULONG, convtolower,
312 AROS_LHA(ULONG, chr, D0),
313 struct LocaleBase *, LocaleBase, 6, language)
314 {
315 AROS_LIBFUNC_INIT
316
317 return __eng_to_lower[chr];
318
319 AROS_LIBFUNC_EXIT
320 }
321
322 /* ULONG ConvToUpper(ULONG char): Language Function 1
323 This function converts the character char to the equivalent
324 upper case character.
325 */
326 AROS_LH1(ULONG, convtoupper,
327 AROS_LHA(ULONG, chr, D0),
328 struct LocaleBase *, LocaleBase, 7, language)
329 {
330 AROS_LIBFUNC_INIT
331
332 return __eng_to_upper[chr];
333
334 AROS_LIBFUNC_EXIT
335 }
336
337 /* STRPTR GetLangString(ULONG num): Language function 3
338 This function is called by GetLocaleStr() and should return
339 the string matching the string id passed in as num.
340 */
341 AROS_LH1(STRPTR, getlangstring,
342 AROS_LHA(ULONG, id, D0),
343 struct LocaleBase *, LocaleBase, 9, language)
344 {
345 AROS_LIBFUNC_INIT
346
347 if(id < MAXSTRMSG)
348 return __eng_strings[id];
349 else
350 return NULL;
351
352 AROS_LIBFUNC_EXIT
353 }
354
355 /* BOOL IsXXXXX(ULONG char): Language functions 4-14
356 These function are the same as the ANSI C isxxxxx() functions,
357 however these will pay extra attention to the current language.
358
359 This gives the advantage of using different character sets,
360 however I wouldn't recommend that, since you will have funny
361 font problems.
362 */
363
364 AROS_LH1(BOOL, isalnum,
365 AROS_LHA(ULONG, chr, D0),
366 struct LocaleBase *, LocaleBase, 10, language)
367 {
368 AROS_LIBFUNC_INIT
369
370 return (BOOL)(
371 (__eng_ctype_array[chr] & iAlpha) || (__eng_ctype_array[chr] & iDigit)
372 );
373
374 AROS_LIBFUNC_EXIT
375 }
376
377 AROS_LH1(BOOL, isalpha,
378 AROS_LHA(ULONG, chr, D0),
379 struct LocaleBase *, LocaleBase, 11, language)
380 {
381 AROS_LIBFUNC_INIT
382
383 return (BOOL)(__eng_ctype_array[chr] & iAlpha);
384
385 AROS_LIBFUNC_EXIT
386 }
387
388 AROS_LH1(BOOL, iscntrl,
389 AROS_LHA(ULONG, chr, D0),
390 struct LocaleBase *, LocaleBase, 12, language)
391 {
392 AROS_LIBFUNC_INIT
393
394 return (BOOL)(__eng_ctype_array[chr] & iCntrl);
395
396 AROS_LIBFUNC_EXIT
397 }
398
399 AROS_LH1(BOOL, isdigit,
400 AROS_LHA(ULONG, chr, D0),
401 struct LocaleBase *, LocaleBase, 13, language)
402 {
403 AROS_LIBFUNC_INIT
404
405 return (BOOL)(__eng_ctype_array[chr] & iDigit);
406
407 AROS_LIBFUNC_EXIT
408 }
409
410 AROS_LH1(BOOL, isgraph,
411 AROS_LHA(ULONG, chr, D0),
412 struct LocaleBase *, LocaleBase, 14, language)
413 {
414 AROS_LIBFUNC_INIT
415
416 return (BOOL)(__eng_ctype_array[chr] & iGraph);
417
418 AROS_LIBFUNC_EXIT
419 }
420
421 AROS_LH1(BOOL, islower,
422 AROS_LHA(ULONG, chr, D0),
423 struct LocaleBase *, LocaleBase, 15, language)
424 {
425 AROS_LIBFUNC_INIT
426
427 return (BOOL)(__eng_ctype_array[chr] & iLower);
428
429 AROS_LIBFUNC_EXIT
430 }
431
432 AROS_LH1(BOOL, isprint,
433 AROS_LHA(ULONG, chr, D0),
434 struct LocaleBase *, LocaleBase, 16, language)
435 {
436 AROS_LIBFUNC_INIT
437
438 return (BOOL)(__eng_ctype_array[chr] & iPrint);
439
440 AROS_LIBFUNC_EXIT
441 }
442
443 AROS_LH1(BOOL, ispunct,
444 AROS_LHA(ULONG, chr, D0),
445 struct LocaleBase *, LocaleBase, 17, language)
446 {
447 AROS_LIBFUNC_INIT
448
449 return (BOOL)(__eng_ctype_array[chr] & iPunct);
450
451 AROS_LIBFUNC_EXIT
452 }
453
454 AROS_LH1(BOOL, isspace,
455 AROS_LHA(ULONG, chr, D0),
456 struct LocaleBase *, LocaleBase, 18, language)
457 {
458 AROS_LIBFUNC_INIT
459
460 return (BOOL)(__eng_ctype_array[chr] & iSpace);
461
462 AROS_LIBFUNC_EXIT
463 }
464
465 AROS_LH1(BOOL, isupper,
466 AROS_LHA(ULONG, chr, D0),
467 struct LocaleBase *, LocaleBase, 19, language)
468 {
469 AROS_LIBFUNC_INIT
470
471 return (BOOL)(__eng_ctype_array[chr] & iUpper);
472
473 AROS_LIBFUNC_EXIT
474 }
475
476 AROS_LH1(BOOL, isxdigit,
477 AROS_LHA(ULONG, chr, D0),
478 struct LocaleBase *, LocaleBase, 20, language)
479 {
480 AROS_LIBFUNC_INIT
481
482 return (BOOL)(__eng_ctype_array[chr] & iXDigit);
483
484 AROS_LIBFUNC_EXIT
485 }
486
487 /* ULONG strconvert(STRPTR s1, STRPTR s2, LONG len, ULONG typ): LF 15
488 This function will convert a string to automatically use the
489 collation table. This is a bit dodgy in my opinion, however the ANSI
490 people didn't think so...
491
492 For SC_ASCII and SC_COLLATE1 this is just convert the string as is.
493 If you use SC_COLLATE2 this does SC_COLLATE1 encoding, the repeats
494 the string as is...
495 */
496 AROS_LH4(ULONG, strconvert,
497 AROS_LHA(STRPTR, string1, A1),
498 AROS_LHA(STRPTR, string2, A2),
499 AROS_LHA(LONG, length, D0),
500 AROS_LHA(ULONG, type, D1),
501 struct LocaleBase *, LocaleBase, 21, english)
502 {
503 AROS_LIBFUNC_INIT
504
505 ULONG count = 0;
506
507 if(type == SC_COLLATE2)
508 {
509 STRPTR origS1;
510
511 while(--length && *string1)
512 {
513 *string2++ = __eng_collate_tab[(UBYTE)*string1];
514 count++;
515 }
516 while(--length && *origS1)
517 {
518 *string2++ = *origS1++;
519 count++;
520 }
521 *string2 = '\0';
522 }
523 else if((type == SC_COLLATE1) || (type == SC_ASCII))
524 {
525 STRPTR collTab;
526
527 if(type == SC_ASCII)
528 collTab = __eng_to_upper;
529 else
530 collTab = __eng_collate_tab;
531
532 while(--length && *string1)
533 {
534 *string2++ = collTab[ (UBYTE)*string1 ];
535 count++;
536 }
537 *string2 = '\0';
538 }
539 return count;
540
541 AROS_LIBFUNC_EXIT
542 }
543
544 /* LONG strcompare(STRPTR s1, STRPTR s2, LONG len, ULONG typ): LF 16
545 This function will do the comparison using either plain ASCII
546 or the collation information. This is explained more in
547 the data file, or in the autodoc...
548 */
549 AROS_LH4(LONG, strcompare,
550 AROS_LHA(STRPTR, string1, A1),
551 AROS_LHA(STRPTR, string2, A2),
552 AROS_LHA(LONG, length, D0),
553 AROS_LHA(ULONG, type, D1),
554 struct LocaleBase *, LocaleBase, 22, english)
555 {
556 AROS_LIBFUNC_INIT
557 ULONG a, b;
558
559 if(type == SC_COLLATE2)
560 {
561 /* Collate 2, a bit more difficult */
562 STRPTR origS1, origS2;
563
564 origS1 = string1;
565 origS2 = string2;
566 do
567 {
568 a = colltab[(UBYTE)*string1++];
569 b = colltab[(UBYTE)*string2++];
570 } while( (a == b) && --length);
571
572 /* If we reached the end, and everything is the same */
573 if((a == 0) && (a == b))
574 {
575 /* Compare again using strings as is... */
576 do
577 {
578 a = *origS1++;
579 b = *origS2++;
580 } while( (a == b) && --length);
581 }
582 return a - b;
583 }
584 else if((type == SC_COLLATE1) || (SC_ASCII))
585 {
586 ULONG *colltab;
587
588 /* Determine which collation table to use... */
589 if(type == SC_ASCII)
590 colltab = __eng_to_upper;
591 else
592 colltab = __eng_collate_tab;
593
594 do
595 {
596 a = colltab[(UBYTE)*string1++];
597 b = colltab[(UBYTE)*string2++];
598 } while( (a == b) && --length);
599 return a - b;
600 }
601
602 /* Ha: Wrong arguments... */
603 return 0;
604 AROS_LIBFUNC_EXIT
605 }
606
607 /* -----------------------------------------------------------------------
608 Library function table - you will need to alter this
609 I have this right here at the end of the library so that I do not
610 have to have prototypes for the functions. Although you could do that.
611 ----------------------------------------------------------------------- */
612
613 void *const functable[] =
614 {
615 &AROS_SLIB_ENTRY(open,language,1),
616 &AROS_SLIB_ENTRY(close,language,2),
617 &AROS_SLIB_ENTRY(expunge,language,3),
618 &AROS_SLIB_ENTRY(null,language,0),
619 &AROS_SLIB_ENTRY(mask,language,5),
620
621 /*
622 CHANGES:
623 This is where language specific functions must go.
624 If this language doesn't require a specific function
625 you must still define the entry. You should make this a
626 function which just returns 0. For the moment, using
627 &AROS_SLIB_ENTRY(null, language) will suffice, however
628 watch out if that function is ever given a purpose.
629
630 You need only include enough vectors to correspond to
631 all of your entries.
632 */
633
634 /* 0 - 3 */
635 &AROS_SLIB_ENTRY(convtolower, language, 6),
636 &AROS_SLIB_ENTRY(convtoupper, language, 7),
637 &AROS_SLIB_ENTRY(null, language, 0),
638 &AROS_SLIB_ENTRY(getlangstring, language, 9),
639
640 /* 4 - 7 */
641 &AROS_SLIB_ENTRY(isalnum, language, 10),
642 &AROS_SLIB_ENTRY(isalpha, language, 11),
643 &AROS_SLIB_ENTRY(iscntrl, language, 12),
644 &AROS_SLIB_ENTRY(isdigit, language, 13),
645
646 /* 8 - 11 */
647 &AROS_SLIB_ENTRY(isgraph, language, 14),
648 &AROS_SLIB_ENTRY(islower, language, 15),
649 &AROS_SLIB_ENTRY(isprint, language, 16),
650 &AROS_SLIB_ENTRY(isspace, language, 17),
651
652 /* 12 - 15 */
653 &AROS_SLIB_ENTRY(ispunct, language, 18),
654 &AROS_SLIB_ENTRY(isupper, language, 19),
655 &AROS_SLIB_ENTRY(isxdigit, language, 20),
656 &AROS_SLIB_ENTRY(stringconv, language, 21),
657
658 /* 16 */
659 &AROS_SLIB_ENTRY(stringcomp, language, 22),
660
661 (void *)-1
662 };
663
664 /*
665 Most languages do not need most of this data. If your languages
666 uses the same codeset as english (ISO-8859-1/ECMA Latin 1), then
667 by allowing the English code to do all the work (see Mask() function)
668 you can reduce this file to just the strings.
669
670 ----------------------------------------------------------------------
671
672 This is the list of strings. It is an array of pointers to strings,
673 although how it is laid out is implementation dependant.
674 */
675 const STRPTR __eng_strings[] =
676 {
677 /* A blank string */
678 "",
679
680 /* The days of the week. Starts with the first day of the week.
681 In English this would be Sunday, this depends upon the settings
682 of Locale->CalendarType.
683 */
684 "Sunday", "Monday", "Tuesday", "Wednesday",
685 "Thursday", "Friday", "Saturday",
686
687 /* Abbreviated days of the week */
688 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
689
690 /* Months of the year */
691 "January", "February", "March",
692 "April", "May", "June",
693 "July", "August", "September",
694 "October", "November", "December",
695
696 /* Abbreviated months of the year */
697 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
698 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
699
700 "Yes", /* Yes, affirmative response */
701 "No", /* No/negative response */
702
703 /* AM/PM strings AM 0000 -> 1159, PM 1200 -> 2359 */
704 "am", "pm",
705
706 /* Soft and hard hyphens */
707 "-", "-",
708
709 /* Open and close quotes */
710 "\"", "\"",
711
712 /* Days: But not actual day names
713 Yesterday - the day before the current
714 Today - the current day
715 Tomorrow - the next day
716 Future.
717 */
718 "Yesterday", "Today", "Tomorrow", "Future"
719 };
720
721 /* Array for the IsXXXXX() functions*/
722 const UWORD __eng_ctype_array[256] =
723 {
724 /* 0 */ iCntrl,
725 /* 1 */ iCntrl,
726 /* 2 */ iCntrl,
727 /* 3 */ iCntrl,
728 /* 4 */ iCntrl,
729 /* 5 */ iCntrl,
730 /* 6 */ iCntrl,
731 /* 7 */ iCntrl,
732 /* 8 */ iCntrl,
733 /* 9 */ iCntrl | iPrint | iSpace,
734 /* 10 */ iCntrl | iPrint | iSpace,
735 /* 11 */ iCntrl | iPrint | iSpace,
736 /* 12 */ iCntrl | iPrint | iSpace,
737 /* 13 */ iCntrl | iPrint | iSpace,
738 /* 14 */ iCntrl,
739 /* 15 */ iCntrl,
740 /* 16 */ iCntrl,
741 /* 17 */ iCntrl,
742 /* 18 */ iCntrl,
743 /* 19 */ iCntrl,
744 /* 20 */ iCntrl,
745 /* 21 */ iCntrl,
746 /* 22 */ iCntrl,
747 /* 23 */ iCntrl,
748 /* 24 */ iCntrl,
749 /* 25 */ iCntrl,
750 /* 26 */ iCntrl,
751 /* 27 */ iCntrl,
752 /* 28 */ iCntrl,
753 /* 29 */ iCntrl,
754 /* 30 */ iCntrl,
755 /* 31 */ iCntrl,
756 /* 32 */ iPrint | iSpace,
757 /* '!' */ iGraph | iPrint | iPunct,
758 /* '"' */ iGraph | iPrint | iPunct,
759 /* '#' */ iGraph | iPrint | iPunct,
760 /* '$' */ iGraph | iPrint | iPunct,
761 /* '%' */ iGraph | iPrint | iPunct,
762 /* '&' */ iGraph | iPrint | iPunct,
763 /* ''' */ iGraph | iPrint | iPunct,
764 /* '(' */ iGraph | iPrint | iPunct,
765 /* ')' */ iGraph | iPrint | iPunct,
766 /* '*' */ iGraph | iPrint | iPunct,
767 /* '+' */ iGraph | iPrint | iPunct,
768 /* ',' */ iGraph | iPrint | iPunct,
769 /* '-' */ iGraph | iPrint | iPunct,
770 /* '.' */ iGraph | iPrint | iPunct,
771 /* '/' */ iGraph | iPrint | iPunct,
772 /* '0' */ iDigit | iGraph | iPrint | iXDigit,
773 /* '1' */ iDigit | iGraph | iPrint | iXDigit,
774 /* '2' */ iDigit | iGraph | iPrint | iXDigit,
775 /* '3' */ iDigit | iGraph | iPrint | iXDigit,
776 /* '4' */ iDigit | iGraph | iPrint | iXDigit,
777 /* '5' */ iDigit | iGraph | iPrint | iXDigit,
778 /* '6' */ iDigit | iGraph | iPrint | iXDigit,
779 /* '7' */ iDigit | iGraph | iPrint | iXDigit,
780 /* '8' */ iDigit | iGraph | iPrint | iXDigit,
781 /* '9' */ iDigit | iGraph | iPrint | iXDigit,
782 /* ':' */ iGraph | iPrint | iPunct,
783 /* ';' */ iGraph | iPrint | iPunct,
784 /* '<' */ iGraph | iPrint | iPunct,
785 /* '=' */ iGraph | iPrint | iPunct,
786 /* '>' */ iGraph | iPrint | iPunct,
787 /* '?' */ iGraph | iPrint | iPunct,
788 /* '@' */ iGraph | iPrint | iPunct,
789 /* 'A' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
790 /* 'B' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
791 /* 'C' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
792 /* 'D' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
793 /* 'E' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
794 /* 'F' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
795 /* 'G' */ iAlpha | iGraph | iPrint | iUpper,
796 /* 'H' */ iAlpha | iGraph | iPrint | iUpper,
797 /* 'I' */ iAlpha | iGraph | iPrint | iUpper,
798 /* 'J' */ iAlpha | iGraph | iPrint | iUpper,
799 /* 'K' */ iAlpha | iGraph | iPrint | iUpper,
800 /* 'L' */ iAlpha | iGraph | iPrint | iUpper,
801 /* 'M' */ iAlpha | iGraph | iPrint | iUpper,
802 /* 'N' */ iAlpha | iGraph | iPrint | iUpper,
803 /* 'O' */ iAlpha | iGraph | iPrint | iUpper,
804 /* 'P' */ iAlpha | iGraph | iPrint | iUpper,
805 /* 'Q' */ iAlpha | iGraph | iPrint | iUpper,
806 /* 'R' */ iAlpha | iGraph | iPrint | iUpper,
807 /* 'S' */ iAlpha | iGraph | iPrint | iUpper,
808 /* 'T' */ iAlpha | iGraph | iPrint | iUpper,
809 /* 'U' */ iAlpha | iGraph | iPrint | iUpper,
810 /* 'V' */ iAlpha | iGraph | iPrint | iUpper,
811 /* 'W' */ iAlpha | iGraph | iPrint | iUpper,
812 /* 'X' */ iAlpha | iGraph | iPrint | iUpper,
813 /* 'Y' */ iAlpha | iGraph | iPrint | iUpper,
814 /* 'Z' */ iAlpha | iGraph | iPrint | iUpper,
815 /* '[' */ iGraph | iPrint | iPunct,
816 /* '\' */ iGraph | iPrint | iPunct,
817 /* ']' */ iGraph | iPrint | iPunct,
818 /* '^' */ iGraph | iPrint | iPunct,
819 /* '_' */ iGraph | iPrint | iPunct,
820 /* '`' */ iGraph | iPrint | iPunct,
821 /* 'a' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
822 /* 'b' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
823 /* 'c' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
824 /* 'd' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
825 /* 'e' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
826 /* 'f' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
827 /* 'g' */ iAlpha | iGraph | iLower | iPrint,
828 /* 'h' */ iAlpha | iGraph | iLower | iPrint,
829 /* 'i' */ iAlpha | iGraph | iLower | iPrint,
830 /* 'j' */ iAlpha | iGraph | iLower | iPrint,
831 /* 'k' */ iAlpha | iGraph | iLower | iPrint,
832 /* 'l' */ iAlpha | iGraph | iLower | iPrint,
833 /* 'm' */ iAlpha | iGraph | iLower | iPrint,
834 /* 'n' */ iAlpha | iGraph | iLower | iPrint,
835 /* 'o' */ iAlpha | iGraph | iLower | iPrint,
836 /* 'p' */ iAlpha | iGraph | iLower | iPrint,
837 /* 'q' */ iAlpha | iGraph | iLower | iPrint,
838 /* 'r' */ iAlpha | iGraph | iLower | iPrint,
839 /* 's' */ iAlpha | iGraph | iLower | iPrint,
840 /* 't' */ iAlpha | iGraph | iLower | iPrint,
841 /* 'u' */ iAlpha | iGraph | iLower | iPrint,
842 /* 'v' */ iAlpha | iGraph | iLower | iPrint,
843 /* 'w' */ iAlpha | iGraph | iLower | iPrint,
844 /* 'x' */ iAlpha | iGraph | iLower | iPrint,
845 /* 'y' */ iAlpha | iGraph | iLower | iPrint,
846 /* 'z' */ iAlpha | iGraph | iLower | iPrint,
847 /* '{' */ iGraph | iPrint | iPunct,
848 /* '|' */ iGraph | iPrint | iPunct,
849 /* '}' */ iGraph | iPrint | iPunct,
850 /* '~' */ iGraph | iPrint | iPunct,
851 /* 127 */ iCntrl,
852 /* 128 */ iCntrl,
853 /* 129 */ iCntrl,
854 /* 130 */ iCntrl,
855 /* 131 */ iCntrl,
856 /* 132 */ iCntrl,
857 /* 133 */ iCntrl,
858 /* 134 */ iCntrl,
859 /* 135 */ iCntrl,
860 /* 136 */ iCntrl,
861 /* 137 */ iCntrl,
862 /* 138 */ iCntrl,
863 /* 139 */ iCntrl,
864 /* 140 */ iCntrl,
865 /* 141 */ iCntrl,
866 /* 142 */ iCntrl,
867 /* 143 */ iCntrl,
868 /* 144 */ iCntrl,
869 /* 145 */ iCntrl,
870 /* 146 */ iCntrl,
871 /* 147 */ iCntrl,
872 /* 148 */ iCntrl,
873 /* 149 */ iCntrl,
874 /* 150 */ iCntrl,
875 /* 151 */ iCntrl,
876 /* 152 */ iCntrl,
877 /* 153 */ iCntrl,
878 /* 154 */ iCntrl,
879 /* 155 */ iCntrl,
880 /* 156 */ iCntrl,
881 /* 157 */ iCntrl,
882 /* 158 */ iCntrl,
883 /* 159 */ iCntrl,
884 /* 160 */ iPrint | iSpace,
885 /* '°' */ iGraph | iPrint | iPunct,
886 /* '¢' */ iGraph | iPrint | iPunct,
887 /* '£' */ iGraph | iPrint | iPunct,
888 /* '§' */ iGraph | iPrint | iPunct,
889 /* '€' */ iGraph | iPrint | iPunct,
890 /* '¶' */ iGraph | iPrint | iPunct,
891 /* 'ß' */ iAlpha | iGraph | iPrint | iLower,
892 /* '®' */ iGraph | iPrint | iPunct,
893 /* '©' */ iGraph | iPrint | iPunct,
894 /* '�' */ iGraph | iPrint | iPunct,
895 /* '´' */ iGraph | iPrint | iPunct,
896 /* '¨' */ iGraph | iPrint | iPunct,
897 /* '‚' */ iGraph | iPrint | iPunct,
898 /* 'Æ' */ iAlpha | iGraph | iPrint | iUpper,
899 /* 'Ø' */ iAlpha | iGraph | iPrint | iUpper,
900 /* 'ƒ' */ iGraph | iPrint | iPunct,
901 /* '±' */ iGraph | iPrint | iPunct,
902 /* '¾' */ iDigit | iGraph | iPrint,
903 /* '„' */ iGraph | iPrint | iPunct,
904 /* '¥' */ iGraph | iPrint | iPunct,
905 /* 'µ' */ iGraph | iPrint | iPunct,
906 /* '�' */ iGraph | iPrint | iPunct,
907 /* '…' */ iGraph | iPrint | iPunct,
908 /* '½' */ iDigit | iGraph | iPrint,
909 /* '¼' */ iDigit | iGraph | iPrint,
910 /* '†' */ iGraph | iPrint | iPunct,
911 /* 'ª' */ iGraph | iPrint | iPunct,
912 /* 'º' */ iGraph | iPrint | iPunct,
913 /* '‡' */ iGraph | iPrint | iPunct,
914 /* 'æ' */ iAlpha | iGraph | iPrint | iLower,
915 /* 'ø' */ iAlpha | iGraph | iPrint | iLower,
916 /* '¿' */ iGraph | iPrint | iPunct,
917 /* '¡' */ iGraph | iPrint | iPunct,
918 /* '¬' */ iAlpha | iGraph | iPrint | iUpper,
919 /* 'ˆ' */ iAlpha | iGraph | iPrint | iUpper,
920 /* 'Ÿ' */ iAlpha | iGraph | iPrint | iUpper,
921 /* '‰' */ iAlpha | iGraph | iPrint | iUpper,
922 /* '�' */ iAlpha | iGraph | iPrint | iUpper,
923 /* '«' */ iGraph | iPrint | iPunct,
924 /* '»' */ iGraph | iPrint | iPunct,
925 /* 'Š' */ iAlpha | iGraph | iPrint | iUpper,
926 /* ' ' */ iAlpha | iGraph | iPrint | iUpper,
927 /* 'À' */ iAlpha | iGraph | iPrint | iUpper,
928 /* 'Ã' */ iAlpha | iGraph | iPrint | iUpper,
929 /* 'Õ' */ iAlpha | iGraph | iPrint | iUpper,
930 /* '‘' */ iAlpha | iGraph | iPrint | iUpper,
931 /* '¦' */ iAlpha | iGraph | iPrint | iUpper,
932 /* '­' */ iAlpha | iGraph | iPrint | iUpper,
933 /* '‹' */ iAlpha | iGraph | iPrint | iUpper,
934 /* '³' */ iDigit | iGraph | iPrint,
935 /* '²' */ iDigit | iGraph | iPrint,
936 /* 'Œ' */ iAlpha | iGraph | iPrint | iUpper,
937 /* '¹' */ iDigit | iGraph | iPrint,
938 /* '÷' */ iPunct | iGraph | iPrint,
939 /* '×' */ iPunct | iGraph | iPrint,
940 /* 'ÿ' */ iAlpha | iGraph | iPrint | iUpper,
941 /* '�' */ iAlpha | iGraph | iPrint | iUpper,
942 /* 'Ž' */ iAlpha | iGraph | iPrint | iUpper,
943 /* '¤' */ iAlpha | iGraph | iPrint | iUpper,
944 /* 'Ð' */ iAlpha | iGraph | iPrint | iUpper,
945 /* 'ð' */ iAlpha | iGraph | iPrint | iLower,
946 /* 'Þ' */ iAlpha | iGraph | iPrint | iUpper,
947 /* 'þ' */ iAlpha | iGraph | iLower | iPrint,
948 /* 'ý' */ iAlpha | iGraph | iLower | iPrint,
949 /* '·' */ iAlpha | iGraph | iLower | iPrint,
950 /* '’' */ iAlpha | iGraph | iLower | iPrint,
951 /* '“' */ iAlpha | iGraph | iLower | iPrint,
952 /* '”' */ iAlpha | iGraph | iLower | iPrint,
953 /* 'Â' */ iAlpha | iGraph | iLower | iPrint,
954 /* 'Ê' */ iAlpha | iGraph | iLower | iPrint,
955 /* 'Á' */ iAlpha | iGraph | iLower | iPrint,
956 /* 'Ë' */ iAlpha | iGraph | iLower | iPrint,
957 /* 'È' */ iAlpha | iGraph | iLower | iPrint,
958 /* 'Í' */ iAlpha | iGraph | iLower | iPrint,
959 /* 'Î' */ iAlpha | iGraph | iLower | iPrint,
960 /* 'Ï' */ iAlpha | iGraph | iLower | iPrint,
961 /* 'Ì' */ iAlpha | iGraph | iLower | iPrint,
962 /* 'Ó' */ iAlpha | iGraph | iLower | iPrint,
963 /* 'Ô' */ iAlpha | iGraph | iLower | iPrint,
964 /* '•' */ iAlpha | iGraph | iLower | iPrint,
965 /* 'Ò' */ iAlpha | iGraph | iLower | iPrint,
966 /* 'Ú' */ iAlpha | iGraph | iLower | iPrint,
967 /* 'Û' */ iAlpha | iGraph | iLower | iPrint,
968 /* 'Ù' */ iAlpha | iGraph | iLower | iPrint,
969 /* 'ž' */ iAlpha | iGraph | iLower | iPrint,
970 /* '–' */ iAlpha | iGraph | iLower | iPrint,
971 /* '—' */ iGraph | iPrint | iPunct,
972 /* '¯' */ iAlpha | iGraph | iLower | iPrint,
973 /* '˜' */ iAlpha | iGraph | iLower | iPrint,
974 /* '™' */ iAlpha | iGraph | iLower | iPrint,
975 /* 'š' */ iAlpha | iGraph | iLower | iPrint,
976 /* '¸' */ iAlpha | iGraph | iLower | iPrint,
977 /* '›' */ iAlpha | iGraph | iLower | iPrint,
978 /* 'œ' */ iAlpha | iGraph | iLower | iPrint,
979 /* '�' */ iAlpha | iGraph | iLower | iPrint
980 };
981
982 const ULONG __eng_to_lower[256] =
983 {
984 0 , /* 0 */ 1 , /* 1 */
985 2 , /* 2 */ 3 , /* 3 */
986 4 , /* 4 */ 5 , /* 5 */
987 6 , /* 6 */ 7 , /* 7 */
988 8 , /* 8 */ 9 , /* 9 */
989 10 , /* 10 */ 11 , /* 11 */
990 12 , /* 12 */ 13 , /* 13 */
991 14 , /* 14 */ 15 , /* 15 */
992 16 , /* 16 */ 17 , /* 17 */
993 18 , /* 18 */ 19 , /* 19 */
994 20 , /* 20 */ 21 , /* 21 */
995 22 , /* 22 */ 23 , /* 23 */
996 24 , /* 24 */ 25 , /* 25 */
997 26 , /* 26 */ 27 , /* 27 */
998 28 , /* 28 */ 29 , /* 29 */
999 30 , /* 30 */ 31 , /* 31 */
1000 32 , /* 32 */ '!', /* '!' */
1001 '"', /* '"' */ '#', /* '#' */
1002 '$', /* '$' */ '%', /* '%' */
1003 '&', /* '&' */ 39 , /* ''' */
1004 '(', /* '(' */ ')', /* ')' */
1005 '*', /* '*' */ '+', /* '+' */
1006 ',', /* ',' */ '-', /* '-' */
1007 '.', /* '.' */ '/', /* '/' */
1008 '0', /* '0' */ '1', /* '1' */
1009 '2', /* '2' */ '3', /* '3' */
1010 '4', /* '4' */ '5', /* '5' */
1011 '6', /* '6' */ '7', /* '7' */
1012 '8', /* '8' */ '9', /* '9' */
1013 ':', /* ':' */ ';', /* ';' */
1014 '<', /* '<' */ '=', /* '=' */
1015 '>', /* '>' */ '?', /* '?' */
1016 '@', /* '@' */ 'a', /* 'A' */
1017 'b', /* 'B' */ 'c', /* 'C' */
1018 'd', /* 'D' */ 'e', /* 'E' */
1019 'f', /* 'F' */ 'g', /* 'G' */
1020 'h', /* 'H' */ 'i', /* 'I' */
1021 'j', /* 'J' */ 'k', /* 'K' */
1022 'l', /* 'L' */ 'm', /* 'M' */
1023 'n', /* 'N' */ 'o', /* 'O' */
1024 'p', /* 'P' */ 'q', /* 'Q' */
1025 'r', /* 'R' */ 's', /* 'S' */
1026 't', /* 'T' */ 'u', /* 'U' */
1027 'v', /* 'V' */ 'w', /* 'W' */
1028 'x', /* 'X' */ 'y', /* 'Y' */
1029 'z', /* 'Z' */ '[', /* '[' */
1030 92 , /* '\' */ ']', /* ']' */
1031 '^', /* '^' */ '_', /* '_' */
1032 '`', /* '`' */ 'a', /* 'a' */
1033 'b', /* 'b' */ 'c', /* 'c' */
1034 'd', /* 'd' */ 'e', /* 'e' */
1035 'f', /* 'f' */ 'g', /* 'g' */
1036 'h', /* 'h' */ 'i', /* 'i' */
1037 'j', /* 'j' */ 'k', /* 'k' */
1038 'l', /* 'l' */ 'm', /* 'm' */
1039 'n', /* 'n' */ 'o', /* 'o' */
1040 'p', /* 'p' */ 'q', /* 'q' */
1041 'r', /* 'r' */ 's', /* 's' */
1042 't', /* 't' */ 'u', /* 'u' */
1043 'v', /* 'v' */ 'w', /* 'w' */
1044 'x', /* 'x' */ 'y', /* 'y' */
1045 'z', /* 'z' */ '{', /* '{' */
1046 '|', /* '|' */ '}', /* '}' */
1047 '~', /* '~' */ 127, /* 127 */
1048 128, /* 128 */ 129, /* 129 */
1049 130, /* 130 */ 131, /* 131 */
1050 132, /* 132 */ 133, /* 133 */
1051 134, /* 134 */ 135, /* 135 */
1052 136, /* 136 */ 137, /* 137 */
1053 138, /* 138 */ 139, /* 139 */
1054 140, /* 140 */ 141, /* 141 */
1055 142, /* 142 */ 143, /* 143 */
1056 144, /* 144 */ 145, /* 145 */
1057 146, /* 146 */ 147, /* 147 */
1058 148, /* 148 */ 149, /* 149 */
1059 150, /* 150 */ 151, /* 151 */
1060 152, /* 152 */ 153, /* 153 */
1061 154, /* 154 */ 155, /* 155 */
1062 156, /* 156 */ 157, /* 157 */
1063 158, /* 158 */ 159, /* 159 */
1064 160, /* 160 */ '°', /* '°' */
1065 '¢', /* '¢' */ '£', /* '£' */
1066 '§', /* '§' */ '€', /* '€' */
1067 '¶', /* '¶' */ 'ß', /* 'ß' */
1068 '®', /* '®' */ '©', /* '©' */
1069 '�', /* '�' */ '´', /* '´' */
1070 '¨', /* '¨' */ '‚', /* '‚' */
1071 'Æ', /* 'Æ' */ 'Ø', /* 'Ø' */
1072 'ƒ', /* 'ƒ' */ '±', /* '±' */
1073 '¾', /* '¾' */ '„', /* '„' */
1074 '¥', /* '¥' */ 'µ', /* 'µ' */
1075 '�', /* '�' */ '…', /* '…' */
1076 '½', /* '½' */ '¼', /* '¼' */
1077 '†', /* '†' */ 'ª', /* 'ª' */
1078 'º', /* 'º' */ '‡', /* '‡' */
1079 'æ', /* 'æ' */ 'ø', /* 'ø' */
1080 'ý', /* '¿' */ '·', /* '¡' */
1081 '’', /* '¬' */ '“', /* 'ˆ' */
1082 '”', /* 'Ÿ' */ 'Â', /* '‰' */
1083 'Ê', /* '�' */ 'Á', /* '«' */
1084 'Ë', /* '»' */ 'È', /* 'Š' */
1085 'Í', /* ' ' */ 'Î', /* 'À' */
1086 'Ï', /* 'Ã' */ 'Ì', /* 'Õ' */
1087 'Ó', /* '‘' */ 'Ô', /* '¦' */
1088 '•', /* '­' */ 'Ò', /* '‹' */
1089 'Ú', /* '³' */ 'Û', /* '²' */
1090 'Ù', /* 'Œ' */ 'ž', /* '¹' */
1091 '–', /* '÷' */ '—', /* '×' */
1092 '¯', /* 'ÿ' */ '˜', /* '�' */
1093 '™', /* 'Ž' */ 'š', /* '¤' */
1094 '¸', /* 'Ð' */ '›', /* 'ð' */
1095 'œ', /* 'Þ' */ 'þ', /* 'þ' */
1096 'ý', /* 'ý' */ '·', /* '·' */
1097 '’', /* '’' */ '“', /* '“' */
1098 '”', /* '”' */ 'Â', /* 'Â' */
1099 'Ê', /* 'Ê' */ 'Á', /* 'Á' */
1100 'Ë', /* 'Ë' */ 'È', /* 'È' */
1101 'Í', /* 'Í' */ 'Î', /* 'Î' */
1102 'Ï', /* 'Ï' */ 'Ì', /* 'Ì' */
1103 'Ó', /* 'Ó' */ 'Ô', /* 'Ô' */
1104 '•', /* '•' */ 'Ò', /* 'Ò' */
1105 'Ú', /* 'Ú' */ 'Û', /* 'Û' */
1106 'Ù', /* 'Ù' */ 'ž', /* 'ž' */
1107 '–', /* '–' */ '—', /* '—' */
1108 '¯', /* '¯' */ '˜', /* '˜' */
1109 '™', /* '™' */ 'š', /* 'š' */
1110 '¸', /* '¸' */ '›', /* '›' */
1111 'œ', /* 'œ' */ '�', /* '�' */
1112 };
1113
1114 const ULONG __eng_to_upper[256] =
1115 {
1116 0 , /* 0 */ 1 , /* 1 */
1117 2 , /* 2 */ 3 , /* 3 */
1118 4 , /* 4 */ 5 , /* 5 */
1119 6 , /* 6 */ 7 , /* 7 */
1120 8 , /* 8 */ 9 , /* 9 */
1121 10 , /* 10 */ 11 , /* 11 */
1122 12 , /* 12 */ 13 , /* 13 */
1123 14 , /* 14 */ 15 , /* 15 */
1124 16 , /* 16 */ 17 , /* 17 */
1125 18 , /* 18 */ 19 , /* 19 */
1126 20 , /* 20 */ 21 , /* 21 */
1127 22 , /* 22 */ 23 , /* 23 */
1128 24 , /* 24 */ 25 , /* 25 */
1129 26 , /* 26 */ 27 , /* 27 */
1130 28 , /* 28 */ 29 , /* 29 */
1131 30 , /* 30 */ 31 , /* 31 */
1132 32 , /* 32 */ '!', /* '!' */
1133 '"', /* '"' */ '#', /* '#' */
1134 '$', /* '$' */ '%', /* '%' */
1135 '&', /* '&' */ 39 , /* ''' */
1136 '(', /* '(' */ ')', /* ')' */
1137 '*', /* '*' */ '+', /* '+' */
1138 ',', /* ',' */ '-', /* '-' */
1139 '.', /* '.' */ '/', /* '/' */
1140 '0', /* '0' */ '1', /* '1' */
1141 '2', /* '2' */ '3', /* '3' */
1142 '4', /* '4' */ '5', /* '5' */
1143 '6', /* '6' */ '7', /* '7' */
1144 '8', /* '8' */ '9', /* '9' */
1145 ':', /* ':' */ ';', /* ';' */
1146 '<', /* '<' */ '=', /* '=' */
1147 '>', /* '>' */ '?', /* '?' */
1148 '@', /* '@' */ 'A', /* 'A' */
1149 'B', /* 'B' */ 'C', /* 'C' */
1150 'D', /* 'D' */ 'E', /* 'E' */
1151 'F', /* 'F' */ 'G', /* 'G' */
1152 'H', /* 'H' */ 'I', /* 'I' */
1153 'J', /* 'J' */ 'K', /* 'K' */
1154 'L', /* 'L' */ 'M', /* 'M' */
1155 'N', /* 'N' */ 'O', /* 'O' */
1156 'P', /* 'P' */ 'Q', /* 'Q' */
1157 'R', /* 'R' */ 'S', /* 'S' */
1158 'T', /* 'T' */ 'U', /* 'U' */
1159 'V', /* 'V' */ 'W', /* 'W' */
1160 'X', /* 'X' */ 'Y', /* 'Y' */
1161 'Z', /* 'Z' */ '[', /* '[' */
1162 92 , /* '\' */ ']', /* ']' */
1163 '^', /* '^' */ '_', /* '_' */
1164 '`', /* '`' */ 'A', /* 'a' */
1165 'B', /* 'b' */ 'C', /* 'c' */
1166 'D', /* 'd' */ 'E', /* 'e' */
1167 'F', /* 'f' */ 'G', /* 'g' */
1168 'H', /* 'h' */ 'I', /* 'i' */
1169 'J', /* 'j' */ 'K', /* 'k' */
1170 'L', /* 'l' */ 'M', /* 'm' */
1171 'N', /* 'n' */ 'O', /* 'o' */
1172 'P', /* 'p' */ 'Q', /* 'q' */
1173 'R', /* 'r' */ 'S', /* 's' */
1174 'T', /* 't' */ 'U', /* 'u' */
1175 'V', /* 'v' */ 'W', /* 'w' */
1176 'X', /* 'x' */ 'Y', /* 'y' */
1177 'Z', /* 'z' */ '{', /* '{' */
1178 '|', /* '|' */ '}', /* '}' */
1179 '~', /* '~' */ 127, /* 127 */
1180 128, /* 128 */ 129, /* 129 */
1181 130, /* 130 */ 131, /* 131 */
1182 132, /* 132 */ 133, /* 133 */
1183 134, /* 134 */ 135, /* 135 */
1184 136, /* 136 */ 137, /* 137 */
1185 138, /* 138 */ 139, /* 139 */
1186 140, /* 140 */ 141, /* 141 */
1187 142, /* 142 */ 143, /* 143 */
1188 144, /* 144 */ 145, /* 145 */
1189 146, /* 146 */ 147, /* 147 */
1190 148, /* 148 */ 149, /* 149 */
1191 150, /* 150 */ 151, /* 151 */
1192 152, /* 152 */ 153, /* 153 */
1193 154, /* 154 */ 155, /* 155 */
1194 156, /* 156 */ 157, /* 157 */
1195 158, /* 158 */ 159, /* 159 */
1196 160, /* 160 */ '°', /* '°' */
1197 '¢', /* '¢' */ '£', /* '£' */
1198 '§', /* '§' */ '€', /* '€' */
1199 '¶', /* '¶' */ 'ß', /* 'ß' */
1200 '®', /* '®' */ '©', /* '©' */
1201 '�', /* '�' */ '´', /* '´' */
1202 '¨', /* '¨' */ '‚', /* '‚' */
1203 'Æ', /* 'Æ' */ 'Ø', /* 'Ø' */
1204 'ƒ', /* 'ƒ' */ '±', /* '±' */
1205 '¾', /* '¾' */ '„', /* '„' */
1206 '¥', /* '¥' */ 'µ', /* 'µ' */
1207 '�', /* '�' */ '…', /* '…' */
1208 '½', /* '½' */ '¼', /* '¼' */
1209 '†', /* '†' */ 'ª', /* 'ª' */
1210 'º', /* 'º' */ '‡', /* '‡' */
1211 'æ', /* 'æ' */ 'ø', /* 'ø' */
1212 '¿', /* '¿' */ '¡', /* '¡' */
1213 '¬', /* '¬' */ 'ˆ', /* 'ˆ' */
1214 'Ÿ', /* 'Ÿ' */ '‰', /* '‰' */
1215 '�', /* '�' */ '«', /* '«' */
1216 '»', /* '»' */ 'Š', /* 'Š' */
1217 ' ', /* ' ' */ 'À', /* 'À' */
1218 'Ã', /* 'Ã' */ 'Õ', /* 'Õ' */
1219 '‘', /* '‘' */ '¦', /* '¦' */
1220 '­', /* '­' */ '‹', /* '‹' */
1221 '³', /* '³' */ '²', /* '²' */
1222 'Œ', /* 'Œ' */ '¹', /* '¹' */
1223 '÷', /* '÷' */ '×', /* '×' */
1224 'ÿ', /* 'ÿ' */ '�', /* '�' */
1225 'Ž', /* 'Ž' */ '¤', /* '¤' */
1226 'Ð', /* 'Ð' */ 'ð', /* 'ð' */
1227 'Þ', /* 'Þ' */ 'þ', /* 'þ' */
1228 '¿', /* 'ý' */ '¡', /* '·' */
1229 '¬', /* '’' */ 'ˆ', /* '“' */
1230 'Ÿ', /* '”' */ '‰', /* 'Â' */
1231 '�', /* 'Ê' */ '«', /* 'Á' */
1232 '»', /* 'Ë' */ 'Š', /* 'È' */
1233 ' ', /* 'Í' */ 'À', /* 'Î' */
1234 'Ã', /* 'Ï' */ 'Õ', /* 'Ì' */
1235 '‘', /* 'Ó' */ '¦', /* 'Ô' */
1236 '­', /* '•' */ '‹', /* 'Ò' */
1237 '³', /* 'Ú' */ '²', /* 'Û' */
1238 'Œ', /* 'Ù' */ '¹', /* 'ž' */
1239 '÷', /* '–' */ '×', /* '—' */
1240 'ÿ', /* '¯' */ '�', /* '˜' */
1241 'Ž', /* '™' */ '¤', /* 'š' */
1242 'Ð', /* '¸' */ 'ð', /* '›' */
1243 'Þ', /* 'œ' */ '�', /* '�' */
1244 };
1245
1246 /*
1247 This is the string collation table.
1248
1249 The basic idea is to have the character which is found in the normal
1250 ENGLISH alphabet used instead, this will allow for sorting in a
1251 list so that "fÛol" would come before full not after it, as would
1252 happen by sorting just by ASCII characters.
1253 */
1254 const ULONG __eng_collate_tab[256] =
1255 {
1256 0 , /* 0 */ 1 , /* 1 */
1257 2 , /* 2 */ 3 , /* 3 */
1258 4 , /* 4 */ 5 , /* 5 */
1259 6 , /* 6 */ 7 , /* 7 */
1260 8 , /* 8 */ 9 , /* 9 */
1261 10 , /* 10 */ 11 , /* 11 */
1262 12 , /* 12 */ 13 , /* 13 */
1263 14 , /* 14 */ 15 , /* 15 */
1264 16 , /* 16 */ 17 , /* 17 */
1265 18 , /* 18 */ 19 , /* 19 */
1266 20 , /* 20 */ 21 , /* 21 */
1267 22 , /* 22 */ 23 , /* 23 */
1268 24 , /* 24 */ 25 , /* 25 */
1269 26 , /* 26 */ 27 , /* 27 */
1270 28 , /* 28 */ 29 , /* 29 */
1271 30 , /* 30 */ 31 , /* 31 */
1272 32 , /* 32 */ '!', /* '!' */
1273 '"', /* '"' */ '#', /* '#' */
1274 '$', /* '$' */ '%', /* '%' */
1275 '&', /* '&' */ 39 , /* ''' */
1276 '(', /* '(' */ ')', /* ')' */
1277 '*', /* '*' */ '+', /* '+' */
1278 ',', /* ',' */ '-', /* '-' */
1279 '.', /* '.' */ '/', /* '/' */
1280 '0', /* '0' */ '1', /* '1' */
1281 '2', /* '2' */ '3', /* '3' */
1282 '4', /* '4' */ '5', /* '5' */
1283 '6', /* '6' */ '7', /* '7' */
1284 '8', /* '8' */ '9', /* '9' */
1285 ':', /* ':' */ ';', /* ';' */
1286 '<', /* '<' */ '=', /* '=' */
1287 '>', /* '>' */ '?', /* '?' */
1288 '@', /* '@' */ 'A', /* 'A' */
1289 'B', /* 'B' */ 'C', /* 'C' */
1290 'D', /* 'D' */ 'E', /* 'E' */
1291 'F', /* 'F' */ 'G', /* 'G' */
1292 'H', /* 'H' */ 'I', /* 'I' */
1293 'J', /* 'J' */ 'K', /* 'K' */
1294 'L', /* 'L' */ 'M', /* 'M' */
1295 'N', /* 'N' */ 'O', /* 'O' */
1296 'P', /* 'P' */ 'Q', /* 'Q' */
1297 'R', /* 'R' */ 'S', /* 'S' */
1298 'T', /* 'T' */ 'U', /* 'U' */
1299 'V', /* 'V' */ 'W', /* 'W' */
1300 'X', /* 'X' */ 'Y', /* 'Y' */
1301 'Z', /* 'Z' */ '[', /* '[' */
1302 92 , /* '\' */ ']', /* ']' */
1303 '^', /* '^' */ '_', /* '_' */
1304 '`', /* '`' */ 'A', /* 'a' */
1305 'B', /* 'b' */ 'C', /* 'c' */
1306 'D', /* 'd' */ 'E', /* 'e' */
1307 'F', /* 'f' */ 'G', /* 'g' */
1308 'H', /* 'h' */ 'I', /* 'i' */
1309 'J', /* 'j' */ 'K', /* 'k' */
1310 'L', /* 'l' */ 'M', /* 'm' */
1311 'N', /* 'n' */ 'O', /* 'o' */
1312 'P', /* 'p' */ 'Q', /* 'q' */
1313 'R', /* 'r' */ 'S', /* 's' */
1314 'T', /* 't' */ 'U', /* 'u' */
1315 'V', /* 'v' */ 'W', /* 'w' */
1316 'X', /* 'x' */ 'Y', /* 'y' */
1317 'Z', /* 'z' */ '{', /* '{' */
1318 '|', /* '|' */ '}', /* '}' */
1319 '~', /* '~' */ 127, /* 127 */
1320 128, /* 128 */ 129, /* 129 */
1321 130, /* 130 */ 131, /* 131 */
1322 132, /* 132 */ 133, /* 133 */
1323 134, /* 134 */ 135, /* 135 */
1324 136, /* 136 */ 137, /* 137 */
1325 138, /* 138 */ 139, /* 139 */
1326 140, /* 140 */ 141, /* 141 */
1327 142, /* 142 */ 143, /* 143 */
1328 144, /* 144 */ 145, /* 145 */
1329 146, /* 146 */ 147, /* 147 */
1330 148, /* 148 */ 149, /* 149 */
1331 150, /* 150 */ 151, /* 151 */
1332 152, /* 152 */ 153, /* 153 */
1333 154, /* 154 */ 155, /* 155 */
1334 156, /* 156 */ 157, /* 157 */
1335 158, /* 158 */ 159, /* 159 */
1336 20, /* 160 */ '!', /* '°' */
1337 '$', /* '¢' */ '$', /* '£' */
1338 'g', /* '§' */ 'h', /* '€' */
1339 'i', /* '¶' */ 'S', /* 'ß' */
1340 'j', /* '®' */ 'k', /* '©' */
1341 'l', /* '�' */ '\"', /* '´' */
1342 'm', /* '¨' */ 'n', /* '‚' */
1343 'o', /* 'Æ' */ 'p', /* 'Ø' */
1344 'q', /* 'ƒ' */ 'r', /* '±' */
1345 's', /* '¾' */ 't', /* '„' */
1346 'u', /* '¥' */ 'v', /* 'µ' */
1347 'w', /* '�' */ 'x', /* '…' */
1348 'y', /* '½' */ 'z', /* '¼' */
1349 '{', /* '†' */ '\"' /* 'ª' */
1350 '|', /* 'º' */ '}', /* '‡' */
1351 '~', /* 'æ' */ '?', /* 'ø' */
1352 'A', /* '¿' */ 'A', /* '¡' */
1353 'A', /* '¬' */ 'A', /* 'ˆ' */
1354 'A', /* 'Ÿ' */ 'A', /* '‰' */
1355 'A', /* '�' */ 'C', /* '«' */
1356 'E', /* '»' */ 'E', /* 'Š' */
1357 'E', /* ' ' */ 'E', /* 'À' */
1358 'I', /* 'Ã' */ 'I', /* 'Õ' */
1359 'I', /* '‘' */ 'I', /* '¦' */
1360 'D', /* '­' */ 'N', /* '‹' */
1361 'O', /* '³' */ 'O', /* '²' */
1362 'O', /* 'Œ' */ 'O', /* '¹' */
1363 'O', /* '÷' */ '*', /* '×' */
1364 'O', /* 'ÿ' */ 'U', /* '�' */
1365 'U', /* 'Ž' */ 'U', /* '¤' */
1366 'U', /* 'Ð' */ 'Y', /* 'ð' */
1367 'P', /* 'Þ' */ 'Y', /* 'þ' */
1368 'A', /* 'ý' */ 'A', /* '·' */
1369 'A', /* '’' */ 'A', /* '“' */
1370 'A', /* '”' */ 'A', /* 'Â' */
1371 'A', /* 'Ê' */ 'C', /* 'Á' */
1372 'E', /* 'Ë' */ 'E', /* 'È' */
1373 'E', /* 'Í' */ 'E', /* 'Î' */
1374 'I', /* 'Ï' */ 'I', /* 'Ì' */
1375 'I', /* 'Ó' */ 'I', /* 'Ô' */
1376 'D', /* '•' */ 'N', /* 'Ò' */
1377 'O', /* 'Ú' */ 'O', /* 'Û' */
1378 'O', /* 'Ù' */ 'O', /* 'ž' */
1379 'O', /* '–' */ '/', /* '—' */
1380 'O', /* '¯' */ 'U', /* '˜' */
1381 'U', /* '™' */ 'U', /* 'š' */
1382 'U', /* '¸' */ 'Y', /* '›' */
1383 'P', /* 'œ' */ 'Y', /* '�' */
1384 };
1385
1386
1387
1388 /* This is the end of ROMtag marker. */
1389 const char end=0;
Mirror of AROS' svn.