API tools faq
paste
Guest User

Untitled

a guest
May 13th, 2019
58
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 17.23 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <locale.h>
  4. unsigned char *StrToLwrExt(unsigned char *pString);
  5. void input(char* buffer) {
  6.     fscanf(stdin, "%[^\n]%*c", buffer);
  7.     StrToLwrExt((unsigned char *)buffer);
  8. }
  9. int equals(char* str1, char* str2) { return !strcmp(str1, str2); }
  10. int main(int argc, char** argv) {
  11.     setlocale(LC_ALL, "ru_RU.UTF8");
  12.     char str[1024];
  13.     while(1) {
  14.         printf(">"); input(str);
  15.         if (
  16.              equals(str, "выйти из игры") ||
  17.              equals(str, "выход") ||
  18.              equals(str, "выход из игры") ||
  19.              equals(str, "покинуть игру") ||
  20.              equals(str, "конец игры") ||
  21.              equals(str, "стоп игра") ||
  22.              equals(str, "стоп") ||
  23.              equals(str, "остановить игру") ||
  24.              equals(str, "остановка игры")
  25.             ) {
  26.             printf("Вы правда хотите остановить игру?\n");
  27.             printf(">"); input(str);
  28.             if (equals(str, "да") || equals(str, "правда")) {
  29.                 printf("Хорошо, игра остановлена.\n");
  30.                 return 0;
  31.             } else {
  32.                 printf("Нет? Продолжаем игру.\n");
  33.             }
  34.         } else {
  35.             static int cant_understand = 0;
  36.             if (cant_understand == 0) {
  37.                 printf("Непонятно.\n");
  38.             } else if (cant_understand == 1) {
  39.                 printf("Перефразируйте.\n");
  40.             } else if (cant_understand == 2) {
  41.                 printf("Попробуйте сказать по-другому.\n");
  42.             } else if (cant_understand == 3) {
  43.                 printf("Сложно это понять.\n");
  44.             } else if (cant_understand == 4) {
  45.                 printf("Неясно.\n");
  46.             }
  47.             cant_understand += 1;
  48.             if (cant_understand > 4) cant_understand = 0;
  49.         }
  50.     }
  51.     return 0;
  52. }
  53. /////////////////////////////////////////////////////////////////////////////
  54. unsigned char *StrToLwrExt(unsigned char *pString) {
  55.     if (pString && *pString) {
  56.         unsigned char *p = pString;
  57.         unsigned char *pExtChar = 0;
  58.         while (*p) {
  59.             if ((*p >= 0x41) && (*p <= 0x5a)) // US ASCII
  60.                 (*p) += 0x20;
  61.             else if (*p > 0xc0) {
  62.                 pExtChar = p;
  63.                 p++;
  64.                 switch (*pExtChar) {
  65.                 case 0xc3: // Latin 1
  66.                     if ((*p >= 0x80)
  67.                         && (*p <= 0x9e)
  68.                         && (*p != 0x97))
  69.                         (*p) += 0x20; // US ASCII shift
  70.                     break;
  71.                 case 0xc4: // Latin Exteneded
  72.                     if ((*p >= 0x80)
  73.                         && (*p <= 0xb7)
  74.                         && (!(*p % 2))) // Even
  75.                         (*p)++; // Next char is lwr
  76.                     else if ((*p >= 0xb9)
  77.                         && (*p <= 0xbe)
  78.                         && (*p % 2)) // Odd
  79.                         (*p)++; // Next char is lwr
  80.                     else if (*p == 0xbf) {
  81.                         *pExtChar = 0xc5;
  82.                         (*p) = 0x80;
  83.                     }
  84.                     break;
  85.                 case 0xc5: // Latin Exteneded
  86.                     if ((*p >= 0x80)
  87.                         && (*p <= 0x88)
  88.                         && (*p % 2)) // Odd
  89.                         (*p)++; // Next char is lwr
  90.                     else if ((*p >= 0x8a)
  91.                         && (*p <= 0xb7)
  92.                         && (!(*p % 2))) // Even
  93.                         (*p)++; // Next char is lwr
  94.                     else if ((*p >= 0xb9)
  95.                         && (*p <= 0xbe)
  96.                         && (*p % 2)) // Odd
  97.                         (*p)++; // Next char is lwr
  98.                     break;
  99.                 case 0xc6: // Latin Exteneded
  100.                     switch (*p) {
  101.                     case 0x82:
  102.                     case 0x84:
  103.                     case 0x87:
  104.                     case 0x8b:
  105.                     case 0x91:
  106.                     case 0x98:
  107.                     case 0xa0:
  108.                     case 0xa2:
  109.                     case 0xa4:
  110.                     case 0xa7:
  111.                     case 0xac:
  112.                     case 0xaf:
  113.                     case 0xb3:
  114.                     case 0xb5:
  115.                     case 0xb8:
  116.                     case 0xbc:
  117.                         (*p)++; // Next char is lwr
  118.                         break;
  119.                     default:
  120.                         break;
  121.                     }
  122.                 case 0xc7: // Latin Exteneded
  123.                     if (*p == 0x84)
  124.                         (*p) = 0x86;
  125.                     else if (*p == 0x85)
  126.                         (*p)++; // Next char is lwr
  127.                     else if (*p == 0x87)
  128.                         (*p) = 0x89;
  129.                     else if (*p == 0x88)
  130.                         (*p)++; // Next char is lwr
  131.                     else if (*p == 0x8a)
  132.                         (*p) = 0x8c;
  133.                     else if (*p == 0x8b)
  134.                         (*p)++; // Next char is lwr
  135.                     else if ((*p >= 0x8d)
  136.                         && (*p <= 0x9c)
  137.                         && (*p % 2)) // Odd
  138.                         (*p)++; // Next char is lwr
  139.                     else if ((*p >= 0x9e)
  140.                         && (*p <= 0xaf)
  141.                         && (!(*p % 2))) // Even
  142.                         (*p)++; // Next char is lwr
  143.                     else if (*p == 0xb1)
  144.                         (*p) = 0xb3;
  145.                     else if (*p == 0xb2)
  146.                         (*p)++; // Next char is lwr
  147.                     else if (*p == 0xb4)
  148.                         (*p)++; // Next char is lwr
  149.                     else if (*p == 0xb8)
  150.                         (*p)++; // Next char is lwr
  151.                     else if (*p == 0xba)
  152.                         (*p)++; // Next char is lwr
  153.                     else if (*p == 0xbc)
  154.                         (*p)++; // Next char is lwr
  155.                     else if (*p == 0xbe)
  156.                         (*p)++; // Next char is lwr
  157.                     break;
  158.                 case 0xc8: // Latin Exteneded
  159.                     if ((*p >= 0x80)
  160.                         && (*p <= 0x9f)
  161.                         && (!(*p % 2))) // Even
  162.                         (*p)++; // Next char is lwr
  163.                     else if ((*p >= 0xa2)
  164.                         && (*p <= 0xb3)
  165.                         && (!(*p % 2))) // Even
  166.                         (*p)++; // Next char is lwr
  167.                     else if (*p == 0xbb)
  168.                         (*p)++; // Next char is lwr
  169.                     break;
  170.                 case 0xcd: // Greek & Coptic
  171.                     switch (*p) {
  172.                     case 0xb0:
  173.                     case 0xb2:
  174.                     case 0xb6:
  175.                         (*p)++; // Next char is lwr
  176.                         break;
  177.                     default:
  178.                         if (*p == 0xbf) {
  179.                             *pExtChar = 0xcf;
  180.                             (*p) = 0xb3;
  181.                         }
  182.                         break;
  183.                     }
  184.                 case 0xce: // Greek & Coptic
  185.                     if (*p == 0x86)
  186.                         (*p) = 0xac;
  187.                     else if (*p == 0x88)
  188.                         (*p) = 0xad;
  189.                     else if (*p == 0x89)
  190.                         (*p) = 0xae;
  191.                     else if (*p == 0x8a)
  192.                         (*p) = 0xaf;
  193.                     else if (*p == 0x8c) {
  194.                         *pExtChar = 0xcf;
  195.                         (*p) = 0x8c;
  196.                     }
  197.                     else if (*p == 0x8e) {
  198.                         *pExtChar = 0xcf;
  199.                         (*p) = 0x8d;
  200.                     }
  201.                     else if (*p == 0x8f) {
  202.                         *pExtChar = 0xcf;
  203.                         (*p) = 0x8e;
  204.                     }
  205.                     else if ((*p >= 0x91)
  206.                         && (*p <= 0x9f))
  207.                         (*p) += 0x20; // US ASCII shift
  208.                     else if ((*p >= 0xa0)
  209.                         && (*p <= 0xab)
  210.                         && (*p != 0xa2)) {
  211.                         *pExtChar = 0xcf;
  212.                         (*p) -= 0x20;
  213.                     }
  214.                     break;
  215.                 case 0xcf: // Greek & Coptic
  216.                     if (*p == 0x8f)
  217.                         (*p) = 0xb4;
  218.                     else if (*p == 0x91)
  219.                         (*p)++; // Next char is lwr
  220.                     else if ((*p >= 0x98)
  221.                         && (*p <= 0xaf)
  222.                         && (!(*p % 2))) // Even
  223.                         (*p)++; // Next char is lwr
  224.                     else if (*p == 0xb4)
  225.                         (*p) = 0x91;
  226.                     else if (*p == 0xb7)
  227.                         (*p)++; // Next char is lwr
  228.                     else if (*p == 0xb9)
  229.                         (*p) = 0xb2;
  230.                     else if (*p == 0xbb)
  231.                         (*p)++; // Next char is lwr
  232.                     else if (*p == 0xbd) {
  233.                         *pExtChar = 0xcd;
  234.                         (*p) = 0xbb;
  235.                     }
  236.                     else if (*p == 0xbe) {
  237.                         *pExtChar = 0xcd;
  238.                         (*p) = 0xbc;
  239.                     }
  240.                     else if (*p == 0xbf) {
  241.                         *pExtChar = 0xcd;
  242.                         (*p) = 0xbd;
  243.                     }
  244.  
  245.                     break;
  246.                 case 0xd0: // Cyrillic
  247.                     if ((*p >= 0x80)
  248.                         && (*p <= 0x8f)) {
  249.                         *pExtChar = 0xd1;
  250.                         (*p) += 0x10;
  251.                     }
  252.                     else if ((*p >= 0x90)
  253.                         && (*p <= 0x9f))
  254.                         (*p) += 0x20; // US ASCII shift
  255.                     else if ((*p >= 0xa0)
  256.                         && (*p <= 0xaf)) {
  257.                         *pExtChar = 0xd1;
  258.                         (*p) -= 0x20;
  259.                     }
  260.                     break;
  261.                 case 0xd1: // Cyrillic supplement
  262.                     if ((*p >= 0xa0)
  263.                         && (*p <= 0xbf)
  264.                         && (!(*p % 2))) // Even
  265.                         (*p)++; // Next char is lwr
  266.                     break;
  267.                 case 0xd2: // Cyrillic supplement
  268.                     if (*p == 0x80)
  269.                         (*p)++; // Next char is lwr
  270.                     else if ((*p >= 0x8a)
  271.                         && (*p <= 0xbf)
  272.                         && (!(*p % 2))) // Even
  273.                         (*p)++; // Next char is lwr
  274.                     break;
  275.                 case 0xd3: // Cyrillic supplement
  276.                     if ((*p >= 0x81)
  277.                         && (*p <= 0x8e)
  278.                         && (*p % 2)) // Odd
  279.                         (*p)++; // Next char is lwr
  280.                     else if ((*p >= 0x90)
  281.                         && (*p <= 0xbf)
  282.                         && (!(*p % 2))) // Even
  283.                         (*p)++; // Next char is lwr
  284.                     break;
  285.                 case 0xd4: // Cyrillic supplement & Armenian
  286.                     if ((*p >= 0x80)
  287.                         && (*p <= 0xaf)
  288.                         && (!(*p % 2))) // Even
  289.                         (*p)++; // Next char is lwr
  290.                     else if ((*p >= 0xb1)
  291.                         && (*p <= 0xbf)) {
  292.                         *pExtChar = 0xd5;
  293.                         (*p) -= 0x10;
  294.                     }
  295.                     break;
  296.                 case 0xd5: // Armenian
  297.                     if ((*p >= 0x80)
  298.                         && (*p <= 0x96)
  299.                         && (!(*p % 2))) // Even
  300.                         (*p)++; // Next char is lwr
  301.                     break;
  302.                 case 0xe1: // Three byte code
  303.                     pExtChar = p;
  304.                     p++;
  305.                     switch (*pExtChar) {
  306.                     case 0x82: // Georgian
  307.                         if ((*p >= 0xa0)
  308.                             && (*p <= 0xbf)) {
  309.                             *pExtChar = 0x83;
  310.                             (*p) -= 0x10;
  311.                         }
  312.                         break;
  313.                     case 0x83: // Georgian
  314.                         if (((*p >= 0x80)
  315.                             && ((*p <= 0x85)
  316.                                 || (*p == 0x87)))
  317.                             || (*p == 0x8d))
  318.                             (*p) += 0x30;
  319.                         break;
  320.                     case 0xb8: // Latin extened
  321.                         if ((*p >= 0x80)
  322.                             && (*p <= 0xbf)
  323.                             && (!(*p % 2))) // Even
  324.                             (*p)++; // Next char is lwr
  325.                         break;
  326.                     case 0xb9: // Latin extened
  327.                         if ((*p >= 0x80)
  328.                             && (*p <= 0xbf)
  329.                             && (!(*p % 2))) // Even
  330.                             (*p)++; // Next char is lwr
  331.                         break;
  332.                     case 0xba: // Latin extened
  333.                         if ((*p >= 0x80)
  334.                             && (*p <= 0x94)
  335.                             && (!(*p % 2))) // Even
  336.                             (*p)++; // Next char is lwr
  337.                         else if ((*p >= 0x9e)
  338.                             && (*p <= 0xbf)
  339.                             && (!(*p % 2))) // Even
  340.                             (*p)++; // Next char is lwr
  341.                         break;
  342.                     case 0xbb: // Latin extened
  343.                         if ((*p >= 0x80)
  344.                             && (*p <= 0xbf)
  345.                             && (!(*p % 2))) // Even
  346.                             (*p)++; // Next char is lwr
  347.                         break;
  348.                     case 0xbc: // Greek extened
  349.                         if ((*p >= 0x88)
  350.                             && (*p <= 0x8f))
  351.                             (*p) -= 0x08;
  352.                         else if ((*p >= 0x98)
  353.                             && (*p <= 0x9f))
  354.                             (*p) -= 0x08;
  355.                         else if ((*p >= 0xa8)
  356.                             && (*p <= 0xaf))
  357.                             (*p) -= 0x08;
  358.                         else if ((*p >= 0xb8)
  359.                             && (*p <= 0x8f))
  360.                             (*p) -= 0x08;
  361.                         break;
  362.                     case 0xbd: // Greek extened
  363.                         if ((*p >= 0x88)
  364.                             && (*p <= 0x8d))
  365.                             (*p) -= 0x08;
  366.                         else if ((*p >= 0x98)
  367.                             && (*p <= 0x9f))
  368.                             (*p) -= 0x08;
  369.                         else if ((*p >= 0xa8)
  370.                             && (*p <= 0xaf))
  371.                             (*p) -= 0x08;
  372.                         else if ((*p >= 0xb8)
  373.                             && (*p <= 0x8f))
  374.                             (*p) -= 0x08;
  375.                         break;
  376.                     case 0xbe: // Greek extened
  377.                         if ((*p >= 0x88)
  378.                             && (*p <= 0x8f))
  379.                             (*p) -= 0x08;
  380.                         else if ((*p >= 0x98)
  381.                             && (*p <= 0x9f))
  382.                             (*p) -= 0x08;
  383.                         else if ((*p >= 0xa8)
  384.                             && (*p <= 0xaf))
  385.                             (*p) -= 0x08;
  386.                         else if ((*p >= 0xb8)
  387.                             && (*p <= 0xb9))
  388.                             (*p) -= 0x08;
  389.                         break;
  390.                     case 0xbf: // Greek extened
  391.                         if ((*p >= 0x88)
  392.                             && (*p <= 0x8c))
  393.                             (*p) -= 0x08;
  394.                         else if ((*p >= 0x98)
  395.                             && (*p <= 0x9b))
  396.                             (*p) -= 0x08;
  397.                         else if ((*p >= 0xa8)
  398.                             && (*p <= 0xac))
  399.                             (*p) -= 0x08;
  400.                         break;
  401.                     default:
  402.                         break;
  403.                     }
  404.                     break;
  405.                 case 0xf0: // Four byte code
  406.                     pExtChar = p;
  407.                     p++;
  408.                     switch (*pExtChar) {
  409.                     case 0x90:
  410.                         pExtChar = p;
  411.                         p++;
  412.                         switch (*pExtChar) {
  413.                         case 0x92: // Osage
  414.                             if ((*p >= 0xb0)
  415.                                 && (*p <= 0xbf)) {
  416.                                 *pExtChar = 0x93;
  417.                                 (*p) -= 0x18;
  418.                             }
  419.                             break;
  420.                         case 0x93: // Osage
  421.                             if ((*p >= 0x80)
  422.                                 && (*p <= 0x93))
  423.                                 (*p) += 0x18;
  424.                             break;
  425.                         default:
  426.                             break;
  427.                         }
  428.                         break;
  429.                     default:
  430.                         break;
  431.                     }
  432.                     break;
  433.                 default:
  434.                     break;
  435.                 }
  436.                 pExtChar = 0;
  437.             }
  438.             p++;
  439.         }
  440.     }
  441.     return pString;
  442. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!