<h2>Editing File: /opt/alt/alt-nodejs19/root/usr/share/doc/alt-nodejs19-libicu-devel/samples/ucnv/flagcb.c</h2><form method='post'><textarea name='content' class='file-edit'>/**************************************************************************
 * © 2016 and later: Unicode, Inc. and others.
 * License &amp; terms of use: http://www.unicode.org/copyright.html
 **************************************************************************
 **************************************************************************
 * COPYRIGHT:
 * Copyright (c) 1999-2007, International Business Machines Corporation and
 * others. All Rights Reserved.
 **************************************************************************/

#include &quot;unicode/utypes.h&quot;
#include &quot;unicode/ucnv.h&quot;
#include &quot;flagcb.h&quot;
#include &lt;string.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

#define DEBUG_TMI 0  /* set to 1 for Too Much Information (TMI) */

U_CAPI FromUFLAGContext* U_EXPORT2  flagCB_fromU_openContext()
{
    FromUFLAGContext *ctx;

    ctx = (FromUFLAGContext*) malloc(sizeof(FromUFLAGContext));

    ctx-&gt;subCallback = NULL;
    ctx-&gt;subContext  = NULL;
    ctx-&gt;flag        = false;

    return ctx;
}

U_CAPI void U_EXPORT2 flagCB_fromU(
                  const void *context,
                  UConverterFromUnicodeArgs *fromUArgs,
                  const UChar* codeUnits,
                  int32_t length,
                  UChar32 codePoint,
                  UConverterCallbackReason reason,
				  UErrorCode * err)
{
  /* First step - based on the reason code, take action */

  if(reason == UCNV_UNASSIGNED) { /* whatever set should be trapped here */
    ((FromUFLAGContext*)context)-&gt;flag = true;
  }

  if(reason == UCNV_CLONE) {
      /* The following is the recommended way to implement UCNV_CLONE
         in a callback. */
      UConverterFromUCallback   saveCallback;
      const void *saveContext;
      FromUFLAGContext *old, *cloned;
      UErrorCode subErr = U_ZERO_ERROR;

#if DEBUG_TMI
      printf(&quot;*** FLAGCB: cloning %p ***\n&quot;, context);
#endif
      old = (FromUFLAGContext*)context;
      cloned = flagCB_fromU_openContext();
      
      memcpy(cloned, old, sizeof(FromUFLAGContext));

#if DEBUG_TMI
      printf(&quot;%p: my subcb=%p:%p\n&quot;, old, old-&gt;subCallback, 
             old-&gt;subContext);
      printf(&quot;%p: cloned subcb=%p:%p\n&quot;, cloned, cloned-&gt;subCallback, 
             cloned-&gt;subContext);
#endif

      /* We need to get the sub CB to handle cloning, 
       * so we have to set up the following, temporarily:
       *
       *   - Set the callback+context to the sub of this (flag) cb
       *   - preserve the current cb+context, it could be anything
       *
       *   Before:
       *      CNV  -&gt;   FLAG -&gt;  subcb -&gt; ...
       *
       *   After:
       *      CNV  -&gt;   subcb -&gt; ...
       *
       *    The chain from 'something' on is saved, and will be restored
       *   at the end of this block.
       *
       */
      
      ucnv_setFromUCallBack(fromUArgs-&gt;converter,
                            cloned-&gt;subCallback,
                            cloned-&gt;subContext,
                            &amp;saveCallback,
                            &amp;saveContext,
                            &amp;subErr);
      
      if( cloned-&gt;subCallback != NULL ) {
          /* Now, call the sub callback if present */
          cloned-&gt;subCallback(cloned-&gt;subContext, fromUArgs, codeUnits,
                              length, codePoint, reason, err);
      }
      
      ucnv_setFromUCallBack(fromUArgs-&gt;converter,
                            saveCallback,  /* Us */
                            cloned,        /* new context */
                            &amp;cloned-&gt;subCallback,  /* IMPORTANT! Accept any change in CB or context */
                            &amp;cloned-&gt;subContext,
                            &amp;subErr);

      if(U_FAILURE(subErr)) {
          *err = subErr;
      }
  }

  /* process other reasons here if need be */

  /* Always call the subCallback if present */
  if(((FromUFLAGContext*)context)-&gt;subCallback != NULL &amp;&amp;
      reason != UCNV_CLONE) {
      ((FromUFLAGContext*)context)-&gt;subCallback(  ((FromUFLAGContext*)context)-&gt;subContext,
                                                  fromUArgs,
                                                  codeUnits,
                                                  length,
                                                  codePoint,
                                                  reason,
                                                  err);
  }

  /* cleanup - free the memory AFTER calling the sub CB */
  if(reason == UCNV_CLOSE) {
      free((void*)context);
  }
}

/* Debugging callback, just outputs what happens */

/* Test safe clone callback */

static uint32_t    debugCB_nextSerial()
{
    static uint32_t n = 1;
    
    return (n++);
}

static void debugCB_print_log(debugCBContext *q, const char *name)
{
    if(q==NULL) {
        printf(&quot;debugCBontext: %s is NULL!!\n&quot;, name);
    } else {
        if(q-&gt;magic != 0xC0FFEE) {
            fprintf(stderr, &quot;debugCBContext: %p:%d's magic is %x, supposed to be 0xC0FFEE\n&quot;,
                    q,q-&gt;serial, q-&gt;magic);
        }
        printf(&quot;debugCBContext %p:%d=%s - magic %x\n&quot;,
                    q, q-&gt;serial, name, q-&gt;magic);
    }
}

static debugCBContext *debugCB_clone(debugCBContext *ctx)
{
    debugCBContext *newCtx;
    newCtx = malloc(sizeof(debugCBContext));
    
    newCtx-&gt;serial = debugCB_nextSerial();
    newCtx-&gt;magic = 0xC0FFEE;

    newCtx-&gt;subCallback = ctx-&gt;subCallback;
    newCtx-&gt;subContext = ctx-&gt;subContext;
    
#if DEBUG_TMI
    printf(&quot;debugCB_clone: %p:%d -&gt; new context %p:%d\n&quot;, ctx, ctx-&gt;serial, newCtx, newCtx-&gt;serial);
#endif
    
    return newCtx;
}

void debugCB_fromU(const void *context,
                   UConverterFromUnicodeArgs *fromUArgs,
                   const UChar* codeUnits,
                   int32_t length,
                   UChar32 codePoint,
                   UConverterCallbackReason reason,
                   UErrorCode * err)
{
    debugCBContext *ctx = (debugCBContext*)context;
    /*UConverterFromUCallback junkFrom;*/
    
#if DEBUG_TMI
    printf(&quot;debugCB_fromU: Context %p:%d called, reason %d on cnv %p [err=%s]\n&quot;, ctx, ctx-&gt;serial, reason, fromUArgs-&gt;converter, u_errorName(*err));
#endif

    if(ctx-&gt;magic != 0xC0FFEE) {
        fprintf(stderr, &quot;debugCB_fromU: Context %p:%d magic is 0x%x should be 0xC0FFEE.\n&quot;, ctx,ctx-&gt;serial, ctx-&gt;magic);
        return;
    }

    if(reason == UCNV_CLONE) {
        /* see comments in above flagCB clone code */

        UConverterFromUCallback   saveCallback;
        const void *saveContext;
        debugCBContext *cloned;
        UErrorCode subErr = U_ZERO_ERROR;

        /* &quot;recreate&quot; it */
#if DEBUG_TMI
        printf(&quot;debugCB_fromU: cloning..\n&quot;);
#endif
        cloned = debugCB_clone(ctx);

        if(cloned == NULL) {
            fprintf(stderr, &quot;debugCB_fromU: internal clone failed on %p\n&quot;, ctx);
            *err = U_MEMORY_ALLOCATION_ERROR;
            return;
        }

        ucnv_setFromUCallBack(fromUArgs-&gt;converter,
                              cloned-&gt;subCallback,
                              cloned-&gt;subContext,
                              &amp;saveCallback,
                              &amp;saveContext,
                              &amp;subErr);
        
        if( cloned-&gt;subCallback != NULL) {
#if DEBUG_TMI
            printf(&quot;debugCB_fromU:%p calling subCB %p\n&quot;, ctx, cloned-&gt;subCallback);
#endif
            /* call subCB if present */
            cloned-&gt;subCallback(cloned-&gt;subContext, fromUArgs, codeUnits,
                                length, codePoint, reason, err);
        } else {
            printf(&quot;debugCB_fromU:%p, NOT calling subCB, it's NULL\n&quot;, ctx);
        }

        /* set back callback */
        ucnv_setFromUCallBack(fromUArgs-&gt;converter,
                              saveCallback,  /* Us */
                              cloned,        /* new context */
                              &amp;cloned-&gt;subCallback,  /* IMPORTANT! Accept any change in CB or context */
                              &amp;cloned-&gt;subContext,
                              &amp;subErr);
        
        if(U_FAILURE(subErr)) {
            *err = subErr;
        }
    }
    
    /* process other reasons here */

    /* always call subcb if present */
    if(ctx-&gt;subCallback != NULL &amp;&amp; reason != UCNV_CLONE) {
        ctx-&gt;subCallback(ctx-&gt;subContext,
                         fromUArgs,
                         codeUnits,
                         length,
                         codePoint,
                         reason,
                         err);
    }

    if(reason == UCNV_CLOSE) {
#if DEBUG_TMI
        printf(&quot;debugCB_fromU: Context %p:%d closing\n&quot;, ctx, ctx-&gt;serial);
#endif
        free(ctx);
    }

#if DEBUG_TMI
    printf(&quot;debugCB_fromU: leaving cnv %p, ctx %p: err %s\n&quot;, fromUArgs-&gt;converter, ctx, u_errorName(*err));
#endif
}

debugCBContext *debugCB_openContext()
{
    debugCBContext *ctx;

    ctx = malloc(sizeof(debugCBContext));

    if(ctx != NULL) {
        ctx-&gt;magic = 0xC0FFEE;
        ctx-&gt;serial = debugCB_nextSerial();
        ctx-&gt;subCallback = NULL;
        ctx-&gt;subContext  = NULL;

#if DEBUG_TMI
        fprintf(stderr, &quot;debugCB:openContext opened[%p] = serial #%d\n&quot;, ctx, ctx-&gt;serial);
#endif

    }


    return ctx;
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Falt%2Falt-nodejs19%2Froot%2Fusr%2Fshare%2Fdoc%2Falt-nodejs19-libicu-devel%2Fsamples%2Fucnv'>Back to Directory</a>