The Tor Browser: intl/icu/source/tools/icuinfo/testplug.c@fc2d59ddac77

     1 /*

     2 ******************************************************************************

3 *

     4 *   Copyright (C) 2009-2010, International Business Machines

     5 *   Corporation and others.  All Rights Reserved.

6 *

     7 ******************************************************************************

8 *

     9 *  FILE NAME : testplug.c

    10 *

    11 *   Date         Name        Description

    12 *   10/29/2009   srl          New.

    13 ******************************************************************************

    14 *

    15 *

    16 * This file implements a number of example ICU plugins.

    17 *

    18 */

    20 #include "unicode/icuplug.h"

    21 #include <stdio.h> /* for fprintf */

    22 #include <stdlib.h> /* for malloc */

    23 #include "udbgutil.h"

    24 #include "unicode/uclean.h"

    25 #include "cmemory.h"

    27 /**

    28  * Prototypes

    29  */

    30 #define DECLARE_PLUGIN(x) U_CAPI UPlugTokenReturn U_EXPORT2 x (UPlugData *data, UPlugReason reason, UErrorCode *status)

    32 DECLARE_PLUGIN(myPlugin);

    33 DECLARE_PLUGIN(myPluginLow);

    34 DECLARE_PLUGIN(myPluginFailQuery);

    35 DECLARE_PLUGIN(myPluginFailToken);

    36 DECLARE_PLUGIN(myPluginBad);

    37 DECLARE_PLUGIN(myPluginHigh);

    38 DECLARE_PLUGIN(debugMemoryPlugin);

    40 /**

    41  * A simple, trivial plugin.

    42  */

    44 U_CAPI

    45 UPlugTokenReturn U_EXPORT2 myPlugin (

    46                   UPlugData *data,

    47                   UPlugReason reason,

    48                   UErrorCode *status) {

    49 	/* Just print this for debugging */

    50     fprintf(stderr,"MyPlugin: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));

    52     if(reason==UPLUG_REASON_QUERY) {

    53         uplug_setPlugName(data, "Just a Test High-Level Plugin"); /* This call is optional in response to UPLUG_REASON_QUERY, but is a good idea. */

    54         uplug_setPlugLevel(data, UPLUG_LEVEL_HIGH); /* This call is Mandatory in response to UPLUG_REASON_QUERY */

    55     }

    57     return UPLUG_TOKEN; /* This must always be returned, to indicate that the entrypoint was actually a plugin. */

    58 }

    61 U_CAPI

    62 UPlugTokenReturn U_EXPORT2 myPluginLow (

    63                   UPlugData *data,

    64                   UPlugReason reason,

    65                   UErrorCode *status) {

    66     fprintf(stderr,"MyPluginLow: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));

    68     if(reason==UPLUG_REASON_QUERY) {

    69         uplug_setPlugName(data, "Low Plugin");

    70         uplug_setPlugLevel(data, UPLUG_LEVEL_LOW);

    71     }

    73     return UPLUG_TOKEN;

    74 }

    76 /**

    77  * Doesn't respond to QUERY properly.

    78  */

    79 U_CAPI

    80 UPlugTokenReturn U_EXPORT2 myPluginFailQuery (

    81                   UPlugData *data,

    82                   UPlugReason reason,

    83                   UErrorCode *status) {

    84     fprintf(stderr,"MyPluginFailQuery: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));

    86 	/* Should respond to UPLUG_REASON_QUERY here. */

    88     return UPLUG_TOKEN;

    89 }

    91 /**

    92  * Doesn't return the proper token.

    93  */

    94 U_CAPI

    95 UPlugTokenReturn U_EXPORT2 myPluginFailToken (

    96                   UPlugData *data,

    97                   UPlugReason reason,

    98                   UErrorCode *status) {

    99     fprintf(stderr,"MyPluginFailToken: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));

   101     if(reason==UPLUG_REASON_QUERY) {

   102         uplug_setPlugName(data, "myPluginFailToken Plugin");

   103         uplug_setPlugLevel(data, UPLUG_LEVEL_LOW);

   104     }

   106     return 0; /* Wrong. */

   107 }

   111 /**

   112  * Says it's low, but isn't.

   113  */

   114 U_CAPI

   115 UPlugTokenReturn U_EXPORT2 myPluginBad (

   116                   UPlugData *data,

   117                   UPlugReason reason,

   118                   UErrorCode *status) {

   119     fprintf(stderr,"MyPluginLow: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));

   121     if(reason==UPLUG_REASON_QUERY) {

   122         uplug_setPlugName(data, "Bad Plugin");

   123         uplug_setPlugLevel(data, UPLUG_LEVEL_LOW);

   124     } else if(reason == UPLUG_REASON_LOAD) {

   125         void *ctx = uprv_malloc(12345);

   127         uplug_setContext(data, ctx);

   128         fprintf(stderr,"I'm %p and I did a bad thing and malloced %p\n", (void*)data, (void*)ctx);

   129     } else if(reason == UPLUG_REASON_UNLOAD) {

   130         void * ctx = uplug_getContext(data);

   132         uprv_free(ctx);

   133     }

   136     return UPLUG_TOKEN;

   137 }

   139 U_CAPI

   140 UPlugTokenReturn U_EXPORT2 myPluginHigh (

   141                   UPlugData *data,

   142                   UPlugReason reason,

   143                   UErrorCode *status) {

   144     fprintf(stderr,"MyPluginHigh: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));

   146     if(reason==UPLUG_REASON_QUERY) {

   147         uplug_setPlugName(data, "High Plugin");

   148         uplug_setPlugLevel(data, UPLUG_LEVEL_HIGH);

   149     }

   151     return UPLUG_TOKEN;

   152 }

   155 /*  Debug Memory Plugin (see hpmufn.c) */

   156 static void * U_CALLCONV myMemAlloc(const void *context, size_t size) {

   157   void *retPtr = (void *)malloc(size);

   158   (void)context; /* unused */

   159   fprintf(stderr, "MEM: malloc(%d) = %p\n", (int32_t)size, retPtr);

   160   return retPtr;

   161 }

   163 static void U_CALLCONV myMemFree(const void *context, void *mem) {

   164   (void)context; /* unused */

   166   free(mem);

   167   fprintf(stderr, "MEM: free(%p)\n", mem);

   168 }

   170 static void * U_CALLCONV myMemRealloc(const void *context, void *mem, size_t size) {

   171     void *retPtr;

   172     (void)context; /* unused */

   175     if(mem==NULL) {

   176         retPtr = NULL;

   177     } else {

   178         retPtr = realloc(mem, size);

   179     }

   180     fprintf(stderr, "MEM: realloc(%p, %d) = %p\n", mem, (int32_t)size, retPtr);

   181     return retPtr;

   182 }

   184 U_CAPI

   185 UPlugTokenReturn U_EXPORT2 debugMemoryPlugin (

   186                   UPlugData *data,

   187                   UPlugReason reason,

   188                   UErrorCode *status) {

   189     fprintf(stderr,"debugMemoryPlugin: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));

   191     if(reason==UPLUG_REASON_QUERY) {

   192         uplug_setPlugLevel(data, UPLUG_LEVEL_LOW);

   193         uplug_setPlugName(data, "Memory Plugin");

   194     } else if(reason==UPLUG_REASON_LOAD) {

   195         u_setMemoryFunctions(uplug_getContext(data), &myMemAlloc, &myMemRealloc, &myMemFree, status);

   196         fprintf(stderr, "MEM: status now %s\n", u_errorName(*status));

   197     } else if(reason==UPLUG_REASON_UNLOAD) {

   198         fprintf(stderr, "MEM: not possible to unload this plugin (no way to reset memory functions)...\n");

   199         uplug_setPlugNoUnload(data, TRUE);

   200     }

   202     return UPLUG_TOKEN;

   203 }

The Tor Browser / file revision

intl/icu/source/tools/icuinfo/testplug.c@fc2d59ddac77

intl/icu/source/tools/icuinfo/testplug.c