icuSources/tools/icuinfo/testplug.c

   1 /*
   2 ******************************************************************************
   3 *
   4 *   Copyright (C) 2009-2015, 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 */
  19
  20 #include "unicode/icuplug.h"
  21
  22 #if UCONFIG_ENABLE_PLUGINS
  23 /* This file isn't usually compiled except on Windows. Guard it. */
  24
  25 #include <stdio.h> /* for fprintf */
  26 #include <stdlib.h> /* for malloc */
  27 #include "udbgutil.h"
  28 #include "unicode/uclean.h"
  29 #include "cmemory.h"
  30
  31 /**
  32  * Prototypes
  33  */
  34 #define DECLARE_PLUGIN(x) U_CAPI UPlugTokenReturn U_EXPORT2 x (UPlugData *data, UPlugReason reason, UErrorCode *status)
  35
  36 DECLARE_PLUGIN(myPlugin);
  37 DECLARE_PLUGIN(myPluginLow);
  38 DECLARE_PLUGIN(myPluginFailQuery);
  39 DECLARE_PLUGIN(myPluginFailToken);
  40 DECLARE_PLUGIN(myPluginBad);
  41 DECLARE_PLUGIN(myPluginHigh);
  42 DECLARE_PLUGIN(debugMemoryPlugin);
  43
  44 /**
  45  * A simple, trivial plugin.
  46  */
  47
  48 U_CAPI
  49 UPlugTokenReturn U_EXPORT2 myPlugin (
  50                   UPlugData *data,
  51                   UPlugReason reason,
  52                   UErrorCode *status) {
  53         /* Just print this for debugging */
  54     fprintf(stderr,"MyPlugin: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));
  55
  56     if(reason==UPLUG_REASON_QUERY) {
  57         uplug_setPlugName(data, "Just a Test High-Level Plugin"); /* This call is optional in response to UPLUG_REASON_QUERY, but is a good idea. */
  58         uplug_setPlugLevel(data, UPLUG_LEVEL_HIGH); /* This call is Mandatory in response to UPLUG_REASON_QUERY */
  59     }
  60
  61     return UPLUG_TOKEN; /* This must always be returned, to indicate that the entrypoint was actually a plugin. */
  62 }
  63
  64
  65 U_CAPI
  66 UPlugTokenReturn U_EXPORT2 myPluginLow (
  67                   UPlugData *data,
  68                   UPlugReason reason,
  69                   UErrorCode *status) {
  70     fprintf(stderr,"MyPluginLow: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));
  71
  72     if(reason==UPLUG_REASON_QUERY) {
  73         uplug_setPlugName(data, "Low Plugin");
  74         uplug_setPlugLevel(data, UPLUG_LEVEL_LOW);
  75     }
  76
  77     return UPLUG_TOKEN;
  78 }
  79
  80 /**
  81  * Doesn't respond to QUERY properly.
  82  */
  83 U_CAPI
  84 UPlugTokenReturn U_EXPORT2 myPluginFailQuery (
  85                   UPlugData *data,
  86                   UPlugReason reason,
  87                   UErrorCode *status) {
  88     fprintf(stderr,"MyPluginFailQuery: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));
  89
  90         /* Should respond to UPLUG_REASON_QUERY here. */
  91
  92     return UPLUG_TOKEN;
  93 }
  94
  95 /**
  96  * Doesn't return the proper token.
  97  */
  98 U_CAPI
  99 UPlugTokenReturn U_EXPORT2 myPluginFailToken (
 100                   UPlugData *data,
 101                   UPlugReason reason,
 102                   UErrorCode *status) {
 103     fprintf(stderr,"MyPluginFailToken: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));
 104
 105     if(reason==UPLUG_REASON_QUERY) {
 106         uplug_setPlugName(data, "myPluginFailToken Plugin");
 107         uplug_setPlugLevel(data, UPLUG_LEVEL_LOW);
 108     }
 109
 110     return 0; /* Wrong. */
 111 }
 112
 113
 114
 115 /**
 116  * Says it's low, but isn't.
 117  */
 118 U_CAPI
 119 UPlugTokenReturn U_EXPORT2 myPluginBad (
 120                   UPlugData *data,
 121                   UPlugReason reason,
 122                   UErrorCode *status) {
 123     fprintf(stderr,"MyPluginLow: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));
 124
 125     if(reason==UPLUG_REASON_QUERY) {
 126         uplug_setPlugName(data, "Bad Plugin");
 127         uplug_setPlugLevel(data, UPLUG_LEVEL_LOW);
 128     } else if(reason == UPLUG_REASON_LOAD) {
 129         void *ctx = uprv_malloc(12345);
 130
 131         uplug_setContext(data, ctx);
 132         fprintf(stderr,"I'm %p and I did a bad thing and malloced %p\n", (void*)data, (void*)ctx);
 133     } else if(reason == UPLUG_REASON_UNLOAD) {
 134         void * ctx = uplug_getContext(data);
 135
 136         uprv_free(ctx);
 137     }
 138
 139
 140     return UPLUG_TOKEN;
 141 }
 142
 143 U_CAPI
 144 UPlugTokenReturn U_EXPORT2 myPluginHigh (
 145                   UPlugData *data,
 146                   UPlugReason reason,
 147                   UErrorCode *status) {
 148     fprintf(stderr,"MyPluginHigh: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));
 149
 150     if(reason==UPLUG_REASON_QUERY) {
 151         uplug_setPlugName(data, "High Plugin");
 152         uplug_setPlugLevel(data, UPLUG_LEVEL_HIGH);
 153     }
 154
 155     return UPLUG_TOKEN;
 156 }
 157
 158
 159 /*  Debug Memory Plugin (see hpmufn.c) */
 160 static void * U_CALLCONV myMemAlloc(const void *context, size_t size) {
 161   void *retPtr = (void *)malloc(size);
 162   (void)context; /* unused */
 163   fprintf(stderr, "MEM: malloc(%d) = %p\n", (int32_t)size, retPtr);
 164   return retPtr;
 165 }
 166
 167 static void U_CALLCONV myMemFree(const void *context, void *mem) {
 168   (void)context; /* unused */
 169
 170   free(mem);
 171   fprintf(stderr, "MEM: free(%p)\n", mem);
 172 }
 173
 174 static void * U_CALLCONV myMemRealloc(const void *context, void *mem, size_t size) {
 175     void *retPtr;
 176     (void)context; /* unused */
 177
 178
 179     if(mem==NULL) {
 180         retPtr = NULL;
 181     } else {
 182         retPtr = realloc(mem, size);
 183     }
 184     fprintf(stderr, "MEM: realloc(%p, %d) = %p\n", mem, (int32_t)size, retPtr);
 185     return retPtr;
 186 }
 187
 188 U_CAPI
 189 UPlugTokenReturn U_EXPORT2 debugMemoryPlugin (
 190                   UPlugData *data,
 191                   UPlugReason reason,
 192                   UErrorCode *status) {
 193     fprintf(stderr,"debugMemoryPlugin: data=%p, reason=%s, status=%s\n", (void*)data, udbg_enumName(UDBG_UPlugReason,(int32_t)reason), u_errorName(*status));
 194
 195     if(reason==UPLUG_REASON_QUERY) {
 196         uplug_setPlugLevel(data, UPLUG_LEVEL_LOW);
 197         uplug_setPlugName(data, "Memory Plugin");
 198     } else if(reason==UPLUG_REASON_LOAD) {
 199         u_setMemoryFunctions(uplug_getContext(data), &myMemAlloc, &myMemRealloc, &myMemFree, status);
 200         fprintf(stderr, "MEM: status now %s\n", u_errorName(*status));
 201     } else if(reason==UPLUG_REASON_UNLOAD) {
 202         fprintf(stderr, "MEM: not possible to unload this plugin (no way to reset memory functions)...\n");
 203         uplug_setPlugNoUnload(data, TRUE);
 204     }
 205
 206     return UPLUG_TOKEN;
 207 }
 208
 209 #endif