home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 8 Other / 08-Other.zip / rxjis096.zip / pctojis.cpp < prev    next >
C/C++ Source or Header  |  1998-05-26  |  10KB  |  436 lines
  1. /* product name: RXJIS                                                */
  2. /* Version:      0.94                                                 */
  3. /* author:       YANO Takashi                                         */
  4. /* target:       OS/2 Warp J3.0+ (J2.1 is possible)                   */
  5. /* source name:  PCTOJIS.CPP                                          */
  6. /* address:      tyano@ca2.so-net.or.jp or tyano@yamato.ibm.co.jp     */
  7. /* comment:      RXJIS is a utility functions for REXX.               */
  8. /*               This header file is a interface to be called from    */
  9. /*               C/C++.                                               */
  10. /* history: 1997-08-05 0.90                                           */
  11. /*          1998-05-26 0.94                                           */
  12. /*                                                                    */
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <limits.h>
  16. #include <string.h>
  17. #include <os2.h>
  18. #include "ibm2jis.hpp"
  19. #include "pc2jis.hpp"
  20. #include "pctojis.hpp"
  21.  
  22. BOOL _Export InJis90 = FALSE;
  23. BOOL _Export DbcsVec[UCHAR_MAX+1];
  24.  
  25. wchar_t _Export 
  26. OldJisToNewJis(
  27. wchar_t pccode) {
  28.    switch (pccode) {
  29.    case 0xe9cb: /* Θ╦ */
  30.       pccode = 0x88b1;
  31.       break;
  32.    case 0x88b1: /* ê▒ */
  33.       pccode = 0xe9cb;
  34.       break;
  35.    case 0xe9f2: /* Θ≥ */
  36.       pccode = 0x89a7;
  37.       break;
  38.    case 0x89a7: /* ëº */
  39.       pccode = 0xe9f2;
  40.       break;
  41.    case 0xe579: /* σy */
  42.       pccode = 0x8a61;
  43.       break;
  44.    case 0x8a61: /* èa */
  45.       pccode = 0xe579;
  46.       break;
  47.    case 0x9d98: /* ¥ÿ */
  48.       pccode = 0x8a68;
  49.       break;
  50.    case 0x8a68: /* èh */
  51.       pccode = 0x9d98;
  52.       break;
  53.    case 0xe27d: /* Γ} */
  54.       pccode = 0x8a96;
  55.       break;
  56.    case 0x8a96: /* èû */
  57.       pccode = 0xe27d;
  58.       break;
  59.    case 0x9ff3: /* ƒ≤ */
  60.       pccode = 0x8ac1;
  61.       break;
  62.    case 0x8ac1: /* è┴ */
  63.       pccode = 0x9ff3;
  64.       break;
  65.    case 0xe67c: /* µ| */
  66.       pccode = 0x8ad0;
  67.       break;
  68.    case 0x8ad0: /* è╨ */
  69.       pccode = 0xe67c;
  70.       break;
  71.    case 0xe8f2: /* Φ≥ */
  72.       pccode = 0x8c7a;
  73.       break;
  74.    case 0x8c7a: /* îz */
  75.       pccode = 0xe8f2;
  76.       break;
  77.    case 0xe1e6: /* ßµ */
  78.       pccode = 0x8d7b;
  79.       break;
  80.    case 0x8d7b: /* ì{ */
  81.       pccode = 0xe1e6;
  82.       break;
  83.    case 0xe541: /* σA */
  84.       pccode = 0x8ec7;
  85.       break;
  86.    case 0x8ec7: /* Ä╟ */
  87.       pccode = 0xe541;
  88.       break;
  89.    case 0xe8d5: /* Φ╒ */
  90.       pccode = 0x9078;
  91.       break;
  92.    case 0x9078: /* Éx */
  93.       pccode = 0xe8d5;
  94.       break;
  95.    case 0xe6cb: /* µ╦ */
  96.       pccode = 0x9147;
  97.       break;
  98.    case 0x9147: /* æG */
  99.       pccode = 0xe6cb;
  100.       break;
  101.    case 0x9ae2: /* ÜΓ */
  102.       pccode = 0x92d9;
  103.       break;
  104.    case 0x92d9: /* Æ┘ */
  105.       pccode = 0x9ae2;
  106.       break;
  107.    case 0xe1e8: /* ßΦ */
  108.       pccode = 0x9376;
  109.       break;
  110.    case 0x9376: /* ôv */
  111.       pccode = 0xe1e8;
  112.       break;
  113.    case 0x9e8d: /* ₧ì */
  114.       pccode = 0x938e;
  115.       break;
  116.    case 0x938e: /* ôÄ */
  117.       pccode = 0x9e8d;
  118.       break;
  119.    case 0x9fb7: /* ƒ╖ */
  120.       pccode = 0x9393;
  121.       break;
  122.    case 0x9393: /* ôô */
  123.       pccode = 0x9fb7;
  124.       break;
  125.    case 0xe78e: /* τÄ */
  126.       pccode = 0x93f4;
  127.       break;
  128.    case 0x93f4: /* ô⌠ */
  129.       pccode = 0xe78e;
  130.       break;
  131.    case 0xe5a2: /* σó */
  132.       pccode = 0x9488;
  133.       break;
  134.    case 0x9488: /* öê */
  135.       pccode = 0xe5a2;
  136.       break;
  137.    case 0x9e77: /* ₧w */
  138.       pccode = 0x954f;
  139.       break;
  140.    case 0x954f: /* òO */
  141.       pccode = 0x9e77;
  142.       break;
  143.    case 0x98d4: /* ÿ╘ */
  144.       pccode = 0x9699;
  145.       break;
  146.    case 0x9699: /* ûÖ */
  147.       pccode = 0x98d4;
  148.       break;
  149.    case 0xe54d: /* σM */
  150.       pccode = 0x96f7;
  151.       break;
  152.    case 0x96f7: /* û≈ */
  153.       pccode = 0xe54d;
  154.       break;
  155.    case 0xe2c4: /* Γ─ */
  156.       pccode = 0x9855;
  157.       break;
  158.    case 0x9855: /* ÿU */
  159.       pccode = 0xe2c4;
  160.       break;
  161.    case 0xea9f: /* Ωƒ */
  162.       pccode = 0x8bc4;
  163.       break;
  164.    case 0x8bc4: /* ï─ */
  165.       pccode = 0xea9f;
  166.       break;
  167.    case 0xeaa0: /* Ωá */
  168.       pccode = 0x968a;
  169.       break;
  170.    case 0x968a: /* ûè */
  171.       pccode = 0xeaa0;
  172.       break;
  173.    case 0xeaa1: /* Ωí */
  174.       pccode = 0x9779;
  175.       break;
  176.    case 0x9779: /* ùy */
  177.       pccode = 0xeaa1;
  178.       break;
  179.    case 0xeaa2: /* Ωó */
  180.       pccode = 0xe0f4;
  181.       break;
  182.    case 0xe0f4: /* α⌠ */
  183.       pccode = 0xeaa2;
  184.       break;
  185.    case 0xfa5b: /* ·[ */
  186.       pccode = 0x81e6;
  187.       break;
  188.    case 0xfa54: /* ·T */
  189.       pccode = 0x81ca;
  190.       break;
  191.    case 0x8d56: /* ìV */
  192.       pccode = 0xfad0;
  193.       break;
  194.    case 0xfad0: /* ·╨ */
  195.       pccode = 0x8d56;
  196.       break;
  197.    } /* endswitch */
  198.    return (pccode);
  199. }
  200.  
  201. wchar_t _Export 
  202. NewJisToOldJis(
  203. wchar_t pccode) {
  204.    switch (pccode) {
  205.    case 0xe9cb: /* Θ╦ */
  206.       pccode = 0x88b1;
  207.       break;
  208.    case 0x88b1: /* ê▒ */
  209.       pccode = 0xe9cb;
  210.       break;
  211.    case 0xe9f2: /* Θ≥ */
  212.       pccode = 0x89a7;
  213.       break;
  214.    case 0x89a7: /* ëº */
  215.       pccode = 0xe9f2;
  216.       break;
  217.    case 0xe579: /* σy */
  218.       pccode = 0x8a61;
  219.       break;
  220.    case 0x8a61: /* èa */
  221.       pccode = 0xe579;
  222.       break;
  223.    case 0x9d98: /* ¥ÿ */
  224.       pccode = 0x8a68;
  225.       break;
  226.    case 0x8a68: /* èh */
  227.       pccode = 0x9d98;
  228.       break;
  229.    case 0xe27d: /* Γ} */
  230.       pccode = 0x8a96;
  231.       break;
  232.    case 0x8a96: /* èû */
  233.       pccode = 0xe27d;
  234.       break;
  235.    case 0x9ff3: /* ƒ≤ */
  236.       pccode = 0x8ac1;
  237.       break;
  238.    case 0x8ac1: /* è┴ */
  239.       pccode = 0x9ff3;
  240.       break;
  241.    case 0xe67c: /* µ| */
  242.       pccode = 0x8ad0;
  243.       break;
  244.    case 0x8ad0: /* è╨ */
  245.       pccode = 0xe67c;
  246.       break;
  247.    case 0xe8f2: /* Φ≥ */
  248.       pccode = 0x8c7a;
  249.       break;
  250.    case 0x8c7a: /* îz */
  251.       pccode = 0xe8f2;
  252.       break;
  253.    case 0xe1e6: /* ßµ */
  254.       pccode = 0x8d7b;
  255.       break;
  256.    case 0x8d7b: /* ì{ */
  257.       pccode = 0xe1e6;
  258.       break;
  259.    case 0xe541: /* σA */
  260.       pccode = 0x8ec7;
  261.       break;
  262.    case 0x8ec7: /* Ä╟ */
  263.       pccode = 0xe541;
  264.       break;
  265.    case 0xe8d5: /* Φ╒ */
  266.       pccode = 0x9078;
  267.       break;
  268.    case 0x9078: /* Éx */
  269.       pccode = 0xe8d5;
  270.       break;
  271.    case 0xe6cb: /* µ╦ */
  272.       pccode = 0x9147;
  273.       break;
  274.    case 0x9147: /* æG */
  275.       pccode = 0xe6cb;
  276.       break;
  277.    case 0x9ae2: /* ÜΓ */
  278.       pccode = 0x92d9;
  279.       break;
  280.    case 0x92d9: /* Æ┘ */
  281.       pccode = 0x9ae2;
  282.       break;
  283.    case 0xe1e8: /* ßΦ */
  284.       pccode = 0x9376;
  285.       break;
  286.    case 0x9376: /* ôv */
  287.       pccode = 0xe1e8;
  288.       break;
  289.    case 0x9e8d: /* ₧ì */
  290.       pccode = 0x938e;
  291.       break;
  292.    case 0x938e: /* ôÄ */
  293.       pccode = 0x9e8d;
  294.       break;
  295.    case 0x9fb7: /* ƒ╖ */
  296.       pccode = 0x9393;
  297.       break;
  298.    case 0x9393: /* ôô */
  299.       pccode = 0x9fb7;
  300.       break;
  301.    case 0xe78e: /* τÄ */
  302.       pccode = 0x93f4;
  303.       break;
  304.    case 0x93f4: /* ô⌠ */
  305.       pccode = 0xe78e;
  306.       break;
  307.    case 0xe5a2: /* σó */
  308.       pccode = 0x9488;
  309.       break;
  310.    case 0x9488: /* öê */
  311.       pccode = 0xe5a2;
  312.       break;
  313.    case 0x9e77: /* ₧w */
  314.       pccode = 0x954f;
  315.       break;
  316.    case 0x954f: /* òO */
  317.       pccode = 0x9e77;
  318.       break;
  319.    case 0x98d4: /* ÿ╘ */
  320.       pccode = 0x9699;
  321.       break;
  322.    case 0x9699: /* ûÖ */
  323.       pccode = 0x98d4;
  324.       break;
  325.    case 0xe54d: /* σM */
  326.       pccode = 0x96f7;
  327.       break;
  328.    case 0x96f7: /* û≈ */
  329.       pccode = 0xe54d;
  330.       break;
  331.    case 0xe2c4: /* Γ─ */
  332.       pccode = 0x9855;
  333.       break;
  334.    case 0x9855: /* ÿU */
  335.       pccode = 0xe2c4;
  336.       break;
  337.    case 0xea9f: /* Ωƒ */
  338.       pccode = 0x8bc4;
  339.       break;
  340.    case 0x8bc4: /* ï─ */
  341.       pccode = 0xea9f;
  342.       break;
  343.    case 0xeaa0: /* Ωá */
  344.       pccode = 0x968a;
  345.       break;
  346.    case 0x968a: /* ûè */
  347.       pccode = 0xeaa0;
  348.       break;
  349.    case 0xeaa1: /* Ωí */
  350.       pccode = 0x9779;
  351.       break;
  352.    case 0x9779: /* ùy */
  353.       pccode = 0xeaa1;
  354.       break;
  355.    case 0xeaa2: /* Ωó */
  356.       pccode = 0xe0f4;
  357.       break;
  358.    case 0xe0f4: /* α⌠ */
  359.       pccode = 0xeaa2;
  360.       break;
  361.    case 0xfa5b: /* ·[ */
  362.       pccode = 0x81e6;
  363.       break;
  364.    case 0xfa54: /* ·T */
  365.       pccode = 0x81ca;
  366.       break;
  367.    case 0x8d56: /* ìV */
  368.       pccode = 0xfad0;
  369.       break;
  370.    case 0xfad0: /* ·╨ */
  371.       pccode = 0x8d56;
  372.       break;
  373.    case 0xe086: /* αå */
  374.       pccode = FillInPc;
  375.       break;
  376.    case 0xeaa3: /* Ωú */
  377.       pccode = FillInPc;
  378.       break;
  379.    } /* endswitch */
  380.    return (pccode);
  381. }
  382.  
  383. int _Export
  384. IbmcodeStringToJiscodeString(
  385. PCHAR ibmstr, 
  386. int ibmstrsize,
  387. PCHAR jisstr,
  388. int jisstrsize) {
  389.    RxJisArgCheck(jisstr, ibmstr, ibmstrsize, jisstrsize)
  390.    int i = 0;
  391.    int j = 0;
  392.    while (i < ibmstrsize) {
  393.       if (!IsDbcs1st(ibmstr[i])) {
  394.          RxJisCountCheck(j + 1, jisstrsize)
  395.          jisstr[j++] = ibmstr[i++];
  396.          continue;
  397.       } /* endif */
  398.       if (i + 1 >= ibmstrsize) {
  399.          break;
  400.       } /* endif */
  401.       int h = ibmstr[i++];
  402.       int l = ibmstr[i++];
  403.       if (!InJis90) {
  404.          wchar_t c = h << ByteBitWidth | l;
  405.          c = OldJisToNewJis(c);
  406.          l = c & ByteMask;
  407.          h = c >> ByteBitWidth;
  408.       } /* endif */
  409.       if (!IbmToJisTable[h] || !IbmToJisTable[h][l]) {
  410.          RxJisCountCheck(j + 2, jisstrsize)
  411.          jisstr[j++] = h;
  412.          jisstr[j++] = l;
  413.          continue;
  414.       } /* endif */
  415.       PCHAR s = IbmToJisTable[h][l];
  416.       int z = strlen(s);
  417.       RxJisCountCheck(j + z, jisstrsize)
  418.       while (*s) {
  419.          jisstr[j++] = *s++;
  420.       } /* endwhile */
  421.    } /* endwhile */
  422.    jisstr[j] = '\0';
  423.    return (j);
  424. }
  425.  
  426. wchar_t _Export
  427. PccodeToJiscode(
  428. wchar_t pccode) {
  429.    char b[2];
  430.    wctomb(b, pccode);
  431.    if (!PcCodeToJisCodeTable[b[0]]) {
  432.       return (FillInJis);
  433.    } /* endif */
  434.    return (PcCodeToJisCodeTable[b[0]][b[1]]);
  435. }
  436.