internal.h File Reference
This graph shows which files directly or indirectly include this file:

## Data Structures

struct | M17NObjectRecord
struct | M17NObject
struct | M17NObjectArray
struct | MText
| Type of M-texts. More...

## Macros

#define | _(String) (String)
#define | MERROR(err, ret)
#define | MERROR_GOTO(err, label)
#define | MWARNING(err)
#define | MFATAL(err)
#define | MFAILP(cond) ((cond) ? 0 : mdebug_hook())
#define | M_CHECK_CHAR(c, ret)
#define | MEMORY_FULL(err)
#define | MTABLE_MALLOC(p, size, err)
#define | MTABLE_CALLOC(p, size, err)
#define | MTABLE_CALLOC_SAFE(p, size) ((p) = (void *) calloc (sizeof (*(p)), (size)))
#define | MTABLE_REALLOC(p, size, err)
#define | MTABLE_ALLOCA(p, size, err)
#define | MSTRUCT_MALLOC(p, err)
#define | MSTRUCT_CALLOC(p, err) MTABLE_CALLOC ((p), 1, (err))
#define | MSTRUCT_CALLOC_SAFE(p) MTABLE_CALLOC_SAFE ((p), 1)
#define | USE_SAFE_ALLOCA int sa_must_free = 0, sa_size = 0
#define | SAFE_ALLOCA(P, SIZE)
#define | SAFE_FREE(P)
#define | MLIST_RESET(list) ((list)->used = 0)
#define | MLIST_INIT1(list, mem, increment)
#define | MLIST_APPEND1(list, mem, elt, err)
#define | MLIST_PREPEND1(list, mem, elt, err)
#define | MLIST_INSERT1(list, mem, idx, len, err)
#define | MLIST_DELETE1(list, mem, idx, len)
#define | MLIST_COPY1(list0, list1, mem, err)
#define | MLIST_FREE1(list, mem)
#define | M17N_OBJECT(object, free_func, err)
#define | M17N_OBJECT_REF(object)
#define | M17N_OBJECT_REF_NTIMES(object, n)
#define | M17N_OBJECT_UNREF(object)
#define | M17N_OBJECT_ADD_ARRAY(array, name)
#define | M17N_OBJECT_REGISTER(array, object)
#define | M17N_OBJECT_UNREGISTER(array, object)
#define | M_CHECK_POS(mt, pos, ret)
#define | M_CHECK_POS_X(mt, pos, ret)
#define | M_CHECK_RANGE(mt, from, to, ret, ret2)
#define | M_CHECK_RANGE_X(mt, from, to, ret)
#define | M_CHECK_POS_NCHARS(mt, pos, nchars, ret, ret2)
#define | MTEXT_READ_ONLY_P(mt) ((mt)->allocated < 0)
#define | M_CHECK_READONLY(mt, ret)
#define | mtext_nchars(mt) ((mt)->nchars)
#define | mtext_nbytes(mt) ((mt)->nbytes)
#define | mtext_allocated(mt) ((mt)->allocated)
#define | mtext_reset(mt) (mtext_del ((mt), 0, (mt)->nchars))
#define | MDEBUG_FLAG() mdebug__flags[mdebug_flag]
#define | MDEBUG_PRINT0(FPRINTF)
#define | MDEBUG_PRINT(msg) MDEBUG_PRINT0 (fprintf (mdebug__output, "%s", (msg)))
#define | MDEBUG_PRINT1(fmt, arg) MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg)))
#define | MDEBUG_PRINT2(fmt, arg1, arg2) MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg1), (arg2)))
#define | MDEBUG_PRINT3(fmt, arg1, arg2, arg3) MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg1), (arg2), (arg3)))
#define | MDEBUG_PRINT4(fmt, arg1, arg2, arg3, arg4) MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg1), (arg2), (arg3), (arg4)))
#define | MDEBUG_PRINT5(fmt, arg1, arg2, arg3, arg4, arg5) MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg1), (arg2), (arg3), (arg4), (arg5)))
#define | MDEBUG_DUMP(prefix, postfix, call)
#define | MDEBUG_PUSH_TIME()
#define | MDEBUG_POP_TIME()
#define | MDEBUG_PRINT_TIME(tag, ARG_LIST)
#define | SWAP_16(c) (((c) >> 8) | (((c) & 0xFF) << 8))
#define | SWAP_32(c)

## Enumerations

enum | MTextCoverage { MTEXT_COVERAGE_ASCII , MTEXT_COVERAGE_UNICODE , MTEXT_COVERAGE_FULL }
enum | MDebugFlag { MDEBUG_INIT , MDEBUG_FINI , MDEBUG_CHARSET , MDEBUG_CODING , MDEBUG_DATABASE , MDEBUG_FONT , MDEBUG_FLT , MDEBUG_FONTSET , MDEBUG_INPUT , MDEBUG_ALL , MDEBUG_MAX = MDEBUG_ALL }

## Functions

int | mdebug_hook ()
| Hook function called on an error. More...
void | mdebug__add_object_array (M17NObjectArray *array, char *name)
void | mdebug__register_object (M17NObjectArray *array, void *object)
void | mdebug__unregister_object (M17NObjectArray *array, void *object)
void | mdebug__push_time ()
void | mdebug__pop_time ()
void | mdebug__print_time ()
int | msymbol__init ()
void | msymbol__fini ()
int | mplist__init ()
void | mplist__fini ()
int | mtext__init ()
void | mtext__fini ()
int | mtext__prop_init ()
void | mtext__prop_fini ()
int | mchartable__init ()
void | mchartable__fini ()
int | mcharset__init ()
void | mcharset__fini ()
int | mcoding__init ()
void | mcoding__fini ()
int | mdatabase__init (void)
void | mdatabase__fini (void)
int | mchar__init ()
void | mchar__fini ()
int | mlang__init ()
void | mlang__fini ()
int | mlocale__init ()
void | mlocale__fini ()
int | minput__init ()
void | minput__fini ()

## Variables

int | m17n__core_initialized
int | m17n__shell_initialized
int | m17n__gui_initialized
int | mdebug__flags [MDEBUG_MAX]
FILE * | mdebug__output

## Macro Definition Documentation

## _

#define _ | ( |  | String | ) | (String)

## MERROR

#define MERROR | ( |  | err,
|  |  | ret
| ) |  |

Value:
do { \
merror_code = (err); \
mdebug_hook(); \
return (ret); \
} while (0)

## MERROR_GOTO

#define MERROR_GOTO | ( |  | err,
|  |  | label
| ) |  |

Value:
do { \
if ((err)) \
merror_code = (err); \
mdebug_hook(); \
goto label; \
} while (0)

## MWARNING

#define MWARNING | ( |  | err | ) |

Value:
do { \
mdebug_hook(); \
goto warning; \
} while (0)

## MFATAL

#define MFATAL | ( |  | err | ) |

Value:
do { \
mdebug_hook(); \
exit (err); \
} while (0)

## MFAILP

#define MFAILP | ( |  | cond | ) | ((cond) ? 0 : mdebug_hook())

## M_CHECK_CHAR

#define M_CHECK_CHAR | ( |  | c,
|  |  | ret
| ) |  |

Value:
if ((c) < 0 || (c) > MCHAR_MAX) \
MERROR (MERROR_CHAR, (ret)); \
else
MCHAR_MAX
#define MCHAR_MAX
Maximum character code.
Definition: character.c:127
MERROR_CHAR
@ MERROR_CHAR
Definition: m17n-misc.h:39

## MEMORY_FULL

#define MEMORY_FULL | ( |  | err | ) |

Value:
do { \
(*m17n_memory_full_handler) (err); \
exit (err); \
} while (0)

## MTABLE_MALLOC

#define MTABLE_MALLOC | ( |  | p,
|  |  | size,
|  |  | err
| ) |  |

Value:
do { \
if (! ((p) = (void *) malloc (sizeof (*(p)) * (size)))) \
MEMORY_FULL (err); \
} while (0)

## MTABLE_CALLOC

#define MTABLE_CALLOC | ( |  | p,
|  |  | size,
|  |  | err
| ) |  |

Value:
do { \
if (! ((p) = (void *) calloc (sizeof (*(p)), size))) \
MEMORY_FULL (err); \
} while (0)

## MTABLE_CALLOC_SAFE

#define MTABLE_CALLOC_SAFE | ( |  | p,
|  |  | size
| ) |  | ((p) = (void *) calloc (sizeof (*(p)), (size)))

## MTABLE_REALLOC

#define MTABLE_REALLOC | ( |  | p,
|  |  | size,
|  |  | err
| ) |  |

Value:
do { \
if (! ((p) = (void *) realloc ((p), sizeof (*(p)) * (size)))) \
MEMORY_FULL (err); \
} while (0)

## MTABLE_ALLOCA

#define MTABLE_ALLOCA | ( |  | p,
|  |  | size,
|  |  | err
| ) |  |

Value:
do { \
int allocasize = sizeof (*(p)) * (size); \
if (! ((p) = (void *) alloca (allocasize))) \
MEMORY_FULL (err); \
memset ((p), 0, allocasize); \
} while (0)

## MSTRUCT_MALLOC

#define MSTRUCT_MALLOC | ( |  | p,
|  |  | err
| ) |  |

Value:
do { \
if (! ((p) = (void *) malloc (sizeof (*(p))))) \
MEMORY_FULL (err); \
} while (0)

## MSTRUCT_CALLOC

#define MSTRUCT_CALLOC | ( |  | p,
|  |  | err
| ) |  | MTABLE_CALLOC ((p), 1, (err))

## MSTRUCT_CALLOC_SAFE

#define MSTRUCT_CALLOC_SAFE | ( |  | p | ) | MTABLE_CALLOC_SAFE ((p), 1)

## USE_SAFE_ALLOCA

#define USE_SAFE_ALLOCA int sa_must_free = 0, sa_size = 0

## SAFE_ALLOCA

#define SAFE_ALLOCA | ( |  | P,
|  |  | SIZE
| ) |  |

Value:
do { \
if (sa_size < (SIZE)) \
{ \
if (sa_must_free) \
(P) = realloc ((P), (SIZE)); \
else \
{ \
(P) = alloca ((SIZE)); \
if (! (P)) \
{ \
(P) = malloc (SIZE); \
sa_must_free = 1; \
} \
} \
if (! (P)) \
MEMORY_FULL (1); \
sa_size = (SIZE); \
} \
} while (0)

## SAFE_FREE

#define SAFE_FREE | ( |  | P | ) |

Value:
do { \
if (sa_must_free && sa_size > 0) \
{ \
free ((P)); \
sa_must_free = sa_size = 0; \
} \
} while (0)

## MLIST_RESET

#define MLIST_RESET | ( |  | list | ) | ((list)->used = 0)

## MLIST_INIT1

#define MLIST_INIT1 | ( |  | list,
|  |  | mem,
|  |  | increment
| ) |  |

Value:
do { \
(list)->size = (list)->used = 0; \
(list)->inc = (increment); \
(list)->mem = NULL; \
} while (0)

## MLIST_APPEND1

#define MLIST_APPEND1 | ( |  | list,
|  |  | mem,
|  |  | elt,
|  |  | err
| ) |  |

Value:
do { \
if ((list)->inc <= 0) \
mdebug_hook(); \
if ((list)->size == (list)->used) \
{ \
(list)->size += (list)->inc; \
MTABLE_REALLOC ((list)->mem, (list)->size, (err)); \
} \
(list)->mem[(list)->used++] = (elt); \
} while (0)

## MLIST_PREPEND1

#define MLIST_PREPEND1 | ( |  | list,
|  |  | mem,
|  |  | elt,
|  |  | err
| ) |  |

Value:
do { \
if ((list)->inc <= 0) \
mdebug_hook(); \
if ((list)->size == (list)->used) \
{ \
(list)->size += (list)->inc; \
MTABLE_REALLOC ((list)->mem, (list)->size, (err)); \
} \
memmove ((list)->mem + 1, (list)->mem, \
sizeof *((list)->mem) * ((list)->used)); \
(list)->mem[0] = (elt); \
(list)->used++; \
} while (0)

## MLIST_INSERT1

#define MLIST_INSERT1 | ( |  | list,
|  |  | mem,
|  |  | idx,
|  |  | len,
|  |  | err
| ) |  |

Value:
do { \
while ((list)->used + (len) > (list)->size) \
{ \
(list)->size += (list)->inc; \
MTABLE_REALLOC ((list)->mem, (list)->size, (err)); \
} \
memmove ((list)->mem + ((idx) + (len)), (list)->mem + (idx), \
(sizeof *((list)->mem)) * ((list)->used - (idx))); \
(list)->used += (len); \
} while (0)

## MLIST_DELETE1

#define MLIST_DELETE1 | ( |  | list,
|  |  | mem,
|  |  | idx,
|  |  | len
| ) |  |

Value:
do { \
memmove ((list)->mem + (idx), (list)->mem + (idx) + (len), \
(sizeof *((list)->mem)) * ((list)->used - (idx) - (len))); \
(list)->used -= (len); \
} while (0)

## MLIST_COPY1

#define MLIST_COPY1 | ( |  | list0,
|  |  | list1,
|  |  | mem,
|  |  | err
| ) |  |

Value:
do { \
(list0)->size = (list0)->used = (list1)->used; \
(list0)->inc = 1; \
MTABLE_MALLOC ((list0)->mem, (list0)->used, (err)); \
memcpy ((list0)->mem, (list1)->mem, \
(sizeof (list0)->mem) * (list0)->used); \
} while (0)

## MLIST_FREE1

#define MLIST_FREE1 | ( |  | list,
|  |  | mem
| ) |  |

Value:
if ((list)->size) \
{ \
free ((list)->mem); \
(list)->mem = NULL; \
(list)->size = (list)->used = 0; \
} \
else

## M17N_OBJECT

#define M17N_OBJECT | ( |  | object,
|  |  | free_func,
|  |  | err
| ) |  |

Value:
do { \
MSTRUCT_CALLOC ((object), (err)); \
((M17NObject *) (object))->ref_count = 1; \
((M17NObject *) (object))->u.freer = free_func; \
} while (0)
M17NObject
Definition: internal.h:180

## M17N_OBJECT_REF

#define M17N_OBJECT_REF | ( |  | object | ) |

Value:
do { \
if (((M17NObject *) (object))->ref_count_extended) \
m17n_object_ref (object); \
else if (((M17NObject *) (object))->ref_count > 0) \
{ \
((M17NObject *) (object))->ref_count++; \
if (! ((M17NObject *) (object))->ref_count) \
{ \
((M17NObject *) (object))->ref_count--; \
m17n_object_ref (object); \
} \
} \
} while (0)

## M17N_OBJECT_REF_NTIMES

#define M17N_OBJECT_REF_NTIMES | ( |  | object,
|  |  | n
| ) |  |

Value:
do { \
int i; \
\
if (((M17NObject *) (object))->ref_count_extended) \
for (i = 0; i < n; i++) \
m17n_object_ref (object); \
else if (((M17NObject *) (object))->ref_count > 0) \
{ \
int orig_ref_count = ((M17NObject *) (object))->ref_count; \
\
for (i = 0; i < n; i++) \
if (! ++((M17NObject *) (object))->ref_count) \
{ \
((M17NObject *) (object))->ref_count = orig_ref_count; \
for (i = 0; i < n; i++) \
m17n_object_ref (object); \
} \
} \
} while (0)
m17n_object_ref
int m17n_object_ref(void *object)
Increment the reference count of a managed object.
Definition: m17n-core.c:556

## M17N_OBJECT_UNREF

#define M17N_OBJECT_UNREF | ( |  | object | ) |

Value:
do { \
if (object) \
{ \
if (((M17NObject *) (object))->ref_count_extended \
|| mdebug__flags[MDEBUG_FINI]) \
{ \
if (m17n_object_unref (object) == 0) \
(object) = NULL; \
} \
else if (((M17NObject *) (object))->ref_count == 0) \
break; \
else \
{ \
((M17NObject *) (object))->ref_count--; \
if (((M17NObject *) (object))->ref_count == 0) \
{ \
if (((M17NObject *) (object))->u.freer) \
(((M17NObject *) (object))->u.freer) (object); \
else \
free (object); \
(object) = NULL; \
} \
} \
} \
} while (0)
m17n_object_unref
int m17n_object_unref(void *object)
Decrement the reference count of a managed object.
Definition: m17n-core.c:599
MDEBUG_FINI
@ MDEBUG_FINI
Definition: internal.h:339
mdebug__flags
int mdebug__flags[MDEBUG_MAX]

## M17N_OBJECT_ADD_ARRAY

#define M17N_OBJECT_ADD_ARRAY | ( |  | array,
|  |  | name
| ) |  |

Value:
if (mdebug__flags[MDEBUG_FINI]) \
mdebug__add_object_array (&array, name); \
else

## M17N_OBJECT_REGISTER

#define M17N_OBJECT_REGISTER | ( |  | array,
|  |  | object
| ) |  |

Value:
if (mdebug__flags[MDEBUG_FINI]) \
mdebug__register_object (&array, object); \
else

## M17N_OBJECT_UNREGISTER

#define M17N_OBJECT_UNREGISTER | ( |  | array,
|  |  | object
| ) |  |

Value:
if (mdebug__flags[MDEBUG_FINI]) \
mdebug__unregister_object (&array, object); \
else

## M_CHECK_POS

#define M_CHECK_POS | ( |  | mt,
|  |  | pos,
|  |  | ret
| ) |  |

Value:
do { \
if ((pos) < 0 || (pos) >= (mt)->nchars) \
MERROR (MERROR_RANGE, (ret)); \
} while (0)
MERROR_RANGE
@ MERROR_RANGE
Definition: m17n-misc.h:43

## M_CHECK_POS_X

#define M_CHECK_POS_X | ( |  | mt,
|  |  | pos,
|  |  | ret
| ) |  |

Value:
do { \
if ((pos) < 0 || (pos) > (mt)->nchars) \
MERROR (MERROR_RANGE, (ret)); \
} while (0)

## M_CHECK_RANGE

#define M_CHECK_RANGE | ( |  | mt,
|  |  | from,
|  |  | to,
|  |  | ret,
|  |  | ret2
| ) |  |

Value:
do { \
if ((from) < 0 || (to) < (from) || (to) > (mt)->nchars) \
MERROR (MERROR_RANGE, (ret)); \
if ((from) == (to)) \
return (ret2); \
} while (0)

## M_CHECK_RANGE_X

#define M_CHECK_RANGE_X | ( |  | mt,
|  |  | from,
|  |  | to,
|  |  | ret
| ) |  |

Value:
do { \
if ((from) < 0 || (to) < (from) || (to) > (mt)->nchars) \
MERROR (MERROR_RANGE, (ret)); \
} while (0)

## M_CHECK_POS_NCHARS

#define M_CHECK_POS_NCHARS | ( |  | mt,
|  |  | pos,
|  |  | nchars,
|  |  | ret,
|  |  | ret2
| ) |  |

Value:
do { \
int to = (pos) + (nchars); \
\
M_CHECK_RANGE ((mt), (pos), (to), (ret), (ret2)); \
} while (0)
M_CHECK_RANGE
#define M_CHECK_RANGE(mt, from, to, ret, ret2)
Definition: internal.h:308

## MTEXT_READ_ONLY_P

#define MTEXT_READ_ONLY_P | ( |  | mt | ) | ((mt)->allocated < 0)

## M_CHECK_READONLY

#define M_CHECK_READONLY | ( |  | mt,
|  |  | ret
| ) |  |

Value:
do { \
if ((mt)->allocated < 0) \
MERROR (MERROR_MTEXT, (ret)); \
} while (0)
MERROR_MTEXT
@ MERROR_MTEXT
Definition: m17n-misc.h:37

## mtext_nchars

#define mtext_nchars | ( |  | mt | ) | ((mt)->nchars)

## mtext_nbytes

#define mtext_nbytes | ( |  | mt | ) | ((mt)->nbytes)

## mtext_allocated

#define mtext_allocated | ( |  | mt | ) | ((mt)->allocated)

## mtext_reset

#define mtext_reset | ( |  | mt | ) | (mtext_del ((mt), 0, (mt)->nchars))

## MDEBUG_FLAG

#define MDEBUG_FLAG | ( |  | ) | mdebug__flags[mdebug_flag]

## MDEBUG_PRINT0

#define MDEBUG_PRINT0 | ( |  | FPRINTF | ) |

Value:
do { \
if (MDEBUG_FLAG()) \
{ \
FPRINTF; \
fflush (mdebug__output); \
} \
} while (0)
MDEBUG_FLAG
#define MDEBUG_FLAG()
Definition: internal.h:355
mdebug__output
FILE * mdebug__output

## MDEBUG_PRINT

#define MDEBUG_PRINT | ( |  | msg | ) | MDEBUG_PRINT0 (fprintf (mdebug__output, "%s", (msg)))

## MDEBUG_PRINT1

#define MDEBUG_PRINT1 | ( |  | fmt,
|  |  | arg
| ) |  | MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg)))

## MDEBUG_PRINT2

#define MDEBUG_PRINT2 | ( |  | fmt,
|  |  | arg1,
|  |  | arg2
| ) |  | MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg1), (arg2)))

## MDEBUG_PRINT3

#define MDEBUG_PRINT3 | ( |  | fmt,
|  |  | arg1,
|  |  | arg2,
|  |  | arg3
| ) |  | MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg1), (arg2), (arg3)))

## MDEBUG_PRINT4

#define MDEBUG_PRINT4 | ( |  | fmt,
|  |  | arg1,
|  |  | arg2,
|  |  | arg3,
|  |  | arg4
| ) |  | MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg1), (arg2), (arg3), (arg4)))

## MDEBUG_PRINT5

#define MDEBUG_PRINT5 | ( |  | fmt,
|  |  | arg1,
|  |  | arg2,
|  |  | arg3,
|  |  | arg4,
|  |  | arg5
| ) |  | MDEBUG_PRINT0 (fprintf (mdebug__output, (fmt), (arg1), (arg2), (arg3), (arg4), (arg5)))

## MDEBUG_DUMP

#define MDEBUG_DUMP | ( |  | prefix,
|  |  | postfix,
|  |  | call
| ) |  |

Value:
do { \
if (MDEBUG_FLAG()) \
{ \
fprintf (mdebug__output, "%s", prefix); \
call; \
fprintf (mdebug__output, "%s", postfix); \
fflush (mdebug__output); \
} \
} while (0)

## MDEBUG_PUSH_TIME

#define MDEBUG_PUSH_TIME | ( |  | ) |

Value:
do { \
if (MDEBUG_FLAG()) \
mdebug__push_time(); \
} while (0)

## MDEBUG_POP_TIME

#define MDEBUG_POP_TIME | ( |  | ) |

Value:
do { \
if (MDEBUG_FLAG()) \
mdebug__pop_time(); \
} while (0)

## MDEBUG_PRINT_TIME

#define MDEBUG_PRINT_TIME | ( |  | tag,
|  |  | ARG_LIST
| ) |  |

Value:
do { \
if (MDEBUG_FLAG()) \
{ \
fprintf (mdebug__output, " [%s] ", tag); \
mdebug__print_time(); \
fprintf ARG_LIST; \
fprintf (mdebug__output, "\n"); \
} \
} while (0)

## SWAP_16

#define SWAP_16 | ( |  | c | ) | (((c) >> 8) | (((c) & 0xFF) << 8))

## SWAP_32

#define SWAP_32 | ( |  | c | ) |

Value:
(((c) >> 24) | (((c) >> 8) & 0xFF00) \
| (((c) & 0xFF00) << 8) | (((c) & 0xFF) << 24))

## Enumeration Type Documentation

## MTextCoverage

enum MTextCoverage

Enumerator
MTEXT_COVERAGE_ASCII |
MTEXT_COVERAGE_UNICODE |
MTEXT_COVERAGE_FULL |

## MDebugFlag

enum MDebugFlag

Enumerator
MDEBUG_INIT |
MDEBUG_FINI |
MDEBUG_CHARSET |
MDEBUG_CODING |
MDEBUG_DATABASE |
MDEBUG_FONT |
MDEBUG_FLT |
MDEBUG_FONTSET |
MDEBUG_INPUT |
MDEBUG_ALL |
MDEBUG_MAX |

## Function Documentation

## mdebug__add_object_array()

void mdebug__add_object_array | ( | M17NObjectArray * | array,
|  | char * | name
| ) |  |

## mdebug__register_object()

void mdebug__register_object | ( | M17NObjectArray * | array,
|  | void * | object
| ) |  |

## mdebug__unregister_object()

void mdebug__unregister_object | ( | M17NObjectArray * | array,
|  | void * | object
| ) |  |

## mdebug__push_time()

void mdebug__push_time | ( |  | ) |

## mdebug__pop_time()

void mdebug__pop_time | ( |  | ) |

## mdebug__print_time()

void mdebug__print_time | ( |  | ) |

## msymbol__init()

int msymbol__init | ( |  | ) |

## msymbol__fini()

void msymbol__fini | ( |  | ) |

## mplist__init()

int mplist__init | ( |  | ) |

## mplist__fini()

void mplist__fini | ( |  | ) |

## mtext__init()

int mtext__init | ( |  | ) |

## mtext__fini()

void mtext__fini | ( |  | ) |

## mtext__prop_init()

int mtext__prop_init | ( |  | ) |

## mtext__prop_fini()

void mtext__prop_fini | ( |  | ) |

## mchartable__init()

int mchartable__init | ( |  | ) |

## mchartable__fini()

void mchartable__fini | ( |  | ) |

## mcharset__init()

int mcharset__init | ( |  | ) |

## mcharset__fini()

void mcharset__fini | ( |  | ) |

## mcoding__init()

int mcoding__init | ( |  | ) |

## mcoding__fini()

void mcoding__fini | ( |  | ) |

## mdatabase__init()

int mdatabase__init | ( | void |  | ) |

## mdatabase__fini()

void mdatabase__fini | ( | void |  | ) |

## mchar__init()

int mchar__init | ( |  | ) |

## mchar__fini()

void mchar__fini | ( |  | ) |

## mlang__init()

int mlang__init | ( |  | ) |

## mlang__fini()

void mlang__fini | ( |  | ) |

## mlocale__init()

int mlocale__init | ( |  | ) |

## mlocale__fini()

void mlocale__fini | ( |  | ) |

## minput__init()

int minput__init | ( |  | ) |

## minput__fini()

void minput__fini | ( |  | ) |

## Variable Documentation

## m17n__core_initialized

int m17n__core_initialized

extern

## m17n__shell_initialized

int m17n__shell_initialized

extern

## m17n__gui_initialized

int m17n__gui_initialized

extern

## mdebug__flags

int mdebug__flags[MDEBUG_MAX]

extern

## mdebug__output

FILE* mdebug__output

extern