2 ******************************************************************************
4 * Copyright (C) 2001-2005, International Business Machines *
5 * Corporation and others. All Rights Reserved. *
7 ******************************************************************************
10 * tab size: 8 (not used)
13 * created on: 2001July05
14 * created by: George Rhoten
20 #include "unicode/utypes.h"
23 * \brief C API: Initialize and clean up ICU
27 * Initialize ICU. The description further below applies to ICU 2.6 to ICU 3.4.
28 * Starting with ICU 3.4, u_init() needs not be called any more for
29 * ensuring thread safety, but it can give an indication for whether ICU
30 * can load its data. In ICU 3.4, it will try to load the converter alias table
31 * (cnvalias.icu) and give an error code if that fails.
32 * This may change in the future.
34 * For ensuring the availability of necessary data, an application should
35 * open the service objects (converters, collators, etc.) that it will use
36 * and check for error codes there.
38 * Documentation for ICU 2.6 to ICU 3.4:
40 * This function loads and initializes data items
41 * that are required internally by various ICU functions. Use of this explicit
42 * initialization is required in multi-threaded applications; in
43 * single threaded apps, use is optional, but incurs little additional
44 * cost, and is thus recommended.
46 * In multi-threaded applications, u_init() should be called in the
47 * main thread before starting additional threads, or, alternatively
48 * it can be called in each individual thread once, before other ICU
49 * functions are called in that thread. In this second scenario, the
50 * application must guarantee that the first call to u_init() happen
51 * without contention, in a single thread only.
53 * If <code>u_setMemoryFunctions()</code> or
54 * <code>u_setMutexFunctions</code> are needed (uncommon), they must be
55 * called _before_ <code>u_init()</code>.
57 * Extra, repeated, or otherwise unneeded calls to u_init() do no harm,
58 * other than taking a small amount of time.
60 * @param status An ICU UErrorCode parameter. It must not be <code>NULL</code>.
61 * An Error will be returned if some required part of ICU data can not
62 * be loaded or initialized.
63 * The function returns immediately if the input error code indicates a
68 U_STABLE void U_EXPORT2
69 u_init(UErrorCode *status);
72 * Clean up the system resources, such as allocated memory or open files,
73 * used in all ICU libraries. This will free/delete all memory owned by the
74 * ICU libraries, and return them to their original load state. All open ICU
75 * items (collators, resource bundles, converters, etc.) must be closed before
76 * calling this function, otherwise ICU may not free its allocated memory
77 * (e.g. close your converters and resource bundles before calling this
78 * function). Generally, this function should be called once just before
79 * an application exits. For applications that dynamically load and unload
80 * the ICU libraries (relatively uncommon), u_cleanup() should be called
81 * just before the library unload.
83 * u_cleanup() also clears any ICU heap functions, mutex functions or
84 * trace functions that may have been set for the process.
85 * This has the effect of restoring ICU to its initial condition, before
86 * any of these override functions were installed. Refer to
87 * u_setMemoryFunctions(), u_setMutexFunctions and
88 * utrace_setFunctions(). If ICU is to be reinitialized after after
89 * calling u_cleanup(), these runtime override functions will need to
90 * be set up again if they are still required.
92 * u_cleanup() is not thread safe. All other threads should stop using ICU
93 * before calling this function.
95 * Any open ICU items will be left in an undefined state by u_cleanup(),
96 * and any subsequent attempt to use such an item will give unpredictable
99 * After calling u_cleanup(), an application may continue to use ICU by
100 * calling u_init(). An application must invoke u_init() first from one single
101 * thread before allowing other threads call u_init(). All threads existing
102 * at the time of the first thread's call to u_init() must also call
103 * u_init() themselves before continuing with other ICU operations.
105 * The use of u_cleanup() just before an application terminates is optional,
106 * but it should be called only once for performance reasons. The primary
107 * benefit is to eliminate reports of memory or resource leaks originating
108 * in ICU code from the results generated by heap analysis tools.
110 * <strong>Use this function with great care!</strong>
116 U_STABLE void U_EXPORT2
123 * An opaque pointer type that represents an ICU mutex.
124 * For user-implemented mutexes, the value will typically point to a
125 * struct or object that implements the mutex.
132 * Function Pointer type for a user supplied mutex initialization function.
133 * The user-supplied function will be called by ICU whenever ICU needs to create a
134 * new mutex. The function implementation should create a mutex, and store a pointer
135 * to something that uniquely identifies the mutex into the UMTX that is supplied
137 * @param context user supplied value, obtained from from u_setMutexFunctions().
138 * @param mutex Receives a pointer that identifies the new mutex.
139 * The mutex init function must set the UMTX to a non-null value.
140 * Subsequent calls by ICU to lock, unlock, or destroy a mutex will
141 * identify the mutex by the UMTX value.
142 * @param status Error status. Report errors back to ICU by setting this variable
143 * with an error code.
147 typedef void U_CALLCONV UMtxInitFn (const void *context, UMTX *mutex, UErrorCode* status);
151 * Function Pointer type for a user supplied mutex functions.
152 * One of the user-supplied functions with this signature will be called by ICU
153 * whenever ICU needs to lock, unlock, or destroy a mutex.
154 * @param context user supplied value, obtained from from u_setMutexFunctions().
155 * @param mutex specify the mutex on which to operate.
159 typedef void U_CALLCONV UMtxFn (const void *context, UMTX *mutex);
163 * Set the functions that ICU will use for mutex operations
164 * Use of this function is optional; by default (without this function), ICU will
165 * directly access system functions for mutex operations
166 * This function can only be used when ICU is in an initial, unused state, before
167 * u_init() has been called.
168 * This function may be used even when ICU has been built without multi-threaded
169 * support (see ICU_USE_THREADS pre-processor variable, umutex.h)
170 * @param context This pointer value will be saved, and then (later) passed as
171 * a parameter to the user-supplied mutex functions each time they
173 * @param init Pointer to a mutex initialization function. Must be non-null.
174 * @param destroy Pointer to the mutex destroy function. Must be non-null.
175 * @param lock pointer to the mutex lock function. Must be non-null.
176 * @param unlock Pointer to the mutex unlock function. Must be non-null.
177 * @param status Receives error values.
181 U_STABLE void U_EXPORT2
182 u_setMutexFunctions(const void *context, UMtxInitFn *init, UMtxFn *destroy, UMtxFn *lock, UMtxFn *unlock,
187 * Pointer type for a user supplied atomic increment or decrement function.
188 * @param context user supplied value, obtained from from u_setAtomicIncDecFunctions().
189 * @param p Pointer to a 32 bit int to be incremented or decremented
190 * @return The value of the variable after the inc or dec operation.
194 typedef int32_t U_CALLCONV UMtxAtomicFn(const void *context, int32_t *p);
197 * Set the functions that ICU will use for atomic increment and decrement of int32_t values.
198 * Use of this function is optional; by default (without this function), ICU will
199 * use its own internal implementation of atomic increment/decrement.
200 * This function can only be used when ICU is in an initial, unused state, before
201 * u_init() has been called.
202 * @param context This pointer value will be saved, and then (later) passed as
203 * a parameter to the increment and decrement functions each time they
204 * are called. This function can only be called
205 * @param inc Pointer to a function to do an atomic increment operation. Must be non-null.
206 * @param dec Pointer to a function to do an atomic decrement operation. Must be non-null.
207 * @param status Receives error values.
211 U_STABLE void U_EXPORT2
212 u_setAtomicIncDecFunctions(const void *context, UMtxAtomicFn *inc, UMtxAtomicFn *dec,
218 * Pointer type for a user supplied memory allocation function.
219 * @param context user supplied value, obtained from from u_setMemoryFunctions().
220 * @param size The number of bytes to be allocated
221 * @return Pointer to the newly allocated memory, or NULL if the allocation failed.
225 typedef void *U_CALLCONV UMemAllocFn(const void *context, size_t size);
227 * Pointer type for a user supplied memory re-allocation function.
228 * @param context user supplied value, obtained from from u_setMemoryFunctions().
229 * @param size The number of bytes to be allocated
230 * @return Pointer to the newly allocated memory, or NULL if the allocation failed.
234 typedef void *U_CALLCONV UMemReallocFn(const void *context, void *mem, size_t size);
236 * Pointer type for a user supplied memory free function. Behavior should be
237 * similar the standard C library free().
238 * @param context user supplied value, obtained from from u_setMemoryFunctions().
239 * @param mem Pointer to the memory block to be resized
240 * @param size The new size for the block
241 * @return Pointer to the resized memory block, or NULL if the resizing failed.
245 typedef void U_CALLCONV UMemFreeFn (const void *context, void *mem);
248 * Set the functions that ICU will use for memory allocation.
249 * Use of this function is optional; by default (without this function), ICU will
250 * use the standard C library malloc() and free() functions.
251 * This function can only be used when ICU is in an initial, unused state, before
252 * u_init() has been called.
253 * @param context This pointer value will be saved, and then (later) passed as
254 * a parameter to the memory functions each time they
256 * @param a Pointer to a user-supplied malloc function.
257 * @param r Pointer to a user-supplied realloc function.
258 * @param f Pointer to a user-supplied free function.
259 * @param status Receives error values.
263 U_STABLE void U_EXPORT2
264 u_setMemoryFunctions(const void *context, UMemAllocFn *a, UMemReallocFn *r, UMemFreeFn *f,