home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / ICU / src / icuapps / locexp / util / decompcb.c next >
Encoding:
C/C++ Source or Header  |  1999-10-22  |  6.9 KB  |  310 lines
  1. #include "stdio.h"
  2. #include "stddef.h"
  3.  
  4. /* Largest decomposition sequence is 18 chars at U+FDFA */
  5. #define DECOMP_MAX 32
  6.  
  7. #include "utypes.h"
  8. #include "ustring.h"
  9.  
  10. #include "ucnv.h"
  11. #include "ucnv_bld.h"
  12. #include "udat.h"
  13. #include "ucal.h"
  14. #include "uchar.h"
  15.  
  16. #include "ucol.h"
  17.  
  18. #include "decompcb.h"
  19.  
  20. UConverterFromUCallback DECOMPOSE_lastResortCallback = UCNV_FROM_U_CALLBACK_SUBSTITUTE;
  21.  
  22. static UChar block0300Subs[] =
  23.     { 0x0060, 0x00b4, 0x005e, 0x007e, 0x007e, 0x00af, 0x0306, 0x0307, 0x00a8, 0x0309, 0x00b0, 0x0022, 0x030c, 0x0022 }; 
  24.  
  25.  
  26. static UChar block0390Subs[] = 
  27. { 
  28.   0x0390,
  29.   0x0041,
  30.   0x0042,
  31.   0x0047,
  32.   0x0044,
  33.   0x0045,
  34.   0x005A,
  35.   0x0048,
  36.   0x0398,
  37.   0x0049
  38. };
  39.  
  40. #ifdef KXI
  41. #include "../dev/kxitbl.c"
  42. #endif
  43.  
  44. /* clone the converter, reset it, and then try to transcode the source into the
  45.    target. If it fails, then transcode into the error buffer. 
  46.  
  47.    source isn't modified because this fcn is expected to deal with all of it.
  48.    
  49.    This would be a very useful function for other callbacks.
  50. */
  51. static void convertIntoTargetOrErrChars(UConverter *_this,
  52.                     char **target,
  53.                     const char *targetLimit,
  54.                     const UChar *source,
  55.                     const UChar *sourceLimit,
  56.                     UErrorCode *err)
  57. {
  58.   const UChar      *sourceAlias = source;
  59.   UErrorCode subErr = U_ZERO_ERROR;   
  60.   char       *myTarget;
  61.   UConverter myConverter = *_this; /* bitwise copy */
  62.  
  63.   ucnv_reset(&myConverter); /* necessary???? */
  64.  
  65.   /*  ucnv_setFromUCallBack (&myConverter,               <-- unneeded
  66.              (UConverterFromUCallback)  UCNV_FROM_U_CALLBACK_DECOMPOSE,
  67.              &err2);*/
  68.   
  69.   ucnv_fromUnicode (&myConverter,
  70.             target,
  71.             targetLimit,
  72.             &sourceAlias,
  73.             sourceLimit,
  74.             NULL,
  75.             TRUE,
  76.             &subErr); /* pass them the real error. */
  77.   
  78.   if(subErr == U_INDEX_OUTOFBOUNDS_ERROR)
  79.     {
  80.       /* it didn't fit. */
  81.       subErr = U_ZERO_ERROR;
  82.  
  83.       myTarget = _this->charErrorBuffer + _this->charErrorBufferLength;
  84.  
  85.       /* OK hit it */
  86.       ucnv_fromUnicode(&myConverter,
  87.                &myTarget,
  88.                _this->charErrorBuffer + UCNV_ERROR_BUFFER_LENGTH,
  89.                &sourceAlias,
  90.                sourceLimit,
  91.                NULL,
  92.                TRUE,
  93.                &subErr);
  94.       /* fix the charBufferLength */
  95.  
  96.       /* **todo: check err here! */
  97.       _this->charErrorBufferLength = ((unsigned char *)myTarget - _this->charErrorBuffer);
  98.  
  99.       *err = U_INDEX_OUTOFBOUNDS_ERROR;
  100.     }
  101. }
  102.  
  103.  
  104.  
  105.  
  106.  
  107. /* called for each char */
  108. static void DECOMPOSE_uchar(UConverter * _this,
  109.                 const UChar **source,
  110.                 const UChar *sourceLimit,
  111.           char **target,
  112.           const char *targetLimit,
  113.           UChar theChar,
  114.           UErrorCode * err)
  115. {
  116.   UChar      decomposedSequence[DECOMP_MAX];
  117.   const UChar     *tempSource, *output;
  118.   int32_t    decomposedLen;
  119.   UErrorCode err2 = U_ZERO_ERROR;
  120.  
  121.   bool_t     changedSomething = FALSE;  /* have we had *any* effect here? 
  122.                        Used to exit when this fcn isn't doing
  123.                        any good. */
  124.  
  125.   
  126.   tempSource = &theChar;
  127.  
  128.   /* First, attempt a decompose */
  129.   decomposedLen = u_normalize(&theChar,
  130.                   1,
  131.                   UCOL_DECOMP_COMPAT,
  132.                   0,
  133.                   decomposedSequence,
  134.                   DECOMP_MAX,
  135.                   &err2);
  136.  
  137.   if( (decomposedLen != 1)  ||
  138.       u_strncmp(&theChar, decomposedSequence, 1) )
  139.     {
  140.       *err = U_USING_FALLBACK_ERROR;
  141.  
  142.       /* Since we changed something, we'll try doing another conversion.
  143.          Guess what callback we use! */
  144.  
  145.       /* Q:: In fact, do we even need a new converter here? would it mess things up here to
  146.      simply use _this as the converter?? the state would be kinda-ok then. 
  147.      Need opinions! 
  148.       */
  149.       
  150.       convertIntoTargetOrErrChars(_this, 
  151.                   target,
  152.                   targetLimit,
  153.                   decomposedSequence,
  154.                   decomposedSequence+decomposedLen,
  155.                   err);
  156.  
  157.       return;
  158.  
  159.     }
  160.  
  161.  
  162.   /* Try other substitutions */
  163.   decomposedSequence[0] = theChar;
  164.   decomposedSequence[1] = 0;
  165.   output = decomposedSequence;
  166.  
  167.  
  168.   /* the following switch statement can either:  
  169.      1). change 'output' to a totally different string,
  170.      2). modify the string in 'decomposedSequence', OR
  171.      3). do nothing, in which case the SUBSTITUTE callback will be called.
  172.   */
  173.   
  174.   switch(theChar & 0xFF00)
  175.     {
  176.     case 0x0000:
  177.       switch(theChar)
  178.     {
  179.     case 0x00E6:
  180.       decomposedSequence[0] = 'a'; /* ASCIISM */
  181.       decomposedSequence[1] = 'e'; /* ASCIISM */
  182.       decomposedSequence[2] = 0;
  183.       break;
  184.     }
  185.       break;
  186.  
  187.     case 0x0300: /* combining diacriticals ------------------ 0300 */
  188.       if(theChar < (0x0300 + (sizeof(block0300Subs)/sizeof(UChar))))
  189.     {
  190.       decomposedSequence[0] = block0300Subs[theChar & 0x00FF];
  191.     }
  192. #if 0
  193.       else if( (theChar >= 0x0391) && (theChar <= (0x0390 - 1 + (sizeof(block0390Subs)/sizeof(UChar)))))
  194.     { /* greek xliteration */
  195.       decomposedSequence[0] = block0390Subs[theChar - 0x0390];
  196.     }
  197. #endif
  198.       break;
  199.       
  200.     case 0x2000:
  201.       switch(theChar)
  202.     {
  203.     case 0x2044:
  204.       decomposedSequence[0] = '/'; /* ASCIISM */
  205.       break;
  206.     }
  207.       break;
  208.       
  209. #ifdef KXI
  210.     case 0x2F00: /* radical forms */
  211.       if(theChar < 0x2FD6 )
  212.     {
  213.       decomposedSequence[0] = 0xFE43;
  214.       decomposedSequence[1] = kxitbl[((theChar & 0x00FF)*2) + 1];
  215.       decomposedSequence[2] = 0xFE44;
  216.       decomposedSequence[3] = 0x0000;
  217.     }
  218.       break;
  219. #endif
  220.     }
  221.  
  222.   if((output != decomposedSequence) ||       /* if it's a different ptr */
  223.      ( (decomposedSequence[0] != theChar) || /* if the decomposedSeq changed*/
  224.        (decomposedSequence[1] != 0) ) )
  225.     {
  226.       /* Yes! We have something different. Put it out.. */
  227.       *err = U_USING_FALLBACK_ERROR;
  228.       
  229.       convertIntoTargetOrErrChars(_this, 
  230.                   target,
  231.                   targetLimit,
  232.                   output,
  233.                   output+u_strlen(output),
  234.                   err);
  235.       return;
  236.     }
  237.  
  238.  
  239.   /* nothing WE can do .. */
  240.   
  241.   (*DECOMPOSE_lastResortCallback)(_this,
  242.                   target,
  243.                   targetLimit,
  244.                   source, /* source shouldn't be needed */
  245.                   sourceLimit, /* sourcelimit doesn't matter */
  246.                   0, /* offsets, */
  247.                   TRUE, /* flush, */
  248.                   err);
  249.  
  250. }
  251.  
  252. U_CAPI void 
  253.   UCNV_FROM_U_CALLBACK_DECOMPOSE (UConverter * _this,
  254.                         char **target,
  255.                         const char *targetLimit,
  256.                         const UChar ** source,
  257.                         const UChar * sourceLimit,
  258.                         int32_t *offsets,
  259.                         bool_t flush,
  260.                         UErrorCode * err)
  261. {
  262.   int32_t i;
  263.   char   *oldTarget;
  264.  
  265.   if (CONVERSION_U_SUCCESS (*err))
  266.     return;
  267.  
  268.   for(i=0;i<_this->invalidUCharLength;i++)
  269.     {
  270.       oldTarget = *target;
  271.  
  272.       /* 
  273.      TODO: [optimization]
  274.      if(target == targetLimit)
  275.         theirTarget = _this->charErrorBuffer;
  276.      etc.
  277.  
  278.      Then, after calling the fcn, update the charErrorLen.
  279.  
  280.      This way, the subfunc won't have to copy back into the charErrorLen
  281.       */
  282.  
  283.       DECOMPOSE_uchar(_this,
  284.               source,
  285.               sourceLimit,
  286.               target,
  287.               targetLimit,
  288.               _this->invalidUCharBuffer[i],
  289.               err);
  290.  
  291.       /* TODO:
  292.      o  update offsets[0..(target-oldTarget)]
  293.      o  offsets += [target-oldTarget]
  294.  
  295.      thank you. 
  296.         --american P
  297.       */
  298.     }
  299.  
  300.  
  301.   return;
  302. }
  303. /*******************************************************end of borrowed code from ucnv_err.c **/
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.