Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /* 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. #ifdef _MB_CAPABLE
  73.   c = _jp2uc (c);
  74.   /* Based on and tested against Unicode 5.2 */
  75.  
  76.   /* Expression used to filter out the characters for the below code:
  77.  
  78.      awk -F\; '{ if ( $13 != "" ) print $1; }' UnicodeData.txt
  79.   */
  80.   if (c < 0x100)
  81.     {
  82.       if (c == 0x00b5)
  83.         return 0x039c;
  84.      
  85.       if ((c >= 0x00e0 && c <= 0x00fe && c != 0x00f7) ||
  86.           (c >= 0x0061 && c <= 0x007a))
  87.         return (c - 0x20);
  88.      
  89.       if (c == 0xff)
  90.         return 0x0178;
  91.      
  92.       return c;
  93.     }
  94.   else if (c < 0x300)
  95.     {
  96.       if ((c >= 0x0101 && c <= 0x012f) ||
  97.           (c >= 0x0133 && c <= 0x0137) ||
  98.           (c >= 0x014b && c <= 0x0177) ||
  99.           (c >= 0x01df && c <= 0x01ef) ||
  100.           (c >= 0x01f9 && c <= 0x021f) ||
  101.           (c >= 0x0223 && c <= 0x0233) ||
  102.           (c >= 0x0247 && c <= 0x024f))
  103.         {
  104.           if (c & 0x01)
  105.             return (c - 1);
  106.           return c;
  107.         }
  108.  
  109.       if ((c >= 0x013a && c <= 0x0148) ||
  110.           (c >= 0x01ce && c <= 0x01dc) ||
  111.           c == 0x023c || c == 0x0242)
  112.         {
  113.           if (!(c & 0x01))
  114.             return (c - 1);
  115.           return c;
  116.         }
  117.      
  118.       if (c == 0x0131)
  119.         return 0x0049;
  120.      
  121.       if (c == 0x017a || c == 0x017c || c == 0x017e)
  122.         return (c - 1);
  123.      
  124.       if (c >= 0x017f && c <= 0x0292)
  125.         {
  126.           wint_t k;
  127.           switch (c)
  128.             {
  129.             case 0x017f:
  130.               k = 0x0053;
  131.               break;
  132.             case 0x0180:
  133.               k = 0x0243;
  134.               break;
  135.             case 0x0183:
  136.               k = 0x0182;
  137.               break;
  138.             case 0x0185:
  139.               k = 0x0184;
  140.               break;
  141.             case 0x0188:
  142.               k = 0x0187;
  143.               break;
  144.             case 0x018c:
  145.               k = 0x018b;
  146.               break;
  147.             case 0x0192:
  148.               k = 0x0191;
  149.               break;
  150.             case 0x0195:
  151.               k = 0x01f6;
  152.               break;
  153.             case 0x0199:
  154.               k = 0x0198;
  155.               break;
  156.             case 0x019a:
  157.               k = 0x023d;
  158.               break;
  159.             case 0x019e:
  160.               k = 0x0220;
  161.               break;
  162.             case 0x01a1:
  163.             case 0x01a3:
  164.             case 0x01a5:
  165.             case 0x01a8:
  166.             case 0x01ad:
  167.             case 0x01b0:
  168.             case 0x01b4:
  169.             case 0x01b6:
  170.             case 0x01b9:
  171.             case 0x01bd:
  172.             case 0x01c5:
  173.             case 0x01c8:
  174.             case 0x01cb:
  175.             case 0x01f2:
  176.             case 0x01f5:
  177.               k = c - 1;
  178.               break;
  179.             case 0x01bf:
  180.               k = 0x01f7;
  181.               break;
  182.             case 0x01c6:
  183.             case 0x01c9:
  184.             case 0x01cc:
  185.               k = c - 2;
  186.               break;
  187.             case 0x01dd:
  188.               k = 0x018e;
  189.               break;
  190.             case 0x01f3:
  191.               k = 0x01f1;
  192.               break;
  193.             case 0x023f:
  194.               k = 0x2c7e;
  195.               break;
  196.             case 0x0240:
  197.               k = 0x2c7f;
  198.               break;
  199.             case 0x0250:
  200.               k = 0x2c6f;
  201.               break;
  202.             case 0x0251:
  203.               k = 0x2c6d;
  204.               break;
  205.             case 0x0252:
  206.               k = 0x2c70;
  207.               break;
  208.             case 0x0253:
  209.               k = 0x0181;
  210.               break;
  211.             case 0x0254:
  212.               k = 0x0186;
  213.               break;
  214.             case 0x0256:
  215.               k = 0x0189;
  216.               break;
  217.             case 0x0257:
  218.               k = 0x018a;
  219.               break;
  220.             case 0x0259:
  221.               k = 0x018f;
  222.               break;
  223.             case 0x025b:
  224.               k = 0x0190;
  225.               break;
  226.             case 0x0260:
  227.               k = 0x0193;
  228.               break;
  229.             case 0x0263:
  230.               k = 0x0194;
  231.               break;
  232.             case 0x0268:
  233.               k = 0x0197;
  234.               break;
  235.             case 0x0269:
  236.               k = 0x0196;
  237.               break;
  238.             case 0x026b:
  239.               k = 0x2c62;
  240.               break;
  241.             case 0x026f:
  242.               k = 0x019c;
  243.               break;
  244.             case 0x0271:
  245.               k = 0x2c6e;
  246.               break;
  247.             case 0x0272:
  248.               k = 0x019d;
  249.               break;
  250.             case 0x0275:
  251.               k = 0x019f;
  252.               break;
  253.             case 0x027d:
  254.               k = 0x2c64;
  255.               break;
  256.             case 0x0280:
  257.               k = 0x01a6;
  258.               break;
  259.             case 0x0283:
  260.               k = 0x01a9;
  261.               break;
  262.             case 0x0288:
  263.               k = 0x01ae;
  264.               break;
  265.             case 0x0289:
  266.               k = 0x0244;
  267.               break;
  268.             case 0x028a:
  269.               k = 0x01b1;
  270.               break;
  271.             case 0x028b:
  272.               k = 0x01b2;
  273.               break;
  274.             case 0x028c:
  275.               k = 0x0245;
  276.               break;
  277.             case 0x0292:
  278.               k = 0x01b7;
  279.               break;
  280.             default:
  281.               k = 0;
  282.             }
  283.           if (k != 0)
  284.             return k;
  285.         }
  286.     }
  287.   else if (c < 0x0400)
  288.     {
  289.       wint_t k;
  290.  
  291.       if (c >= 0x03ad && c <= 0x03af)
  292.         return (c - 0x25);
  293.  
  294.       if (c >= 0x03b1 && c <= 0x03cb && c != 0x03c2)
  295.         return (c - 0x20);
  296.      
  297.       if (c >= 0x03d9 && c <= 0x03ef && (c & 1))
  298.         return (c - 1);
  299.  
  300.       switch (c)
  301.         {
  302.         case 0x0345:
  303.           k = 0x0399;
  304.           break;
  305.         case 0x0371:
  306.         case 0x0373:
  307.         case 0x0377:
  308.         case 0x03f8:
  309.         case 0x03fb:
  310.           k = c - 1;
  311.           break;
  312.         case 0x037b:
  313.         case 0x037c:
  314.         case 0x037d:
  315.           k = c + 0x82;
  316.           break;
  317.         case 0x03ac:
  318.           k = 0x0386;
  319.           break;
  320.         case 0x03c2:
  321.           k = 0x03a3;
  322.           break;
  323.         case 0x03cc:
  324.           k = 0x038c;
  325.           break;
  326.         case 0x03cd:
  327.         case 0x03ce:
  328.           k = c - 0x3f;
  329.           break;
  330.         case 0x03d0:
  331.           k = 0x0392;
  332.           break;
  333.         case 0x03d1:
  334.           k = 0x0398;
  335.           break;
  336.         case 0x03d5:
  337.           k = 0x03a6;
  338.           break;
  339.         case 0x03d6:
  340.           k = 0x03a0;
  341.           break;
  342.         case 0x03d7:
  343.           k = 0x03cf;
  344.           break;
  345.         case 0x03f0:
  346.           k = 0x039a;
  347.           break;
  348.         case 0x03f1:
  349.           k = 0x03a1;
  350.           break;
  351.         case 0x03f2:
  352.           k = 0x03f9;
  353.           break;
  354.         case 0x03f5:
  355.           k = 0x0395;
  356.           break;
  357.         default:
  358.           k = 0;
  359.         }
  360.       if (k != 0)
  361.         return k;
  362.     }
  363.   else if (c < 0x500)
  364.     {
  365.       if (c >= 0x0430 && c <= 0x044f)
  366.         return (c - 0x20);
  367.      
  368.       if (c >= 0x0450 && c <= 0x045f)
  369.         return (c - 0x50);
  370.      
  371.       if ((c >= 0x0461 && c <= 0x0481) ||
  372.           (c >= 0x048b && c <= 0x04bf) ||
  373.           (c >= 0x04d1 && c <= 0x04ff))
  374.         {
  375.           if (c & 0x01)
  376.             return (c - 1);
  377.           return c;
  378.         }
  379.      
  380.       if (c >= 0x04c2 && c <= 0x04ce)
  381.         {
  382.           if (!(c & 0x01))
  383.             return (c - 1);
  384.           return c;
  385.         }
  386.      
  387.       if (c == 0x04cf)
  388.         return 0x04c0;
  389.  
  390.       if (c >= 0x04f7 && c <= 0x04f9)
  391.         return (c - 1);
  392.     }
  393.   else if (c < 0x0600)
  394.     {
  395.       if (c >= 0x0501 && c <= 0x0525 && (c & 1))
  396.         return c - 1;
  397.  
  398.       if (c >= 0x0561 && c <= 0x0586)
  399.         return (c - 0x30);
  400.     }
  401.   else if (c < 0x1f00)
  402.     {
  403.       if (c == 0x1d79)
  404.         return 0xa77d;
  405.  
  406.       if (c == 0x1d7d)
  407.         return 0x2c63;
  408.  
  409.       if ((c >= 0x1e01 && c <= 0x1e95) ||
  410.           (c >= 0x1ea1 && c <= 0x1eff))
  411.         {
  412.           if (c & 0x01)
  413.             return (c - 1);
  414.           return c;
  415.         }
  416.      
  417.       if (c == 0x1e9b)
  418.         return 0x1e60;
  419.     }
  420.   else if (c < 0x2000)
  421.     {
  422.      
  423.       if ((c >= 0x1f00 && c <= 0x1f07) ||
  424.           (c >= 0x1f10 && c <= 0x1f15) ||
  425.           (c >= 0x1f20 && c <= 0x1f27) ||
  426.           (c >= 0x1f30 && c <= 0x1f37) ||
  427.           (c >= 0x1f40 && c <= 0x1f45) ||
  428.           (c >= 0x1f60 && c <= 0x1f67) ||
  429.           (c >= 0x1f80 && c <= 0x1f87) ||
  430.           (c >= 0x1f90 && c <= 0x1f97) ||
  431.           (c >= 0x1fa0 && c <= 0x1fa7))
  432.         return (c + 0x08);
  433.  
  434.       if (c >= 0x1f51 && c <= 0x1f57 && (c & 0x01))
  435.         return (c + 0x08);
  436.      
  437.       if (c >= 0x1f70 && c <= 0x1ff3)
  438.         {
  439.           wint_t k;
  440.           switch (c)
  441.             {
  442.             case 0x1fb0:
  443.               k = 0x1fb8;
  444.               break;
  445.             case 0x1fb1:
  446.               k = 0x1fb9;
  447.               break;
  448.             case 0x1f70:
  449.               k = 0x1fba;
  450.               break;
  451.             case 0x1f71:
  452.               k = 0x1fbb;
  453.               break;
  454.             case 0x1fb3:
  455.               k = 0x1fbc;
  456.               break;
  457.             case 0x1fbe:
  458.               k = 0x0399;
  459.               break;
  460.             case 0x1f72:
  461.               k = 0x1fc8;
  462.               break;
  463.             case 0x1f73:
  464.               k = 0x1fc9;
  465.               break;
  466.             case 0x1f74:
  467.               k = 0x1fca;
  468.               break;
  469.             case 0x1f75:
  470.               k = 0x1fcb;
  471.               break;
  472.             case 0x1fc3:
  473.               k = 0x1fcc;
  474.               break;
  475.             case 0x1fd0:
  476.               k = 0x1fd8;
  477.               break;
  478.             case 0x1fd1:
  479.               k = 0x1fd9;
  480.               break;
  481.             case 0x1f76:
  482.               k = 0x1fda;
  483.               break;
  484.             case 0x1f77:
  485.               k = 0x1fdb;
  486.               break;
  487.             case 0x1fe0:
  488.               k = 0x1fe8;
  489.               break;
  490.             case 0x1fe1:
  491.               k = 0x1fe9;
  492.               break;
  493.             case 0x1f7a:
  494.               k = 0x1fea;
  495.               break;
  496.             case 0x1f7b:
  497.               k = 0x1feb;
  498.               break;
  499.             case 0x1fe5:
  500.               k = 0x1fec;
  501.               break;
  502.             case 0x1f78:
  503.               k = 0x1ff8;
  504.               break;
  505.             case 0x1f79:
  506.               k = 0x1ff9;
  507.               break;
  508.             case 0x1f7c:
  509.               k = 0x1ffa;
  510.               break;
  511.             case 0x1f7d:
  512.               k = 0x1ffb;
  513.               break;
  514.             case 0x1ff3:
  515.               k = 0x1ffc;
  516.               break;
  517.             default:
  518.               k = 0;
  519.             }
  520.           if (k != 0)
  521.             return k;
  522.         }
  523.     }
  524.   else if (c < 0x3000)
  525.     {
  526.       if (c == 0x214e)
  527.         return 0x2132;
  528.  
  529.       if (c == 0x2184)
  530.         return 0x2183;
  531.  
  532.       if (c >= 0x2170 && c <= 0x217f)
  533.         return (c - 0x10);
  534.      
  535.       if (c >= 0x24d0 && c <= 0x24e9)
  536.         return (c - 0x1a);
  537.      
  538.       if (c >= 0x2c30 && c <= 0x2c5e)
  539.         return (c - 0x30);
  540.  
  541.       if ((c >= 0x2c68 && c <= 0x2c6c && !(c & 1)) ||
  542.           (c >= 0x2c81 && c <= 0x2ce3 &&  (c & 1)) ||
  543.           c == 0x2c73 || c == 0x2c76 ||
  544.           c == 0x2cec || c == 0x2cee)
  545.         return (c - 1);
  546.  
  547.       if (c >= 0x2c81 && c <= 0x2ce3 && (c & 1))
  548.         return (c - 1);
  549.  
  550.       if (c >= 0x2d00 && c <= 0x2d25)
  551.         return (c - 0x1c60);
  552.  
  553.       switch (c)
  554.         {
  555.         case 0x2c61:
  556.           return 0x2c60;
  557.         case 0x2c65:
  558.           return 0x023a;
  559.         case 0x2c66:
  560.           return 0x023e;
  561.         }
  562.     }
  563.   else if (c >= 0xa000 && c < 0xb000)
  564.     {
  565.       if (((c >= 0xa641 && c <= 0xa65f) ||
  566.            (c >= 0xa663 && c <= 0xa66d) ||
  567.            (c >= 0xa681 && c <= 0xa697) ||
  568.            (c >= 0xa723 && c <= 0xa72f) ||
  569.            (c >= 0xa733 && c <= 0xa76f) ||
  570.            (c >= 0xa77f && c <= 0xa787)) &&
  571.           (c & 1))
  572.         return (c - 1);
  573.        
  574.       if (c == 0xa77a || c == 0xa77c || c == 0xa78c)
  575.         return (c - 1);
  576.     }
  577.   else
  578.     {
  579.       if (c >= 0xff41 && c <= 0xff5a)
  580.         return (c - 0x20);
  581.      
  582.       if (c >= 0x10428 && c <= 0x1044f)
  583.         return (c - 0x28);
  584.     }
  585.   return c;
  586. #else
  587.   return (c < 0x00ff ? (wint_t)(toupper ((int)c)) : c);
  588. #endif /* _MB_CAPABLE */
  589. }
  590.  
  591.