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