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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-newlib/] [newlib-1.17.0/] [newlib/] [libc/] [ctype/] [towlower.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
        <<towlower>>---translate wide characters to lowercase
 
INDEX
        towlower
 
ANSI_SYNOPSIS
        #include <wctype.h>
        wint_t towlower(wint_t <[c]>);
 
TRAD_SYNOPSIS
        #include <wctype.h>
        wint_t towlower(<[c]>)
        wint_t <[c]>;
 
 
DESCRIPTION
<<towlower>> is a function which converts uppercase wide characters to
lowercase, leaving all other characters unchanged.
 
RETURNS
<<towlower>> returns the lowercase equivalent of <[c]> when it is a
uppercase wide character; otherwise, it returns the input character.
 
PORTABILITY
<<towlower>> 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(towlower,(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 >= 0x0041 && c <= 0x005a) ||
              (c >= 0x00c0 && c <= 0x00de))
            return (c + 0x20);
 
          if (c == 0x00b5)
            return 0x03bc;
 
          return c;
        }
      else if (c < 0x300)
        {
          if ((c >= 0x0100 && c <= 0x012e) ||
              (c >= 0x0132 && c <= 0x0136) ||
              (c >= 0x014a && c <= 0x0176) ||
              (c >= 0x01de && c <= 0x01ee) ||
              (c >= 0x01f8 && c <= 0x021e) ||
              (c >= 0x0222 && c <= 0x0232))
            {
              if (!(c & 0x01))
                return (c + 1);
              return c;
            }
 
          if ((c >= 0x0139 && c <= 0x0147) ||
              (c >= 0x01cd && c <= 0x91db))
            {
              if (c & 0x01)
                return (c + 1);
              return c;
            }
 
          if (c >= 0x178 && c <= 0x01f7)
            {
              wint_t k;
              switch (c)
                {
                case 0x0178:
                  k = 0x00ff;
                  break;
                case 0x0179:
                case 0x017b:
                case 0x017d:
                case 0x0182:
                case 0x0184:
                case 0x0187:
                case 0x018b:
                case 0x0191:
                case 0x0198:
                case 0x01a0:
                case 0x01a2:
                case 0x01a4:
                case 0x01a7:
                case 0x01ac:
                case 0x01af:
                case 0x01b3:
                case 0x01b5:
                case 0x01b8:
                case 0x01bc:
                case 0x01c5:
                case 0x01c8:
                case 0x01cb:
                case 0x01cd:
                case 0x01cf:
                case 0x01d1:
                case 0x01d3:
                case 0x01d5:
                case 0x01d7:
                case 0x01d9:
                case 0x01db:
                case 0x01f2:
                case 0x01f4:
                  k = c + 1;
                  break;
                case 0x017f:
                  k = 0x0073;
                  break;
                case 0x0181:
                  k = 0x0253;
                  break;
                case 0x0186:
                  k = 0x0254;
                  break;
                case 0x0189:
                  k = 0x0256;
                  break;
                case 0x018a:
                  k = 0x0257;
                  break;
                case 0x018e:
                  k = 0x01dd;
                  break;
                case 0x018f:
                  k = 0x0259;
                  break;
                case 0x0190:
                  k = 0x025b;
                  break;
                case 0x0193:
                  k = 0x0260;
                  break;
                case 0x0194:
                  k = 0x0263;
                  break;
                case 0x0196:
                  k = 0x0269;
                  break;
                case 0x0197:
                  k = 0x0268;
                  break;
                case 0x019c:
                  k = 0x026f;
                  break;
                case 0x019d:
                  k = 0x0272;
                  break;
                case 0x019f:
                  k = 0x0275;
                  break;
                case 0x01a6:
                  k = 0x0280;
                  break;
                case 0x01a9:
                  k = 0x0283;
                  break;
                case 0x01ae:
                  k = 0x0288;
                  break;
                case 0x01b1:
                  k = 0x028a;
                  break;
                case 0x01b2:
                  k = 0x028b;
                  break;
                case 0x01b7:
                  k = 0x0292;
                  break;
                case 0x01c4:
                case 0x01c7:
                case 0x01ca:
                case 0x01f1:
                  k = c + 2;
                  break;
                case 0x01f6:
                  k = 0x0195;
                  break;
                case 0x01f7:
                  k = 0x01bf;
                  break;
                default:
                  k = 0;
                }
              if (k != 0)
                return k;
            }
 
          if (c == 0x0220)
            return 0x019e;
        }
      else if (c < 0x0400)
        {
          if (c >= 0x0391 && c <= 0x03ab && c != 0x03a2)
            return (c + 0x20);
          if (c >= 0x03d8 && c <= 0x03ee && !(c & 0x01))
            return (c + 1);
          if (c >= 0x0386 && c <= 0x03f5)
            {
              wint_t k;
              switch (c)
                {
                case 0x0386:
                  k = 0x03ac;
                  break;
                case 0x0388:
                  k = 0x03ad;
                  break;
                case 0x0389:
                  k = 0x03ae;
                  break;
                case 0x038a:
                  k = 0x03af;
                  break;
                case 0x038c:
                  k = 0x03cc;
                  break;
                case 0x038e:
                  k = 0x03cd;
                  break;
                case 0x038f:
                  k = 0x038f;
                  break;
                case 0x03c2:
                  k = 0x03c3;
                  break;
                case 0x03d0:
                  k = 0x03b2;
                  break;
                case 0x03d1:
                  k = 0x03b8;
                  break;
                case 0x03d5:
                  k = 0x03c6;
                  break;
                case 0x03d6:
                  k = 0x03c0;
                  break;
                case 0x03f0:
                  k = 0x03ba;
                  break;
                case 0x03f1:
                  k = 0x03c1;
                  break;
                case 0x03f2:
                  k = 0x03c3;
                  break;
                case 0x03f4:
                  k = 0x03b8;
                  break;
                case 0x03f5:
                  k = 0x03b5;
                  break;
                default:
                  k = 0;
                }
              if (k != 0)
                return k;
            }
 
          if (c == 0x0345)
            return 0x03b9;
        }
      else if (c < 0x500)
        {
          if (c >= 0x0400 && c <= 0x040f)
            return (c + 0x50);
 
          if (c >= 0x0410 && c <= 0x042f)
            return (c + 0x20);
 
          if ((c >= 0x0460 && c <= 0x0480) ||
              (c >= 0x048a && c <= 0x04be) ||
              (c >= 0x04d0 && c <= 0x04f4) ||
              (c == 0x04f8))
            {
              if (!(c & 0x01))
                return (c + 1);
              return c;
            }
 
          if (c >= 0x04c1 && c <= 0x04cd)
            {
              if (c & 0x01)
                return (c + 1);
              return c;
            }
        }
      else if (c < 0x1f00)
        {
          if ((c >= 0x0500 && c <= 0x050e) ||
              (c >= 0x1e00 && c <= 0x1e94) ||
              (c >= 0x1ea0 && c <= 0x1ef8))
            {
              if (!(c & 0x01))
                return (c + 1);
              return c;
            }
 
          if (c >= 0x0531 && c <= 0x0556)
            return (c + 0x30);
 
          if (c == 0x1e9b)
            return 0x1e61;
        }
      else if (c < 0x2000)
        {
          if ((c >= 0x1f08 && c <= 0x1f0f) ||
              (c >= 0x1f18 && c <= 0x1f1d) ||
              (c >= 0x1f28 && c <= 0x1f2f) ||
              (c >= 0x1f38 && c <= 0x1f3f) ||
              (c >= 0x1f48 && c <= 0x1f4d) ||
              (c >= 0x1f68 && c <= 0x1f6f) ||
              (c >= 0x1f88 && c <= 0x1f8f) ||
              (c >= 0x1f98 && c <= 0x1f9f) ||
              (c >= 0x1fa8 && c <= 0x1faf))
            return (c - 0x08);
 
          if (c >= 0x1f59 && c <= 0x1f5f)
            {
              if (c & 0x01)
                return (c - 0x08);
              return c;
            }
 
          if (c >= 0x1fb8 && c <= 0x1ffc)
            {
              wint_t k;
              switch (c)
                {
                case 0x1fb8:
                case 0x1fb9:
                case 0x1fd8:
                case 0x1fd9:
                case 0x1fe8:
                case 0x1fe9:
                  k = c - 0x08;
                  break;
                case 0x1fba:
                case 0x1fbb:
                  k = c - 0x4a;
                  break;
                case 0x1fbc:
                  k = 0x1fb3;
                  break;
                case 0x1fbe:
                  k = 0x03b9;
                  break;
                case 0x1fc8:
                case 0x1fc9:
                case 0x1fca:
                case 0x1fcb:
                  k = c - 0x56;
                  break;
                case 0x1fcc:
                  k = 0x1fc3;
                  break;
                case 0x1fda:
                case 0x1fdb:
                  k = c - 0x64;
                  break;
                case 0x1fea:
                case 0x1feb:
                  k = c - 0x70;
                  break;
                case 0x1fec:
                  k = 0x1fe5;
                  break;
                case 0x1ffa:
                case 0x1ffb:
                  k = c - 0x7e;
                  break;
                case 0x1ffc:
                  k = 0x1ff3;
                  break;
                default:
                  k = 0;
                }
              if (k != 0)
                return k;
            }
        }
      else
        {
          if (c >= 0x2160 && c <= 0x216f)
            return (c + 0x10);
 
          if (c >= 0x24b6 && c <= 0x24cf)
            return (c + 0x1a);
 
          if (c >= 0xff21 && c <= 0xff3a)
            return (c + 0x20);
 
          if (c >= 0x10400 && c <= 0x10425)
            return (c + 0x28);
 
          if (c == 0x2126)
            return 0x03c9;
          if (c == 0x212a)
            return 0x006b;
          if (c == 0x212b)
            return 0x00e5;
        }
    }
#endif /* _MB_CAPABLE */
 
  return (c < 0x00ff ? (wint_t)(tolower ((int)c)) : c);
}
 

Browse

Tools

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-newlib/] [newlib-1.17.0/] [newlib/] [libc/] [ctype/] [towlower.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			`<<towlower>>---translate wide characters to lowercase`
33
34			`INDEX`
35			`towlower`
36
37			`ANSI_SYNOPSIS`
38			`#include <wctype.h>`
39			`wint_t towlower(wint_t <[c]>);`
40
41			`TRAD_SYNOPSIS`
42			`#include <wctype.h>`
43			`wint_t towlower(<[c]>)`
44			`wint_t <[c]>;`
45
46
47			`DESCRIPTION`
48			`<<towlower>> is a function which converts uppercase wide characters to`
49			`lowercase, leaving all other characters unchanged.`
50
51			`RETURNS`
52			`<<towlower>> returns the lowercase equivalent of <[c]> when it is a`
53			`uppercase wide character; otherwise, it returns the input character.`
54
55			`PORTABILITY`
56			`<<towlower>> 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(towlower,(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 >= 0x0041 && c <= 0x005a) \|\|`
105			`(c >= 0x00c0 && c <= 0x00de))`
106			`return (c + 0x20);`
107
108			`if (c == 0x00b5)`
109			`return 0x03bc;`
110
111			`return c;`
112			`}`
113			`else if (c < 0x300)`
114			`{`
115			`if ((c >= 0x0100 && c <= 0x012e) \|\|`
116			`(c >= 0x0132 && c <= 0x0136) \|\|`
117			`(c >= 0x014a && c <= 0x0176) \|\|`
118			`(c >= 0x01de && c <= 0x01ee) \|\|`
119			`(c >= 0x01f8 && c <= 0x021e) \|\|`
120			`(c >= 0x0222 && c <= 0x0232))`
121			`{`
122			`if (!(c & 0x01))`
123			`return (c + 1);`
124			`return c;`
125			`}`
126
127			`if ((c >= 0x0139 && c <= 0x0147) \|\|`
128			`(c >= 0x01cd && c <= 0x91db))`
129			`{`
130			`if (c & 0x01)`
131			`return (c + 1);`
132			`return c;`
133			`}`
134
135			`if (c >= 0x178 && c <= 0x01f7)`
136			`{`
137			`wint_t k;`
138			`switch (c)`
139			`{`
140			`case 0x0178:`
141			`k = 0x00ff;`
142			`break;`
143			`case 0x0179:`
144			`case 0x017b:`
145			`case 0x017d:`
146			`case 0x0182:`
147			`case 0x0184:`
148			`case 0x0187:`
149			`case 0x018b:`
150			`case 0x0191:`
151			`case 0x0198:`
152			`case 0x01a0:`
153			`case 0x01a2:`
154			`case 0x01a4:`
155			`case 0x01a7:`
156			`case 0x01ac:`
157			`case 0x01af:`
158			`case 0x01b3:`
159			`case 0x01b5:`
160			`case 0x01b8:`
161			`case 0x01bc:`
162			`case 0x01c5:`
163			`case 0x01c8:`
164			`case 0x01cb:`
165			`case 0x01cd:`
166			`case 0x01cf:`
167			`case 0x01d1:`
168			`case 0x01d3:`
169			`case 0x01d5:`
170			`case 0x01d7:`
171			`case 0x01d9:`
172			`case 0x01db:`
173			`case 0x01f2:`
174			`case 0x01f4:`
175			`k = c + 1;`
176			`break;`
177			`case 0x017f:`
178			`k = 0x0073;`
179			`break;`
180			`case 0x0181:`
181			`k = 0x0253;`
182			`break;`
183			`case 0x0186:`
184			`k = 0x0254;`
185			`break;`
186			`case 0x0189:`
187			`k = 0x0256;`
188			`break;`
189			`case 0x018a:`
190			`k = 0x0257;`
191			`break;`
192			`case 0x018e:`
193			`k = 0x01dd;`
194			`break;`
195			`case 0x018f:`
196			`k = 0x0259;`
197			`break;`
198			`case 0x0190:`
199			`k = 0x025b;`
200			`break;`
201			`case 0x0193:`
202			`k = 0x0260;`
203			`break;`
204			`case 0x0194:`
205			`k = 0x0263;`
206			`break;`
207			`case 0x0196:`
208			`k = 0x0269;`
209			`break;`
210			`case 0x0197:`
211			`k = 0x0268;`
212			`break;`
213			`case 0x019c:`
214			`k = 0x026f;`
215			`break;`
216			`case 0x019d:`
217			`k = 0x0272;`
218			`break;`
219			`case 0x019f:`
220			`k = 0x0275;`
221			`break;`
222			`case 0x01a6:`
223			`k = 0x0280;`
224			`break;`
225			`case 0x01a9:`
226			`k = 0x0283;`
227			`break;`
228			`case 0x01ae:`
229			`k = 0x0288;`
230			`break;`
231			`case 0x01b1:`
232			`k = 0x028a;`
233			`break;`
234			`case 0x01b2:`
235			`k = 0x028b;`
236			`break;`
237			`case 0x01b7:`
238			`k = 0x0292;`
239			`break;`
240			`case 0x01c4:`
241			`case 0x01c7:`
242			`case 0x01ca:`
243			`case 0x01f1:`
244			`k = c + 2;`
245			`break;`
246			`case 0x01f6:`
247			`k = 0x0195;`
248			`break;`
249			`case 0x01f7:`
250			`k = 0x01bf;`
251			`break;`
252			`default:`
253			`k = 0;`
254			`}`
255			`if (k != 0)`
256			`return k;`
257			`}`
258
259			`if (c == 0x0220)`
260			`return 0x019e;`
261			`}`
262			`else if (c < 0x0400)`
263			`{`
264			`if (c >= 0x0391 && c <= 0x03ab && c != 0x03a2)`
265			`return (c + 0x20);`
266			`if (c >= 0x03d8 && c <= 0x03ee && !(c & 0x01))`
267			`return (c + 1);`
268			`if (c >= 0x0386 && c <= 0x03f5)`
269			`{`
270			`wint_t k;`
271			`switch (c)`
272			`{`
273			`case 0x0386:`
274			`k = 0x03ac;`
275			`break;`
276			`case 0x0388:`
277			`k = 0x03ad;`
278			`break;`
279			`case 0x0389:`
280			`k = 0x03ae;`
281			`break;`
282			`case 0x038a:`
283			`k = 0x03af;`
284			`break;`
285			`case 0x038c:`
286			`k = 0x03cc;`
287			`break;`
288			`case 0x038e:`
289			`k = 0x03cd;`
290			`break;`
291			`case 0x038f:`
292			`k = 0x038f;`
293			`break;`
294			`case 0x03c2:`
295			`k = 0x03c3;`
296			`break;`
297			`case 0x03d0:`
298			`k = 0x03b2;`
299			`break;`
300			`case 0x03d1:`
301			`k = 0x03b8;`
302			`break;`
303			`case 0x03d5:`
304			`k = 0x03c6;`
305			`break;`
306			`case 0x03d6:`
307			`k = 0x03c0;`
308			`break;`
309			`case 0x03f0:`
310			`k = 0x03ba;`
311			`break;`
312			`case 0x03f1:`
313			`k = 0x03c1;`
314			`break;`
315			`case 0x03f2:`
316			`k = 0x03c3;`
317			`break;`
318			`case 0x03f4:`
319			`k = 0x03b8;`
320			`break;`
321			`case 0x03f5:`
322			`k = 0x03b5;`
323			`break;`
324			`default:`
325			`k = 0;`
326			`}`
327			`if (k != 0)`
328			`return k;`
329			`}`
330
331			`if (c == 0x0345)`
332			`return 0x03b9;`
333			`}`
334			`else if (c < 0x500)`
335			`{`
336			`if (c >= 0x0400 && c <= 0x040f)`
337			`return (c + 0x50);`
338
339			`if (c >= 0x0410 && c <= 0x042f)`
340			`return (c + 0x20);`
341
342			`if ((c >= 0x0460 && c <= 0x0480) \|\|`
343			`(c >= 0x048a && c <= 0x04be) \|\|`
344			`(c >= 0x04d0 && c <= 0x04f4) \|\|`
345			`(c == 0x04f8))`
346			`{`
347			`if (!(c & 0x01))`
348			`return (c + 1);`
349			`return c;`
350			`}`
351
352			`if (c >= 0x04c1 && c <= 0x04cd)`
353			`{`
354			`if (c & 0x01)`
355			`return (c + 1);`
356			`return c;`
357			`}`
358			`}`
359			`else if (c < 0x1f00)`
360			`{`
361			`if ((c >= 0x0500 && c <= 0x050e) \|\|`
362			`(c >= 0x1e00 && c <= 0x1e94) \|\|`
363			`(c >= 0x1ea0 && c <= 0x1ef8))`
364			`{`
365			`if (!(c & 0x01))`
366			`return (c + 1);`
367			`return c;`
368			`}`
369
370			`if (c >= 0x0531 && c <= 0x0556)`
371			`return (c + 0x30);`
372
373			`if (c == 0x1e9b)`
374			`return 0x1e61;`
375			`}`
376			`else if (c < 0x2000)`
377			`{`
378			`if ((c >= 0x1f08 && c <= 0x1f0f) \|\|`
379			`(c >= 0x1f18 && c <= 0x1f1d) \|\|`
380			`(c >= 0x1f28 && c <= 0x1f2f) \|\|`
381			`(c >= 0x1f38 && c <= 0x1f3f) \|\|`
382			`(c >= 0x1f48 && c <= 0x1f4d) \|\|`
383			`(c >= 0x1f68 && c <= 0x1f6f) \|\|`
384			`(c >= 0x1f88 && c <= 0x1f8f) \|\|`
385			`(c >= 0x1f98 && c <= 0x1f9f) \|\|`
386			`(c >= 0x1fa8 && c <= 0x1faf))`
387			`return (c - 0x08);`
388
389			`if (c >= 0x1f59 && c <= 0x1f5f)`
390			`{`
391			`if (c & 0x01)`
392			`return (c - 0x08);`
393			`return c;`
394			`}`
395
396			`if (c >= 0x1fb8 && c <= 0x1ffc)`
397			`{`
398			`wint_t k;`
399			`switch (c)`
400			`{`
401			`case 0x1fb8:`
402			`case 0x1fb9:`
403			`case 0x1fd8:`
404			`case 0x1fd9:`
405			`case 0x1fe8:`
406			`case 0x1fe9:`
407			`k = c - 0x08;`
408			`break;`
409			`case 0x1fba:`
410			`case 0x1fbb:`
411			`k = c - 0x4a;`
412			`break;`
413			`case 0x1fbc:`
414			`k = 0x1fb3;`
415			`break;`
416			`case 0x1fbe:`
417			`k = 0x03b9;`
418			`break;`
419			`case 0x1fc8:`
420			`case 0x1fc9:`
421			`case 0x1fca:`
422			`case 0x1fcb:`
423			`k = c - 0x56;`
424			`break;`
425			`case 0x1fcc:`
426			`k = 0x1fc3;`
427			`break;`
428			`case 0x1fda:`
429			`case 0x1fdb:`
430			`k = c - 0x64;`
431			`break;`
432			`case 0x1fea:`
433			`case 0x1feb:`
434			`k = c - 0x70;`
435			`break;`
436			`case 0x1fec:`
437			`k = 0x1fe5;`
438			`break;`
439			`case 0x1ffa:`
440			`case 0x1ffb:`
441			`k = c - 0x7e;`
442			`break;`
443			`case 0x1ffc:`
444			`k = 0x1ff3;`
445			`break;`
446			`default:`
447			`k = 0;`
448			`}`
449			`if (k != 0)`
450			`return k;`
451			`}`
452			`}`
453			`else`
454			`{`
455			`if (c >= 0x2160 && c <= 0x216f)`
456			`return (c + 0x10);`
457
458			`if (c >= 0x24b6 && c <= 0x24cf)`
459			`return (c + 0x1a);`
460
461			`if (c >= 0xff21 && c <= 0xff3a)`
462			`return (c + 0x20);`
463
464			`if (c >= 0x10400 && c <= 0x10425)`
465			`return (c + 0x28);`
466
467			`if (c == 0x2126)`
468			`return 0x03c9;`
469			`if (c == 0x212a)`
470			`return 0x006b;`
471			`if (c == 0x212b)`
472			`return 0x00e5;`
473			`}`
474			`}`
475			`#endif /* _MB_CAPABLE */`
476
477			`return (c < 0x00ff ? (wint_t)(tolower ((int)c)) : c);`
478			`}`
479