URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-newlib/] [newlib-1.17.0/] [newlib/] [libc/] [ctype/] [towupper.c] - Blame information for rev 9

Details | Compare with Previous | View Log


/* Copyright (c) 2002 Red Hat Incorporated.
   All rights reserved.
 
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are met:
 
     Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
 
     Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
 
     The name of Red Hat Incorporated may not be used to endorse
     or promote products derived from this software without specific
     prior written permission.
 
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   ARE DISCLAIMED.  IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY
   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/*
FUNCTION
        <<towupper>>---translate wide characters to uppercase
 
INDEX
        towupper
 
ANSI_SYNOPSIS
        #include <wctype.h>
        wint_t towupper(wint_t <[c]>);
 
TRAD_SYNOPSIS
        #include <wctype.h>
        wint_t towupper(<[c]>)
        wint_t <[c]>;
 
 
DESCRIPTION
<<towupper>> is a function which converts lowercase wide characters to
uppercase, leaving all other characters unchanged.
 
RETURNS
<<towupper>> returns the uppercase equivalent of <[c]> when it is a
lowercase wide character, otherwise, it returns the input character.
 
PORTABILITY
<<towupper>> is C99.
 
No supporting OS subroutines are required.
*/
 
#include <_ansi.h>
#include <newlib.h>
#include <string.h>
#include <reent.h>
#include <ctype.h>
#include <wctype.h>
#include "local.h"
 
wint_t
_DEFUN(towupper,(c), wint_t c)
{
  int unicode = 0;
 
  if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')
    {
      unicode = 0;
      /* fall-through */
    }
#ifdef _MB_CAPABLE
  else if (!strcmp (__lc_ctype, "C-JIS"))
    {
      c = __jp2uc (c, JP_JIS);
      unicode = 1;
    }
  else if (!strcmp (__lc_ctype, "C-SJIS"))
    {
      c = __jp2uc (c, JP_SJIS);
      unicode = 1;
    }
  else if (!strcmp (__lc_ctype, "C-EUCJP"))
    {
      c = __jp2uc (c, JP_EUCJP);
      unicode = 1;
    }
  else if (!strcmp (__lc_ctype, "C-UTF-8"))
    {
      unicode = 1;
    }
 
  if (unicode)
    {
      if (c < 0x100)
        {
          if (c == 0x00b5)
            return 0x039c;
 
          if ((c >= 0x00e0 && c <= 0x00fe) ||
              (c >= 0x0061 && c <= 0x007a))
            return (c - 0x20);
 
          if (c == 0xff)
            return 0x0178;
 
          return c;
        }
      else if (c < 0x300)
        {
          if ((c >= 0x0101 && c <= 0x012f) ||
              (c >= 0x0133 && c <= 0x0137) ||
              (c >= 0x014b && c <= 0x0177) ||
              (c >= 0x01df && c <= 0x01ef) ||
              (c >= 0x01f9 && c <= 0x021f) ||
              (c >= 0x0223 && c <= 0x0233))
            {
              if (c & 0x01)
                return (c - 1);
              return c;
            }
 
          if ((c >= 0x013a && c <= 0x0148) ||
              (c >= 0x01ce && c <= 0x1dc))
            {
              if (!(c & 0x01))
                return (c - 1);
              return c;
            }
 
          if (c == 0x0131)
            return 0x0049;
 
          if (c == 0x017a || c == 0x017c || c == 0x017e)
            return (c - 1);
 
          if (c >= 0x017f && c <= 0x0292)
            {
              wint_t k;
              switch (c)
                {
                case 0x017f:
                  k = 0x0053;
                  break;
                case 0x0183:
                  k = 0x0182;
                  break;
                case 0x0185:
                  k = 0x0184;
                  break;
                case 0x0188:
                  k = 0x0187;
                  break;
                case 0x018c:
                  k = 0x018b;
                  break;
                case 0x0192:
                  k = 0x0191;
                  break;
                case 0x0195:
                  k = 0x01f6;
                  break;
                case 0x0199:
                  k = 0x0198;
                  break;
                case 0x019e:
                  k = 0x0220;
                  break;
                case 0x01a1:
                case 0x01a3:
                case 0x01a5:
                case 0x01a8:
                case 0x01ad:
                case 0x01b0:
                case 0x01b4:
                case 0x01b6:
                case 0x01b9:
                case 0x01bd:
                case 0x01c5:
                case 0x01c8:
                case 0x01cb:
                case 0x01f2:
                case 0x01f5:
                  k = c - 1;
                  break;
                case 0x01bf:
                  k = 0x01f7;
                  break;
                case 0x01c6:
                case 0x01c9:
                case 0x01cc:
                  k = c - 2;
                  break;
                case 0x01dd:
                  k = 0x018e;
                  break;
                case 0x01f3:
                  k = 0x01f1;
                  break;
                case 0x0253:
                  k = 0x0181;
                  break;
                case 0x0254:
                  k = 0x0186;
                  break;
                case 0x0256:
                  k = 0x0189;
                  break;
                case 0x0257:
                  k = 0x018a;
                  break;
                case 0x0259:
                  k = 0x018f;
                  break;
                case 0x025b:
                  k = 0x0190;
                  break;
                case 0x0260:
                  k = 0x0193;
                  break;
                case 0x0263:
                  k = 0x0194;
                  break;
                case 0x0268:
                  k = 0x0197;
                  break;
                case 0x0269:
                  k = 0x0196;
                  break;
                case 0x026f:
                  k = 0x019c;
                  break;
                case 0x0272:
                  k = 0x019d;
                  break;
                case 0x0275:
                  k = 0x019f;
                  break;
                case 0x0280:
                  k = 0x01a6;
                  break;
                case 0x0283:
                  k = 0x01a9;
                  break;
                case 0x0288:
                  k = 0x01ae;
                  break;
                case 0x028a:
                  k = 0x01b1;
                  break;
                case 0x028b:
                  k = 0x01b2;
                  break;
                case 0x0292:
                  k = 0x01b7;
                  break;
                default:
                  k = 0;
                }
              if (k != 0)
                return k;
            }
        }
      else if (c < 0x0400)
        {
          if (c == 0x03ac)
            return 0x0386;
 
          if ((c & 0xfff0) == 0x03a0 && c >= 0x03ad)
            return (c - 0x15);
 
          if (c >= 0x03b1 && c <= 0x03cb && c != 0x03c2)
            return (c - 0x20);
 
          if (c == 0x03c2)
            return 0x03a3;
 
          if (c >= 0x03cc && c <= 0x03f5)
            {
              wint_t k;
              switch (c)
                {
                case 0x03cc:
                  k = 0x038c;
                  break;
                case 0x03cd:
                case 0x03ce:
                  k = c - 0x3f;
                  break;
                case 0x03d0:
                  k = 0x0392;
                  break;
                case 0x03d1:
                  k = 0x0398;
                  break;
                case 0x03d5:
                  k = 0x03a6;
                  break;
                case 0x03d6:
                  k = 0x03a0;
                  break;
                case 0x03d9:
                case 0x03db:
                case 0x03dd:
                case 0x03df:
                case 0x03e1:
                case 0x03e3:
                case 0x03e5:
                case 0x03e7:
                case 0x03e9:
                case 0x03eb:
                case 0x03ed:
                case 0x03ef:
                  k = c - 1;
                  break;
                case 0x03f0:
                  k = 0x039a;
                  break;
                case 0x03f1:
                  k = 0x03a1;
                  break;
                case 0x03f2:
                  k = 0x03a3;
                  break;
                case 0x03f5:
                  k = 0x0395;
                  break;
                default:
                  k = 0;
                }
              if (k != 0)
                return k;
            }
        }
      else if (c < 0x500)
        {
          if (c >= 0x0450 && c <= 0x045f)
            return (c - 0x50);
 
          if (c >= 0x0430 && c <= 0x044f)
            return (c - 0x20);
 
          if ((c >= 0x0461 && c <= 0x0481) ||
              (c >= 0x048b && c <= 0x04bf) ||
              (c >= 0x04d1 && c <= 0x04f5))
            {
              if (c & 0x01)
                return (c - 1);
              return c;
            }
 
          if (c >= 0x04c2 && c <= 0x04ce)
            {
              if (!(c & 0x01))
                return (c - 1);
              return c;
            }
 
          if (c == 0x04f9)
            return 0x04f8;
        }
      else if (c < 0x1f00)
        {
          if ((c >= 0x0501 && c <= 0x050f) ||
              (c >= 0x1e01 && c <= 0x1e95) ||
              (c >= 0x1ea1 && c <= 0x1ef9))
            {
              if (c & 0x01)
                return (c - 1);
              return c;
            }
 
          if (c >= 0x0561 && c <= 0x0586)
            return (c - 0x30);
 
          if (c == 0x1e9b)
            return 0x1e60;
        }
      else if (c < 0x2000)
        {
 
          if ((c >= 0x1f00 && c <= 0x1f07) ||
              (c >= 0x1f10 && c <= 0x1f15) ||
              (c >= 0x1f20 && c <= 0x1f27) ||
              (c >= 0x1f30 && c <= 0x1f37) ||
              (c >= 0x1f40 && c <= 0x1f45) ||
              (c >= 0x1f60 && c <= 0x1f67) ||
              (c >= 0x1f80 && c <= 0x1f87) ||
              (c >= 0x1f90 && c <= 0x1f97) ||
              (c >= 0x1fa0 && c <= 0x1fa7))
            return (c + 0x08);
 
          if (c >= 0x1f51 && c <= 0x1f57 && (c & 0x01))
            return (c + 0x08);
 
          if (c >= 0x1f70 && c <= 0x1ff3)
            {
              wint_t k;
              switch (c)
                {
                case 0x1fb0:
                  k = 0x1fb8;
                  break;
                case 0x1fb1:
                  k = 0x1fb9;
                  break;
                case 0x1f70:
                  k = 0x1fba;
                  break;
                case 0x1f71:
                  k = 0x1fbb;
                  break;
                case 0x1fb3:
                  k = 0x1fbc;
                  break;
                case 0x1fbe:
                  k = 0x0399;
                  break;
                case 0x1f72:
                  k = 0x1fc8;
                  break;
                case 0x1f73:
                  k = 0x1fc9;
                  break;
                case 0x1f74:
                  k = 0x1fca;
                  break;
                case 0x1f75:
                  k = 0x1fcb;
                  break;
                case 0x1fd0:
                  k = 0x1fd8;
                  break;
                case 0x1fd1:
                  k = 0x1fd9;
                  break;
                case 0x1f76:
                  k = 0x1fda;
                  break;
                case 0x1f77:
                  k = 0x1fdb;
                  break;
                case 0x1fe0:
                  k = 0x1fe8;
                  break;
                case 0x1fe1:
                  k = 0x1fe9;
                  break;
                case 0x1f7a:
                  k = 0x1fea;
                  break;
                case 0x1f7b:
                  k = 0x1feb;
                  break;
                case 0x1fe5:
                  k = 0x1fec;
                  break;
                case 0x1f78:
                  k = 0x1ff8;
                  break;
                case 0x1f79:
                  k = 0x1ff9;
                  break;
                case 0x1f7c:
                  k = 0x1ffa;
                  break;
                case 0x1f7d:
                  k = 0x1ffb;
                  break;
                case 0x1ff3:
                  k = 0x1ffc;
                  break;
                default:
                  k = 0;
                }
              if (k != 0)
                return k;
            }
        }
      else
        {
          if (c >= 0x2170 && c <= 0x217f)
            return (c - 0x10);
 
          if (c >= 0x24d0 && c <= 0x24e9)
            return (c - 0x1a);
 
          if (c >= 0xff41 && c <= 0xff5a)
            return (c - 0x20);
 
          if (c >= 0x10428 && c <= 0x1044d)
            return (c - 0x28);
        }
    }
#endif /* _MB_CAPABLE */
 
  return (c < 0x00ff ? (wint_t)(toupper ((int)c)) : c);
}
 

Browse

Tools

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-newlib/] [newlib-1.17.0/] [newlib/] [libc/] [ctype/] [towupper.c] - Blame information for rev 9

Line No.	Rev	Author	Line
1	9	jlechner	`/* Copyright (c) 2002 Red Hat Incorporated.`
2			`All rights reserved.`
3
4			`Redistribution and use in source and binary forms, with or without`
5			`modification, are permitted provided that the following conditions are met:`
6
7			`Redistributions of source code must retain the above copyright`
8			`notice, this list of conditions and the following disclaimer.`
9
10			`Redistributions in binary form must reproduce the above copyright`
11			`notice, this list of conditions and the following disclaimer in the`
12			`documentation and/or other materials provided with the distribution.`
13
14			`The name of Red Hat Incorporated may not be used to endorse`
15			`or promote products derived from this software without specific`
16			`prior written permission.`
17
18			`THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"`
19			`AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE`
20			`IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE`
21			`ARE DISCLAIMED. IN NO EVENT SHALL RED HAT INCORPORATED BE LIABLE FOR ANY`
22			`DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES`
23			`(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;`
24			`LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND`
25			`ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT`
26			`(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS`
27			`SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.`
28			`*/`
29
30			`/*`
31			`FUNCTION`
32			`<<towupper>>---translate wide characters to uppercase`
33
34			`INDEX`
35			`towupper`
36
37			`ANSI_SYNOPSIS`
38			`#include <wctype.h>`
39			`wint_t towupper(wint_t <[c]>);`
40
41			`TRAD_SYNOPSIS`
42			`#include <wctype.h>`
43			`wint_t towupper(<[c]>)`
44			`wint_t <[c]>;`
45
46
47			`DESCRIPTION`
48			`<<towupper>> is a function which converts lowercase wide characters to`
49			`uppercase, leaving all other characters unchanged.`
50
51			`RETURNS`
52			`<<towupper>> returns the uppercase equivalent of <[c]> when it is a`
53			`lowercase wide character, otherwise, it returns the input character.`
54
55			`PORTABILITY`
56			`<<towupper>> is C99.`
57
58			`No supporting OS subroutines are required.`
59			`*/`
60
61			`#include <_ansi.h>`
62			`#include <newlib.h>`
63			`#include <string.h>`
64			`#include <reent.h>`
65			`#include <ctype.h>`
66			`#include <wctype.h>`
67			`#include "local.h"`
68
69			`wint_t`
70			`_DEFUN(towupper,(c), wint_t c)`
71			`{`
72			`int unicode = 0;`
73
74			`if (__lc_ctype[0] == 'C' && __lc_ctype[1] == '\0')`
75			`{`
76			`unicode = 0;`
77			`/* fall-through */`
78			`}`
79			`#ifdef _MB_CAPABLE`
80			`else if (!strcmp (__lc_ctype, "C-JIS"))`
81			`{`
82			`c = __jp2uc (c, JP_JIS);`
83			`unicode = 1;`
84			`}`
85			`else if (!strcmp (__lc_ctype, "C-SJIS"))`
86			`{`
87			`c = __jp2uc (c, JP_SJIS);`
88			`unicode = 1;`
89			`}`
90			`else if (!strcmp (__lc_ctype, "C-EUCJP"))`
91			`{`
92			`c = __jp2uc (c, JP_EUCJP);`
93			`unicode = 1;`
94			`}`
95			`else if (!strcmp (__lc_ctype, "C-UTF-8"))`
96			`{`
97			`unicode = 1;`
98			`}`
99
100			`if (unicode)`
101			`{`
102			`if (c < 0x100)`
103			`{`
104			`if (c == 0x00b5)`
105			`return 0x039c;`
106
107			`if ((c >= 0x00e0 && c <= 0x00fe) \|\|`
108			`(c >= 0x0061 && c <= 0x007a))`
109			`return (c - 0x20);`
110
111			`if (c == 0xff)`
112			`return 0x0178;`
113
114			`return c;`
115			`}`
116			`else if (c < 0x300)`
117			`{`
118			`if ((c >= 0x0101 && c <= 0x012f) \|\|`
119			`(c >= 0x0133 && c <= 0x0137) \|\|`
120			`(c >= 0x014b && c <= 0x0177) \|\|`
121			`(c >= 0x01df && c <= 0x01ef) \|\|`
122			`(c >= 0x01f9 && c <= 0x021f) \|\|`
123			`(c >= 0x0223 && c <= 0x0233))`
124			`{`
125			`if (c & 0x01)`
126			`return (c - 1);`
127			`return c;`
128			`}`
129
130			`if ((c >= 0x013a && c <= 0x0148) \|\|`
131			`(c >= 0x01ce && c <= 0x1dc))`
132			`{`
133			`if (!(c & 0x01))`
134			`return (c - 1);`
135			`return c;`
136			`}`
137
138			`if (c == 0x0131)`
139			`return 0x0049;`
140
141			`if (c == 0x017a \|\| c == 0x017c \|\| c == 0x017e)`
142			`return (c - 1);`
143
144			`if (c >= 0x017f && c <= 0x0292)`
145			`{`
146			`wint_t k;`
147			`switch (c)`
148			`{`
149			`case 0x017f:`
150			`k = 0x0053;`
151			`break;`
152			`case 0x0183:`
153			`k = 0x0182;`
154			`break;`
155			`case 0x0185:`
156			`k = 0x0184;`
157			`break;`
158			`case 0x0188:`
159			`k = 0x0187;`
160			`break;`
161			`case 0x018c:`
162			`k = 0x018b;`
163			`break;`
164			`case 0x0192:`
165			`k = 0x0191;`
166			`break;`
167			`case 0x0195:`
168			`k = 0x01f6;`
169			`break;`
170			`case 0x0199:`
171			`k = 0x0198;`
172			`break;`
173			`case 0x019e:`
174			`k = 0x0220;`
175			`break;`
176			`case 0x01a1:`
177			`case 0x01a3:`
178			`case 0x01a5:`
179			`case 0x01a8:`
180			`case 0x01ad:`
181			`case 0x01b0:`
182			`case 0x01b4:`
183			`case 0x01b6:`
184			`case 0x01b9:`
185			`case 0x01bd:`
186			`case 0x01c5:`
187			`case 0x01c8:`
188			`case 0x01cb:`
189			`case 0x01f2:`
190			`case 0x01f5:`
191			`k = c - 1;`
192			`break;`
193			`case 0x01bf:`
194			`k = 0x01f7;`
195			`break;`
196			`case 0x01c6:`
197			`case 0x01c9:`
198			`case 0x01cc:`
199			`k = c - 2;`
200			`break;`
201			`case 0x01dd:`
202			`k = 0x018e;`
203			`break;`
204			`case 0x01f3:`
205			`k = 0x01f1;`
206			`break;`
207			`case 0x0253:`
208			`k = 0x0181;`
209			`break;`
210			`case 0x0254:`
211			`k = 0x0186;`
212			`break;`
213			`case 0x0256:`
214			`k = 0x0189;`
215			`break;`
216			`case 0x0257:`
217			`k = 0x018a;`
218			`break;`
219			`case 0x0259:`
220			`k = 0x018f;`
221			`break;`
222			`case 0x025b:`
223			`k = 0x0190;`
224			`break;`
225			`case 0x0260:`
226			`k = 0x0193;`
227			`break;`
228			`case 0x0263:`
229			`k = 0x0194;`
230			`break;`
231			`case 0x0268:`
232			`k = 0x0197;`
233			`break;`
234			`case 0x0269:`
235			`k = 0x0196;`
236			`break;`
237			`case 0x026f:`
238			`k = 0x019c;`
239			`break;`
240			`case 0x0272:`
241			`k = 0x019d;`
242			`break;`
243			`case 0x0275:`
244			`k = 0x019f;`
245			`break;`
246			`case 0x0280:`
247			`k = 0x01a6;`
248			`break;`
249			`case 0x0283:`
250			`k = 0x01a9;`
251			`break;`
252			`case 0x0288:`
253			`k = 0x01ae;`
254			`break;`
255			`case 0x028a:`
256			`k = 0x01b1;`
257			`break;`
258			`case 0x028b:`
259			`k = 0x01b2;`
260			`break;`
261			`case 0x0292:`
262			`k = 0x01b7;`
263			`break;`
264			`default:`
265			`k = 0;`
266			`}`
267			`if (k != 0)`
268			`return k;`
269			`}`
270			`}`
271			`else if (c < 0x0400)`
272			`{`
273			`if (c == 0x03ac)`
274			`return 0x0386;`
275
276			`if ((c & 0xfff0) == 0x03a0 && c >= 0x03ad)`
277			`return (c - 0x15);`
278
279			`if (c >= 0x03b1 && c <= 0x03cb && c != 0x03c2)`
280			`return (c - 0x20);`
281
282			`if (c == 0x03c2)`
283			`return 0x03a3;`
284
285			`if (c >= 0x03cc && c <= 0x03f5)`
286			`{`
287			`wint_t k;`
288			`switch (c)`
289			`{`
290			`case 0x03cc:`
291			`k = 0x038c;`
292			`break;`
293			`case 0x03cd:`
294			`case 0x03ce:`
295			`k = c - 0x3f;`
296			`break;`
297			`case 0x03d0:`
298			`k = 0x0392;`
299			`break;`
300			`case 0x03d1:`
301			`k = 0x0398;`
302			`break;`
303			`case 0x03d5:`
304			`k = 0x03a6;`
305			`break;`
306			`case 0x03d6:`
307			`k = 0x03a0;`
308			`break;`
309			`case 0x03d9:`
310			`case 0x03db:`
311			`case 0x03dd:`
312			`case 0x03df:`
313			`case 0x03e1:`
314			`case 0x03e3:`
315			`case 0x03e5:`
316			`case 0x03e7:`
317			`case 0x03e9:`
318			`case 0x03eb:`
319			`case 0x03ed:`
320			`case 0x03ef:`
321			`k = c - 1;`
322			`break;`
323			`case 0x03f0:`
324			`k = 0x039a;`
325			`break;`
326			`case 0x03f1:`
327			`k = 0x03a1;`
328			`break;`
329			`case 0x03f2:`
330			`k = 0x03a3;`
331			`break;`
332			`case 0x03f5:`
333			`k = 0x0395;`
334			`break;`
335			`default:`
336			`k = 0;`
337			`}`
338			`if (k != 0)`
339			`return k;`
340			`}`
341			`}`
342			`else if (c < 0x500)`
343			`{`
344			`if (c >= 0x0450 && c <= 0x045f)`
345			`return (c - 0x50);`
346
347			`if (c >= 0x0430 && c <= 0x044f)`
348			`return (c - 0x20);`
349
350			`if ((c >= 0x0461 && c <= 0x0481) \|\|`
351			`(c >= 0x048b && c <= 0x04bf) \|\|`
352			`(c >= 0x04d1 && c <= 0x04f5))`
353			`{`
354			`if (c & 0x01)`
355			`return (c - 1);`
356			`return c;`
357			`}`
358
359			`if (c >= 0x04c2 && c <= 0x04ce)`
360			`{`
361			`if (!(c & 0x01))`
362			`return (c - 1);`
363			`return c;`
364			`}`
365
366			`if (c == 0x04f9)`
367			`return 0x04f8;`
368			`}`
369			`else if (c < 0x1f00)`
370			`{`
371			`if ((c >= 0x0501 && c <= 0x050f) \|\|`
372			`(c >= 0x1e01 && c <= 0x1e95) \|\|`
373			`(c >= 0x1ea1 && c <= 0x1ef9))`
374			`{`
375			`if (c & 0x01)`
376			`return (c - 1);`
377			`return c;`
378			`}`
379
380			`if (c >= 0x0561 && c <= 0x0586)`
381			`return (c - 0x30);`
382
383			`if (c == 0x1e9b)`
384			`return 0x1e60;`
385			`}`
386			`else if (c < 0x2000)`
387			`{`
388
389			`if ((c >= 0x1f00 && c <= 0x1f07) \|\|`
390			`(c >= 0x1f10 && c <= 0x1f15) \|\|`
391			`(c >= 0x1f20 && c <= 0x1f27) \|\|`
392			`(c >= 0x1f30 && c <= 0x1f37) \|\|`
393			`(c >= 0x1f40 && c <= 0x1f45) \|\|`
394			`(c >= 0x1f60 && c <= 0x1f67) \|\|`
395			`(c >= 0x1f80 && c <= 0x1f87) \|\|`
396			`(c >= 0x1f90 && c <= 0x1f97) \|\|`
397			`(c >= 0x1fa0 && c <= 0x1fa7))`
398			`return (c + 0x08);`
399
400			`if (c >= 0x1f51 && c <= 0x1f57 && (c & 0x01))`
401			`return (c + 0x08);`
402
403			`if (c >= 0x1f70 && c <= 0x1ff3)`
404			`{`
405			`wint_t k;`
406			`switch (c)`
407			`{`
408			`case 0x1fb0:`
409			`k = 0x1fb8;`
410			`break;`
411			`case 0x1fb1:`
412			`k = 0x1fb9;`
413			`break;`
414			`case 0x1f70:`
415			`k = 0x1fba;`
416			`break;`
417			`case 0x1f71:`
418			`k = 0x1fbb;`
419			`break;`
420			`case 0x1fb3:`
421			`k = 0x1fbc;`
422			`break;`
423			`case 0x1fbe:`
424			`k = 0x0399;`
425			`break;`
426			`case 0x1f72:`
427			`k = 0x1fc8;`
428			`break;`
429			`case 0x1f73:`
430			`k = 0x1fc9;`
431			`break;`
432			`case 0x1f74:`
433			`k = 0x1fca;`
434			`break;`
435			`case 0x1f75:`
436			`k = 0x1fcb;`
437			`break;`
438			`case 0x1fd0:`
439			`k = 0x1fd8;`
440			`break;`
441			`case 0x1fd1:`
442			`k = 0x1fd9;`
443			`break;`
444			`case 0x1f76:`
445			`k = 0x1fda;`
446			`break;`
447			`case 0x1f77:`
448			`k = 0x1fdb;`
449			`break;`
450			`case 0x1fe0:`
451			`k = 0x1fe8;`
452			`break;`
453			`case 0x1fe1:`
454			`k = 0x1fe9;`
455			`break;`
456			`case 0x1f7a:`
457			`k = 0x1fea;`
458			`break;`
459			`case 0x1f7b:`
460			`k = 0x1feb;`
461			`break;`
462			`case 0x1fe5:`
463			`k = 0x1fec;`
464			`break;`
465			`case 0x1f78:`
466			`k = 0x1ff8;`
467			`break;`
468			`case 0x1f79:`
469			`k = 0x1ff9;`
470			`break;`
471			`case 0x1f7c:`
472			`k = 0x1ffa;`
473			`break;`
474			`case 0x1f7d:`
475			`k = 0x1ffb;`
476			`break;`
477			`case 0x1ff3:`
478			`k = 0x1ffc;`
479			`break;`
480			`default:`
481			`k = 0;`
482			`}`
483			`if (k != 0)`
484			`return k;`
485			`}`
486			`}`
487			`else`
488			`{`
489			`if (c >= 0x2170 && c <= 0x217f)`
490			`return (c - 0x10);`
491
492			`if (c >= 0x24d0 && c <= 0x24e9)`
493			`return (c - 0x1a);`
494
495			`if (c >= 0xff41 && c <= 0xff5a)`
496			`return (c - 0x20);`
497
498			`if (c >= 0x10428 && c <= 0x1044d)`
499			`return (c - 0x28);`
500			`}`
501			`}`
502			`#endif /* _MB_CAPABLE */`
503
504			`return (c < 0x00ff ? (wint_t)(toupper ((int)c)) : c);`
505			`}`
506