?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
grub2: bring back build of aros-side grub2 tools
[AROS.git] / workbench / locale / languages / templates / english.c
blob42aaadf77c4c7398726e4a485709fb7ffffb907a
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 /* Native language name */
721 NLANGSTR
722 };
723
724 /* Array for the IsXXXXX() functions*/
725 const UWORD __eng_ctype_array[256] =
726 {
727 /* 0 */ iCntrl,
728 /* 1 */ iCntrl,
729 /* 2 */ iCntrl,
730 /* 3 */ iCntrl,
731 /* 4 */ iCntrl,
732 /* 5 */ iCntrl,
733 /* 6 */ iCntrl,
734 /* 7 */ iCntrl,
735 /* 8 */ iCntrl,
736 /* 9 */ iCntrl | iPrint | iSpace,
737 /* 10 */ iCntrl | iPrint | iSpace,
738 /* 11 */ iCntrl | iPrint | iSpace,
739 /* 12 */ iCntrl | iPrint | iSpace,
740 /* 13 */ iCntrl | iPrint | iSpace,
741 /* 14 */ iCntrl,
742 /* 15 */ iCntrl,
743 /* 16 */ iCntrl,
744 /* 17 */ iCntrl,
745 /* 18 */ iCntrl,
746 /* 19 */ iCntrl,
747 /* 20 */ iCntrl,
748 /* 21 */ iCntrl,
749 /* 22 */ iCntrl,
750 /* 23 */ iCntrl,
751 /* 24 */ iCntrl,
752 /* 25 */ iCntrl,
753 /* 26 */ iCntrl,
754 /* 27 */ iCntrl,
755 /* 28 */ iCntrl,
756 /* 29 */ iCntrl,
757 /* 30 */ iCntrl,
758 /* 31 */ iCntrl,
759 /* 32 */ iPrint | iSpace,
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 /* '-' */ iGraph | iPrint | iPunct,
773 /* '.' */ iGraph | iPrint | iPunct,
774 /* '/' */ iGraph | iPrint | iPunct,
775 /* '0' */ iDigit | iGraph | iPrint | iXDigit,
776 /* '1' */ iDigit | iGraph | iPrint | iXDigit,
777 /* '2' */ iDigit | iGraph | iPrint | iXDigit,
778 /* '3' */ iDigit | iGraph | iPrint | iXDigit,
779 /* '4' */ iDigit | iGraph | iPrint | iXDigit,
780 /* '5' */ iDigit | iGraph | iPrint | iXDigit,
781 /* '6' */ iDigit | iGraph | iPrint | iXDigit,
782 /* '7' */ iDigit | iGraph | iPrint | iXDigit,
783 /* '8' */ iDigit | iGraph | iPrint | iXDigit,
784 /* '9' */ iDigit | iGraph | iPrint | iXDigit,
785 /* ':' */ iGraph | iPrint | iPunct,
786 /* ';' */ iGraph | iPrint | iPunct,
787 /* '<' */ iGraph | iPrint | iPunct,
788 /* '=' */ iGraph | iPrint | iPunct,
789 /* '>' */ iGraph | iPrint | iPunct,
790 /* '?' */ iGraph | iPrint | iPunct,
791 /* '@' */ iGraph | iPrint | iPunct,
792 /* 'A' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
793 /* 'B' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
794 /* 'C' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
795 /* 'D' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
796 /* 'E' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
797 /* 'F' */ iAlpha | iGraph | iPrint | iUpper | iXDigit,
798 /* 'G' */ iAlpha | iGraph | iPrint | iUpper,
799 /* 'H' */ iAlpha | iGraph | iPrint | iUpper,
800 /* 'I' */ iAlpha | iGraph | iPrint | iUpper,
801 /* 'J' */ iAlpha | iGraph | iPrint | iUpper,
802 /* 'K' */ iAlpha | iGraph | iPrint | iUpper,
803 /* 'L' */ iAlpha | iGraph | iPrint | iUpper,
804 /* 'M' */ iAlpha | iGraph | iPrint | iUpper,
805 /* 'N' */ iAlpha | iGraph | iPrint | iUpper,
806 /* 'O' */ iAlpha | iGraph | iPrint | iUpper,
807 /* 'P' */ iAlpha | iGraph | iPrint | iUpper,
808 /* 'Q' */ iAlpha | iGraph | iPrint | iUpper,
809 /* 'R' */ iAlpha | iGraph | iPrint | iUpper,
810 /* 'S' */ iAlpha | iGraph | iPrint | iUpper,
811 /* 'T' */ iAlpha | iGraph | iPrint | iUpper,
812 /* 'U' */ iAlpha | iGraph | iPrint | iUpper,
813 /* 'V' */ iAlpha | iGraph | iPrint | iUpper,
814 /* 'W' */ iAlpha | iGraph | iPrint | iUpper,
815 /* 'X' */ iAlpha | iGraph | iPrint | iUpper,
816 /* 'Y' */ iAlpha | iGraph | iPrint | iUpper,
817 /* 'Z' */ iAlpha | iGraph | iPrint | iUpper,
818 /* '[' */ iGraph | iPrint | iPunct,
819 /* '\' */ iGraph | iPrint | iPunct,
820 /* ']' */ iGraph | iPrint | iPunct,
821 /* '^' */ iGraph | iPrint | iPunct,
822 /* '_' */ iGraph | iPrint | iPunct,
823 /* '`' */ iGraph | iPrint | iPunct,
824 /* 'a' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
825 /* 'b' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
826 /* 'c' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
827 /* 'd' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
828 /* 'e' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
829 /* 'f' */ iAlpha | iGraph | iLower | iPrint | iXDigit,
830 /* 'g' */ iAlpha | iGraph | iLower | iPrint,
831 /* 'h' */ iAlpha | iGraph | iLower | iPrint,
832 /* 'i' */ iAlpha | iGraph | iLower | iPrint,
833 /* 'j' */ iAlpha | iGraph | iLower | iPrint,
834 /* 'k' */ iAlpha | iGraph | iLower | iPrint,
835 /* 'l' */ iAlpha | iGraph | iLower | iPrint,
836 /* 'm' */ iAlpha | iGraph | iLower | iPrint,
837 /* 'n' */ iAlpha | iGraph | iLower | iPrint,
838 /* 'o' */ iAlpha | iGraph | iLower | iPrint,
839 /* 'p' */ iAlpha | iGraph | iLower | iPrint,
840 /* 'q' */ iAlpha | iGraph | iLower | iPrint,
841 /* 'r' */ iAlpha | iGraph | iLower | iPrint,
842 /* 's' */ iAlpha | iGraph | iLower | iPrint,
843 /* 't' */ iAlpha | iGraph | iLower | iPrint,
844 /* 'u' */ iAlpha | iGraph | iLower | iPrint,
845 /* 'v' */ iAlpha | iGraph | iLower | iPrint,
846 /* 'w' */ iAlpha | iGraph | iLower | iPrint,
847 /* 'x' */ iAlpha | iGraph | iLower | iPrint,
848 /* 'y' */ iAlpha | iGraph | iLower | iPrint,
849 /* 'z' */ iAlpha | iGraph | iLower | iPrint,
850 /* '{' */ iGraph | iPrint | iPunct,
851 /* '|' */ iGraph | iPrint | iPunct,
852 /* '}' */ iGraph | iPrint | iPunct,
853 /* '~' */ iGraph | iPrint | iPunct,
854 /* 127 */ iCntrl,
855 /* 128 */ iCntrl,
856 /* 129 */ iCntrl,
857 /* 130 */ iCntrl,
858 /* 131 */ iCntrl,
859 /* 132 */ iCntrl,
860 /* 133 */ iCntrl,
861 /* 134 */ iCntrl,
862 /* 135 */ iCntrl,
863 /* 136 */ iCntrl,
864 /* 137 */ iCntrl,
865 /* 138 */ iCntrl,
866 /* 139 */ iCntrl,
867 /* 140 */ iCntrl,
868 /* 141 */ iCntrl,
869 /* 142 */ iCntrl,
870 /* 143 */ iCntrl,
871 /* 144 */ iCntrl,
872 /* 145 */ iCntrl,
873 /* 146 */ iCntrl,
874 /* 147 */ iCntrl,
875 /* 148 */ iCntrl,
876 /* 149 */ iCntrl,
877 /* 150 */ iCntrl,
878 /* 151 */ iCntrl,
879 /* 152 */ iCntrl,
880 /* 153 */ iCntrl,
881 /* 154 */ iCntrl,
882 /* 155 */ iCntrl,
883 /* 156 */ iCntrl,
884 /* 157 */ iCntrl,
885 /* 158 */ iCntrl,
886 /* 159 */ iCntrl,
887 /* 160 */ iPrint | iSpace,
888 /* '°' */ iGraph | iPrint | iPunct,
889 /* '¢' */ iGraph | iPrint | iPunct,
890 /* '£' */ iGraph | iPrint | iPunct,
891 /* '§' */ iGraph | iPrint | iPunct,
892 /* '€' */ iGraph | iPrint | iPunct,
893 /* '¶' */ iGraph | iPrint | iPunct,
894 /* 'ß' */ iAlpha | iGraph | iPrint | iLower,
895 /* '®' */ iGraph | iPrint | iPunct,
896 /* '©' */ iGraph | iPrint | iPunct,
897 /* '�' */ iGraph | iPrint | iPunct,
898 /* '´' */ iGraph | iPrint | iPunct,
899 /* '¨' */ iGraph | iPrint | iPunct,
900 /* '‚' */ iGraph | iPrint | iPunct,
901 /* 'Æ' */ iAlpha | iGraph | iPrint | iUpper,
902 /* 'Ø' */ iAlpha | iGraph | iPrint | iUpper,
903 /* 'ƒ' */ iGraph | iPrint | iPunct,
904 /* '±' */ iGraph | iPrint | iPunct,
905 /* '¾' */ iDigit | iGraph | iPrint,
906 /* '„' */ iGraph | iPrint | iPunct,
907 /* '¥' */ iGraph | iPrint | iPunct,
908 /* 'µ' */ iGraph | iPrint | iPunct,
909 /* '�' */ iGraph | iPrint | iPunct,
910 /* '…' */ iGraph | iPrint | iPunct,
911 /* '½' */ iDigit | iGraph | iPrint,
912 /* '¼' */ iDigit | iGraph | iPrint,
913 /* '†' */ iGraph | iPrint | iPunct,
914 /* 'ª' */ iGraph | iPrint | iPunct,
915 /* 'º' */ iGraph | iPrint | iPunct,
916 /* '‡' */ iGraph | iPrint | iPunct,
917 /* 'æ' */ iAlpha | iGraph | iPrint | iLower,
918 /* 'ø' */ iAlpha | iGraph | iPrint | iLower,
919 /* '¿' */ iGraph | iPrint | iPunct,
920 /* '¡' */ iGraph | iPrint | iPunct,
921 /* '¬' */ iAlpha | iGraph | iPrint | iUpper,
922 /* 'ˆ' */ iAlpha | iGraph | iPrint | iUpper,
923 /* 'Ÿ' */ iAlpha | iGraph | iPrint | iUpper,
924 /* '‰' */ iAlpha | iGraph | iPrint | iUpper,
925 /* '�' */ iAlpha | iGraph | iPrint | iUpper,
926 /* '«' */ iGraph | iPrint | iPunct,
927 /* '»' */ iGraph | iPrint | iPunct,
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 /* '¦' */ iAlpha | iGraph | iPrint | iUpper,
935 /* '­' */ iAlpha | iGraph | iPrint | iUpper,
936 /* '‹' */ iAlpha | iGraph | iPrint | iUpper,
937 /* '³' */ iDigit | iGraph | iPrint,
938 /* '²' */ iDigit | iGraph | iPrint,
939 /* 'Œ' */ iAlpha | iGraph | iPrint | iUpper,
940 /* '¹' */ iDigit | iGraph | iPrint,
941 /* '÷' */ iPunct | iGraph | iPrint,
942 /* '×' */ iPunct | iGraph | iPrint,
943 /* 'ÿ' */ iAlpha | iGraph | iPrint | iUpper,
944 /* '�' */ iAlpha | iGraph | iPrint | iUpper,
945 /* 'Ž' */ iAlpha | iGraph | iPrint | iUpper,
946 /* '¤' */ iAlpha | iGraph | iPrint | iUpper,
947 /* 'Ð' */ iAlpha | iGraph | iPrint | iUpper,
948 /* 'ð' */ iAlpha | iGraph | iPrint | iLower,
949 /* 'Þ' */ iAlpha | iGraph | iPrint | iUpper,
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 /* 'Ù' */ iAlpha | iGraph | iLower | iPrint,
972 /* 'ž' */ iAlpha | iGraph | iLower | iPrint,
973 /* '–' */ iAlpha | iGraph | iLower | iPrint,
974 /* '—' */ iGraph | iPrint | iPunct,
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 /* '›' */ iAlpha | iGraph | iLower | iPrint,
981 /* 'œ' */ iAlpha | iGraph | iLower | iPrint,
982 /* '�' */ iAlpha | iGraph | iLower | iPrint
983 };
984
985 const ULONG __eng_to_lower[256] =
986 {
987 0 , /* 0 */ 1 , /* 1 */
988 2 , /* 2 */ 3 , /* 3 */
989 4 , /* 4 */ 5 , /* 5 */
990 6 , /* 6 */ 7 , /* 7 */
991 8 , /* 8 */ 9 , /* 9 */
992 10 , /* 10 */ 11 , /* 11 */
993 12 , /* 12 */ 13 , /* 13 */
994 14 , /* 14 */ 15 , /* 15 */
995 16 , /* 16 */ 17 , /* 17 */
996 18 , /* 18 */ 19 , /* 19 */
997 20 , /* 20 */ 21 , /* 21 */
998 22 , /* 22 */ 23 , /* 23 */
999 24 , /* 24 */ 25 , /* 25 */
1000 26 , /* 26 */ 27 , /* 27 */
1001 28 , /* 28 */ 29 , /* 29 */
1002 30 , /* 30 */ 31 , /* 31 */
1003 32 , /* 32 */ '!', /* '!' */
1004 '"', /* '"' */ '#', /* '#' */
1005 '$', /* '$' */ '%', /* '%' */
1006 '&', /* '&' */ 39 , /* ''' */
1007 '(', /* '(' */ ')', /* ')' */
1008 '*', /* '*' */ '+', /* '+' */
1009 ',', /* ',' */ '-', /* '-' */
1010 '.', /* '.' */ '/', /* '/' */
1011 '0', /* '0' */ '1', /* '1' */
1012 '2', /* '2' */ '3', /* '3' */
1013 '4', /* '4' */ '5', /* '5' */
1014 '6', /* '6' */ '7', /* '7' */
1015 '8', /* '8' */ '9', /* '9' */
1016 ':', /* ':' */ ';', /* ';' */
1017 '<', /* '<' */ '=', /* '=' */
1018 '>', /* '>' */ '?', /* '?' */
1019 '@', /* '@' */ 'a', /* 'A' */
1020 'b', /* 'B' */ 'c', /* 'C' */
1021 'd', /* 'D' */ 'e', /* 'E' */
1022 'f', /* 'F' */ 'g', /* 'G' */
1023 'h', /* 'H' */ 'i', /* 'I' */
1024 'j', /* 'J' */ 'k', /* 'K' */
1025 'l', /* 'L' */ 'm', /* 'M' */
1026 'n', /* 'N' */ 'o', /* 'O' */
1027 'p', /* 'P' */ 'q', /* 'Q' */
1028 'r', /* 'R' */ 's', /* 'S' */
1029 't', /* 'T' */ 'u', /* 'U' */
1030 'v', /* 'V' */ 'w', /* 'W' */
1031 'x', /* 'X' */ 'y', /* 'Y' */
1032 'z', /* 'Z' */ '[', /* '[' */
1033 92 , /* '\' */ ']', /* ']' */
1034 '^', /* '^' */ '_', /* '_' */
1035 '`', /* '`' */ 'a', /* 'a' */
1036 'b', /* 'b' */ 'c', /* 'c' */
1037 'd', /* 'd' */ 'e', /* 'e' */
1038 'f', /* 'f' */ 'g', /* 'g' */
1039 'h', /* 'h' */ 'i', /* 'i' */
1040 'j', /* 'j' */ 'k', /* 'k' */
1041 'l', /* 'l' */ 'm', /* 'm' */
1042 'n', /* 'n' */ 'o', /* 'o' */
1043 'p', /* 'p' */ 'q', /* 'q' */
1044 'r', /* 'r' */ 's', /* 's' */
1045 't', /* 't' */ 'u', /* 'u' */
1046 'v', /* 'v' */ 'w', /* 'w' */
1047 'x', /* 'x' */ 'y', /* 'y' */
1048 'z', /* 'z' */ '{', /* '{' */
1049 '|', /* '|' */ '}', /* '}' */
1050 '~', /* '~' */ 127, /* 127 */
1051 128, /* 128 */ 129, /* 129 */
1052 130, /* 130 */ 131, /* 131 */
1053 132, /* 132 */ 133, /* 133 */
1054 134, /* 134 */ 135, /* 135 */
1055 136, /* 136 */ 137, /* 137 */
1056 138, /* 138 */ 139, /* 139 */
1057 140, /* 140 */ 141, /* 141 */
1058 142, /* 142 */ 143, /* 143 */
1059 144, /* 144 */ 145, /* 145 */
1060 146, /* 146 */ 147, /* 147 */
1061 148, /* 148 */ 149, /* 149 */
1062 150, /* 150 */ 151, /* 151 */
1063 152, /* 152 */ 153, /* 153 */
1064 154, /* 154 */ 155, /* 155 */
1065 156, /* 156 */ 157, /* 157 */
1066 158, /* 158 */ 159, /* 159 */
1067 160, /* 160 */ '°', /* '°' */
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 'œ', /* 'œ' */ '�', /* '�' */
1115 };
1116
1117 const ULONG __eng_to_upper[256] =
1118 {
1119 0 , /* 0 */ 1 , /* 1 */
1120 2 , /* 2 */ 3 , /* 3 */
1121 4 , /* 4 */ 5 , /* 5 */
1122 6 , /* 6 */ 7 , /* 7 */
1123 8 , /* 8 */ 9 , /* 9 */
1124 10 , /* 10 */ 11 , /* 11 */
1125 12 , /* 12 */ 13 , /* 13 */
1126 14 , /* 14 */ 15 , /* 15 */
1127 16 , /* 16 */ 17 , /* 17 */
1128 18 , /* 18 */ 19 , /* 19 */
1129 20 , /* 20 */ 21 , /* 21 */
1130 22 , /* 22 */ 23 , /* 23 */
1131 24 , /* 24 */ 25 , /* 25 */
1132 26 , /* 26 */ 27 , /* 27 */
1133 28 , /* 28 */ 29 , /* 29 */
1134 30 , /* 30 */ 31 , /* 31 */
1135 32 , /* 32 */ '!', /* '!' */
1136 '"', /* '"' */ '#', /* '#' */
1137 '$', /* '$' */ '%', /* '%' */
1138 '&', /* '&' */ 39 , /* ''' */
1139 '(', /* '(' */ ')', /* ')' */
1140 '*', /* '*' */ '+', /* '+' */
1141 ',', /* ',' */ '-', /* '-' */
1142 '.', /* '.' */ '/', /* '/' */
1143 '0', /* '0' */ '1', /* '1' */
1144 '2', /* '2' */ '3', /* '3' */
1145 '4', /* '4' */ '5', /* '5' */
1146 '6', /* '6' */ '7', /* '7' */
1147 '8', /* '8' */ '9', /* '9' */
1148 ':', /* ':' */ ';', /* ';' */
1149 '<', /* '<' */ '=', /* '=' */
1150 '>', /* '>' */ '?', /* '?' */
1151 '@', /* '@' */ 'A', /* 'A' */
1152 'B', /* 'B' */ 'C', /* 'C' */
1153 'D', /* 'D' */ 'E', /* 'E' */
1154 'F', /* 'F' */ 'G', /* 'G' */
1155 'H', /* 'H' */ 'I', /* 'I' */
1156 'J', /* 'J' */ 'K', /* 'K' */
1157 'L', /* 'L' */ 'M', /* 'M' */
1158 'N', /* 'N' */ 'O', /* 'O' */
1159 'P', /* 'P' */ 'Q', /* 'Q' */
1160 'R', /* 'R' */ 'S', /* 'S' */
1161 'T', /* 'T' */ 'U', /* 'U' */
1162 'V', /* 'V' */ 'W', /* 'W' */
1163 'X', /* 'X' */ 'Y', /* 'Y' */
1164 'Z', /* 'Z' */ '[', /* '[' */
1165 92 , /* '\' */ ']', /* ']' */
1166 '^', /* '^' */ '_', /* '_' */
1167 '`', /* '`' */ 'A', /* 'a' */
1168 'B', /* 'b' */ 'C', /* 'c' */
1169 'D', /* 'd' */ 'E', /* 'e' */
1170 'F', /* 'f' */ 'G', /* 'g' */
1171 'H', /* 'h' */ 'I', /* 'i' */
1172 'J', /* 'j' */ 'K', /* 'k' */
1173 'L', /* 'l' */ 'M', /* 'm' */
1174 'N', /* 'n' */ 'O', /* 'o' */
1175 'P', /* 'p' */ 'Q', /* 'q' */
1176 'R', /* 'r' */ 'S', /* 's' */
1177 'T', /* 't' */ 'U', /* 'u' */
1178 'V', /* 'v' */ 'W', /* 'w' */
1179 'X', /* 'x' */ 'Y', /* 'y' */
1180 'Z', /* 'z' */ '{', /* '{' */
1181 '|', /* '|' */ '}', /* '}' */
1182 '~', /* '~' */ 127, /* 127 */
1183 128, /* 128 */ 129, /* 129 */
1184 130, /* 130 */ 131, /* 131 */
1185 132, /* 132 */ 133, /* 133 */
1186 134, /* 134 */ 135, /* 135 */
1187 136, /* 136 */ 137, /* 137 */
1188 138, /* 138 */ 139, /* 139 */
1189 140, /* 140 */ 141, /* 141 */
1190 142, /* 142 */ 143, /* 143 */
1191 144, /* 144 */ 145, /* 145 */
1192 146, /* 146 */ 147, /* 147 */
1193 148, /* 148 */ 149, /* 149 */
1194 150, /* 150 */ 151, /* 151 */
1195 152, /* 152 */ 153, /* 153 */
1196 154, /* 154 */ 155, /* 155 */
1197 156, /* 156 */ 157, /* 157 */
1198 158, /* 158 */ 159, /* 159 */
1199 160, /* 160 */ '°', /* '°' */
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 };
1248
1249 /*
1250 This is the string collation table.
1251
1252 The basic idea is to have the character which is found in the normal
1253 ENGLISH alphabet used instead, this will allow for sorting in a
1254 list so that "fÛol" would come before full not after it, as would
1255 happen by sorting just by ASCII characters.
1256 */
1257 const ULONG __eng_collate_tab[256] =
1258 {
1259 0 , /* 0 */ 1 , /* 1 */
1260 2 , /* 2 */ 3 , /* 3 */
1261 4 , /* 4 */ 5 , /* 5 */
1262 6 , /* 6 */ 7 , /* 7 */
1263 8 , /* 8 */ 9 , /* 9 */
1264 10 , /* 10 */ 11 , /* 11 */
1265 12 , /* 12 */ 13 , /* 13 */
1266 14 , /* 14 */ 15 , /* 15 */
1267 16 , /* 16 */ 17 , /* 17 */
1268 18 , /* 18 */ 19 , /* 19 */
1269 20 , /* 20 */ 21 , /* 21 */
1270 22 , /* 22 */ 23 , /* 23 */
1271 24 , /* 24 */ 25 , /* 25 */
1272 26 , /* 26 */ 27 , /* 27 */
1273 28 , /* 28 */ 29 , /* 29 */
1274 30 , /* 30 */ 31 , /* 31 */
1275 32 , /* 32 */ '!', /* '!' */
1276 '"', /* '"' */ '#', /* '#' */
1277 '$', /* '$' */ '%', /* '%' */
1278 '&', /* '&' */ 39 , /* ''' */
1279 '(', /* '(' */ ')', /* ')' */
1280 '*', /* '*' */ '+', /* '+' */
1281 ',', /* ',' */ '-', /* '-' */
1282 '.', /* '.' */ '/', /* '/' */
1283 '0', /* '0' */ '1', /* '1' */
1284 '2', /* '2' */ '3', /* '3' */
1285 '4', /* '4' */ '5', /* '5' */
1286 '6', /* '6' */ '7', /* '7' */
1287 '8', /* '8' */ '9', /* '9' */
1288 ':', /* ':' */ ';', /* ';' */
1289 '<', /* '<' */ '=', /* '=' */
1290 '>', /* '>' */ '?', /* '?' */
1291 '@', /* '@' */ 'A', /* 'A' */
1292 'B', /* 'B' */ 'C', /* 'C' */
1293 'D', /* 'D' */ 'E', /* 'E' */
1294 'F', /* 'F' */ 'G', /* 'G' */
1295 'H', /* 'H' */ 'I', /* 'I' */
1296 'J', /* 'J' */ 'K', /* 'K' */
1297 'L', /* 'L' */ 'M', /* 'M' */
1298 'N', /* 'N' */ 'O', /* 'O' */
1299 'P', /* 'P' */ 'Q', /* 'Q' */
1300 'R', /* 'R' */ 'S', /* 'S' */
1301 'T', /* 'T' */ 'U', /* 'U' */
1302 'V', /* 'V' */ 'W', /* 'W' */
1303 'X', /* 'X' */ 'Y', /* 'Y' */
1304 'Z', /* 'Z' */ '[', /* '[' */
1305 92 , /* '\' */ ']', /* ']' */
1306 '^', /* '^' */ '_', /* '_' */
1307 '`', /* '`' */ 'A', /* 'a' */
1308 'B', /* 'b' */ 'C', /* 'c' */
1309 'D', /* 'd' */ 'E', /* 'e' */
1310 'F', /* 'f' */ 'G', /* 'g' */
1311 'H', /* 'h' */ 'I', /* 'i' */
1312 'J', /* 'j' */ 'K', /* 'k' */
1313 'L', /* 'l' */ 'M', /* 'm' */
1314 'N', /* 'n' */ 'O', /* 'o' */
1315 'P', /* 'p' */ 'Q', /* 'q' */
1316 'R', /* 'r' */ 'S', /* 's' */
1317 'T', /* 't' */ 'U', /* 'u' */
1318 'V', /* 'v' */ 'W', /* 'w' */
1319 'X', /* 'x' */ 'Y', /* 'y' */
1320 'Z', /* 'z' */ '{', /* '{' */
1321 '|', /* '|' */ '}', /* '}' */
1322 '~', /* '~' */ 127, /* 127 */
1323 128, /* 128 */ 129, /* 129 */
1324 130, /* 130 */ 131, /* 131 */
1325 132, /* 132 */ 133, /* 133 */
1326 134, /* 134 */ 135, /* 135 */
1327 136, /* 136 */ 137, /* 137 */
1328 138, /* 138 */ 139, /* 139 */
1329 140, /* 140 */ 141, /* 141 */
1330 142, /* 142 */ 143, /* 143 */
1331 144, /* 144 */ 145, /* 145 */
1332 146, /* 146 */ 147, /* 147 */
1333 148, /* 148 */ 149, /* 149 */
1334 150, /* 150 */ 151, /* 151 */
1335 152, /* 152 */ 153, /* 153 */
1336 154, /* 154 */ 155, /* 155 */
1337 156, /* 156 */ 157, /* 157 */
1338 158, /* 158 */ 159, /* 159 */
1339 20, /* 160 */ '!', /* '°' */
1340 '$', /* '¢' */ '$', /* '£' */
1341 'g', /* '§' */ 'h', /* '€' */
1342 'i', /* '¶' */ 'S', /* 'ß' */
1343 'j', /* '®' */ 'k', /* '©' */
1344 'l', /* '�' */ '\"', /* '´' */
1345 'm', /* '¨' */ 'n', /* '‚' */
1346 'o', /* 'Æ' */ 'p', /* 'Ø' */
1347 'q', /* 'ƒ' */ 'r', /* '±' */
1348 's', /* '¾' */ 't', /* '„' */
1349 'u', /* '¥' */ 'v', /* 'µ' */
1350 'w', /* '�' */ 'x', /* '…' */
1351 'y', /* '½' */ 'z', /* '¼' */
1352 '{', /* '†' */ '\"' /* 'ª' */
1353 '|', /* 'º' */ '}', /* '‡' */
1354 '~', /* 'æ' */ '?', /* 'ø' */
1355 'A', /* '¿' */ 'A', /* '¡' */
1356 'A', /* '¬' */ 'A', /* 'ˆ' */
1357 'A', /* 'Ÿ' */ 'A', /* '‰' */
1358 'A', /* '�' */ 'C', /* '«' */
1359 'E', /* '»' */ 'E', /* 'Š' */
1360 'E', /* ' ' */ 'E', /* 'À' */
1361 'I', /* 'Ã' */ 'I', /* 'Õ' */
1362 'I', /* '‘' */ 'I', /* '¦' */
1363 'D', /* '­' */ 'N', /* '‹' */
1364 'O', /* '³' */ 'O', /* '²' */
1365 'O', /* 'Œ' */ 'O', /* '¹' */
1366 'O', /* '÷' */ '*', /* '×' */
1367 'O', /* 'ÿ' */ 'U', /* '�' */
1368 'U', /* 'Ž' */ 'U', /* '¤' */
1369 'U', /* 'Ð' */ 'Y', /* 'ð' */
1370 'P', /* 'Þ' */ 'Y', /* 'þ' */
1371 'A', /* 'ý' */ 'A', /* '·' */
1372 'A', /* '’' */ 'A', /* '“' */
1373 'A', /* '”' */ 'A', /* 'Â' */
1374 'A', /* 'Ê' */ 'C', /* 'Á' */
1375 'E', /* 'Ë' */ 'E', /* 'È' */
1376 'E', /* 'Í' */ 'E', /* 'Î' */
1377 'I', /* 'Ï' */ 'I', /* 'Ì' */
1378 'I', /* 'Ó' */ 'I', /* 'Ô' */
1379 'D', /* '•' */ 'N', /* 'Ò' */
1380 'O', /* 'Ú' */ 'O', /* 'Û' */
1381 'O', /* 'Ù' */ 'O', /* 'ž' */
1382 'O', /* '–' */ '/', /* '—' */
1383 'O', /* '¯' */ 'U', /* '˜' */
1384 'U', /* '™' */ 'U', /* 'š' */
1385 'U', /* '¸' */ 'Y', /* '›' */
1386 'P', /* 'œ' */ 'Y', /* '�' */
1387 };
1388
1389
1390
1391 /* This is the end of ROMtag marker. */
1392 const char end=0;
Mirror of AROS' svn.