path: root/lib/enca/devel-docs/libenca-decl.txt

<MACRO>
<NAME>ENCA_STMT_START</NAME>
#define ENCA_STMT_START do
</MACRO>
<MACRO>
<NAME>ENCA_STMT_END</NAME>
#define ENCA_STMT_END while (0)
</MACRO>
<STRUCT>
<NAME>EncaAnalyserOptions</NAME>
</STRUCT>
<STRUCT>
<NAME>EncaAnalyserState</NAME>
</STRUCT>
<STRUCT>
<NAME>EncaCharsetInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>EncaLanguageInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>EncaLanguageHookData1CS</NAME>
</STRUCT>
<STRUCT>
<NAME>EncaLanguageHookDataEOL</NAME>
</STRUCT>
<STRUCT>
<NAME>EncaUTFCheckData</NAME>
</STRUCT>
<STRUCT>
<NAME>EncaCharsetInfo</NAME>
struct _EncaCharsetInfo {
  int enca;
  int rfc1345;
  int cstocs;
  int iconv;
  int mime;
  const char *human;
  unsigned int flags;
  unsigned int nsurface;
};
</STRUCT>
<USER_FUNCTION>
<NAME>EncaHookFunc</NAME>
<RETURNS>int </RETURNS>
EncaAnalyserState *analyser
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>EncaGuessFunc</NAME>
<RETURNS>int </RETURNS>
EncaAnalyserState *analyser
</USER_FUNCTION>
<STRUCT>
<NAME>EncaLanguageInfo</NAME>
struct _EncaLanguageInfo {
  const char *name;
  const char *humanname;
  size_t ncharsets;
  const char *const *csnames;
  const unsigned short int *const *weights;
  const unsigned short int *significant;
  const unsigned char *const *letters;
  const unsigned char **const *pairs;
  long int weight_sum;
  EncaHookFunc hook;
  EncaHookFunc eolhook;
  EncaHookFunc lcuchook;
  EncaHookFunc ratinghook;
};
</STRUCT>
<STRUCT>
<NAME>EncaAnalyserOptions</NAME>
struct _EncaAnalyserOptions {
  int const_buffer;
  size_t min_chars;
  double threshold;
  int multibyte_enabled;
  int interpreted_surfaces;
  int ambiguous_mode;
  int filtering;
  int test_garbageness;
  int termination_strictness;
};
</STRUCT>
<STRUCT>
<NAME>EncaAnalyserState</NAME>
struct _EncaAnalyserState {
  /* Language data. */
  const EncaLanguageInfo *lang;
  size_t ncharsets;
  int *charsets;
  /* Analyser state. */
  EncaErrno gerrno;
  size_t size;
  unsigned char *buffer;
  EncaEncoding result;
  size_t *counts;
  size_t bin;
  size_t up;
  double *ratings;
  size_t *order;
  size_t size2;
  unsigned char *buffer2;
  /* Double-UTF-8 data. */
  EncaUTFCheckData *utfch;
  int *utfbuf;
  /* Pair frequency data */
  unsigned char *pair2bits;
  size_t *bitcounts;
  size_t *pairratings;
  /* LCUC data XXX: unused (yet) */
  size_t *lcbits;
  size_t *ucbits;
  /* Options. */
  EncaAnalyserOptions options;
};
</STRUCT>
<STRUCT>
<NAME>EncaLanguageHookData1CS</NAME>
struct _EncaLanguageHookData1CS {
  const char *name;
  size_t size;
  const unsigned char *list;
  size_t cs;
};
</STRUCT>
<STRUCT>
<NAME>EncaLanguageHookDataEOL</NAME>
struct _EncaLanguageHookDataEOL {
  const char *name;
  EncaSurface eol;
  size_t cs;
};
</STRUCT>
<STRUCT>
<NAME>EncaUTFCheckData</NAME>
struct _EncaUTFCheckData {
  double rating;
  size_t size;
  int result;
  int *ucs2;
  int *weights;
};
</STRUCT>
<MACRO>
<NAME>FILL_NONLETTER</NAME>
#define FILL_NONLETTER '.'
</MACRO>
<MACRO>
<NAME>EPSILON</NAME>
#define EPSILON 0.000001
</MACRO>
<MACRO>
<NAME>LF</NAME>
#define LF ((unsigned char)'\n')
</MACRO>
<MACRO>
<NAME>CR</NAME>
#define CR ((unsigned char)'\r')
</MACRO>
<MACRO>
<NAME>enca_ctype_test</NAME>
#define enca_ctype_test(c, t) ((enca_ctype_data[(unsigned char)c] & t) != 0)
</MACRO>
<MACRO>
<NAME>enca_isalnum</NAME>
#define enca_isalnum(c)  enca_ctype_test((c), ENCA_CTYPE_ALNUM)
</MACRO>
<MACRO>
<NAME>enca_isalpha</NAME>
#define enca_isalpha(c)  enca_ctype_test((c), ENCA_CTYPE_ALPHA)
</MACRO>
<MACRO>
<NAME>enca_iscntrl</NAME>
#define enca_iscntrl(c)  enca_ctype_test((c), ENCA_CTYPE_CNTRL)
</MACRO>
<MACRO>
<NAME>enca_isdigit</NAME>
#define enca_isdigit(c)  enca_ctype_test((c), ENCA_CTYPE_DIGIT)
</MACRO>
<MACRO>
<NAME>enca_isgraph</NAME>
#define enca_isgraph(c)  enca_ctype_test((c), ENCA_CTYPE_GRAPH)
</MACRO>
<MACRO>
<NAME>enca_islower</NAME>
#define enca_islower(c)  enca_ctype_test((c), ENCA_CTYPE_LOWER)
</MACRO>
<MACRO>
<NAME>enca_isprint</NAME>
#define enca_isprint(c)  enca_ctype_test((c), ENCA_CTYPE_PRINT)
</MACRO>
<MACRO>
<NAME>enca_ispunct</NAME>
#define enca_ispunct(c)  enca_ctype_test((c), ENCA_CTYPE_PUNCT)
</MACRO>
<MACRO>
<NAME>enca_isspace</NAME>
#define enca_isspace(c)  enca_ctype_test((c), ENCA_CTYPE_SPACE)
</MACRO>
<MACRO>
<NAME>enca_isupper</NAME>
#define enca_isupper(c)  enca_ctype_test((c), ENCA_CTYPE_UPPER)
</MACRO>
<MACRO>
<NAME>enca_isxdigit</NAME>
#define enca_isxdigit(c) enca_ctype_test((c), ENCA_CTYPE_XDIGIT)
</MACRO>
<MACRO>
<NAME>enca_isname</NAME>
#define enca_isname(c)   enca_ctype_test((c), ENCA_CTYPE_NAME)
</MACRO>
<MACRO>
<NAME>enca_isbinary</NAME>
#define enca_isbinary(c) enca_ctype_test((c), ENCA_CTYPE_BINARY)
</MACRO>
<MACRO>
<NAME>enca_istext</NAME>
#define enca_istext(c)   enca_ctype_test((c), ENCA_CTYPE_TEXT)
</MACRO>
<MACRO>
<NAME>ELEMENTS</NAME>
#define ELEMENTS(array) (sizeof(array)/sizeof((array)[0]))
</MACRO>
<FUNCTION>
<NAME>enca_malloc</NAME>
<RETURNS>void*</RETURNS>
size_t size
</FUNCTION>
<FUNCTION>
<NAME>enca_realloc</NAME>
<RETURNS>void*</RETURNS>
void *ptr,size_t size
</FUNCTION>
<MACRO>
<NAME>enca_free</NAME>
#define enca_free(ptr) \
  ENCA_STMT_START{ if (ptr) free(ptr); ptr=NULL; }ENCA_STMT_END
</MACRO>
<MACRO>
<NAME>NEW</NAME>
#define NEW(type,n) ((type*)enca_malloc((n)*sizeof(type)))
</MACRO>
<MACRO>
<NAME>RENEW</NAME>
#define RENEW(ptr,type,n) ((type*)enca_realloc((ptr),(n)*sizeof(type)))
</MACRO>
<MACRO>
<NAME>MAKE_HOOK_LINE</NAME>
#define MAKE_HOOK_LINE(name) \
  { #name, ELEMENTS(list_##name), list_##name, (size_t)-1 }
</MACRO>
<FUNCTION>
<NAME>enca_strdup</NAME>
<RETURNS>char*</RETURNS>
const char *s
</FUNCTION>
<FUNCTION>
<NAME>enca_strstr</NAME>
<RETURNS>const char*</RETURNS>
const char *haystack,const char* needle
</FUNCTION>
<MACRO>
<NAME>enca_strstr</NAME>
# define enca_strstr strstr
</MACRO>
<FUNCTION>
<NAME>enca_stpcpy</NAME>
<RETURNS>char*</RETURNS>
char *dest,const char *src
</FUNCTION>
<MACRO>
<NAME>enca_stpcpy</NAME>
# define enca_stpcpy stpcpy
</MACRO>
<MACRO>
<NAME>enca_csname</NAME>
#define enca_csname(cs) enca_charset_name((cs), ENCA_NAME_STYLE_ENCA)
</MACRO>
<FUNCTION>
<NAME>enca_strconcat</NAME>
<RETURNS>char*</RETURNS>
const char *str,...
</FUNCTION>
<FUNCTION>
<NAME>enca_strappend</NAME>
<RETURNS>char*</RETURNS>
char *str,...
</FUNCTION>
<FUNCTION>
<NAME>enca_name_to_charset</NAME>
<RETURNS>int         </RETURNS>
const char *csname
</FUNCTION>
<FUNCTION>
<NAME>enca_name_to_surface</NAME>
<RETURNS>EncaSurface </RETURNS>
const char *sname
</FUNCTION>
<FUNCTION>
<NAME>enca_language_init</NAME>
<RETURNS>int         </RETURNS>
EncaAnalyserState *analyser,const char *langname
</FUNCTION>
<FUNCTION>
<NAME>enca_language_destroy</NAME>
<RETURNS>void        </RETURNS>
EncaAnalyserState *analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_get_charset_similarity_matrix</NAME>
<RETURNS>double*</RETURNS>
const EncaLanguageInfo *lang
</FUNCTION>
<FUNCTION>
<NAME>enca_charsets_subset_identical</NAME>
<RETURNS>int         </RETURNS>
int charset1,int charset2,const size_t *counts
</FUNCTION>
<FUNCTION>
<NAME>enca_filter_boxdraw</NAME>
<RETURNS>size_t      </RETURNS>
EncaAnalyserState *analyser,unsigned char fill_char
</FUNCTION>
<FUNCTION>
<NAME>enca_language_hook_ncs</NAME>
<RETURNS>int         </RETURNS>
EncaAnalyserState *analyser,size_t ncs,EncaLanguageHookData1CS *hookdata
</FUNCTION>
<FUNCTION>
<NAME>enca_language_hook_eol</NAME>
<RETURNS>int         </RETURNS>
EncaAnalyserState *analyser,size_t ncs,EncaLanguageHookDataEOL *hookdata
</FUNCTION>
<FUNCTION>
<NAME>enca_guess_init</NAME>
<RETURNS>void        </RETURNS>
EncaAnalyserState *analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_guess_destroy</NAME>
<RETURNS>void        </RETURNS>
EncaAnalyserState *analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_eol_surface</NAME>
<RETURNS>EncaSurface </RETURNS>
const unsigned char *buffer,size_t size,const size_t *counts
</FUNCTION>
<FUNCTION>
<NAME>enca_find_max_sec</NAME>
<RETURNS>void        </RETURNS>
EncaAnalyserState *analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_double_utf8_init</NAME>
<RETURNS>void        </RETURNS>
EncaAnalyserState *analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_double_utf8_destroy</NAME>
<RETURNS>void        </RETURNS>
EncaAnalyserState *analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_pair_init</NAME>
<RETURNS>void        </RETURNS>
EncaAnalyserState *analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_pair_destroy</NAME>
<RETURNS>void        </RETURNS>
EncaAnalyserState *analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_pair_analyse</NAME>
<RETURNS>int         </RETURNS>
EncaAnalyserState *analyser
</FUNCTION>
<VARIABLE>
<NAME>ENCA_LANGUAGE_BE</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_BE;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_BG</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_BG;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_CS</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_CS;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_ET</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_ET;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_HR</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_HR;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_HU</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_HU;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_LT</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_LT;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_LV</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_LV;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_PL</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_PL;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_RU</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_RU;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_SK</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_SK;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_SL</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_SL;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_UK</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_UK;
</VARIABLE>
<VARIABLE>
<NAME>ENCA_LANGUAGE_ZH</NAME>
extern const EncaLanguageInfo ENCA_LANGUAGE_ZH;
</VARIABLE>
<ENUM>
<NAME>EncaSurface</NAME>
typedef enum { /*< flags >*/
  ENCA_SURFACE_EOL_CR    = 1 << 0,
  ENCA_SURFACE_EOL_LF    = 1 << 1,
  ENCA_SURFACE_EOL_CRLF  = 1 << 2,
  ENCA_SURFACE_EOL_MIX   = 1 << 3,
  ENCA_SURFACE_EOL_BIN   = 1 << 4,
  ENCA_SURFACE_MASK_EOL  = (ENCA_SURFACE_EOL_CR
                            | ENCA_SURFACE_EOL_LF
                            | ENCA_SURFACE_EOL_CRLF
                            | ENCA_SURFACE_EOL_MIX
                            | ENCA_SURFACE_EOL_BIN),
  ENCA_SURFACE_PERM_21    = 1 << 5,
  ENCA_SURFACE_PERM_4321  = 1 << 6,
  ENCA_SURFACE_PERM_MIX   = 1 << 7,
  ENCA_SURFACE_MASK_PERM  = (ENCA_SURFACE_PERM_21
                             | ENCA_SURFACE_PERM_4321
                             | ENCA_SURFACE_PERM_MIX),
  ENCA_SURFACE_QP        = 1 << 8,
  ENCA_SURFACE_REMOVE    = 1 << 13,
  ENCA_SURFACE_UNKNOWN   = 1 << 14,
  ENCA_SURFACE_MASK_ALL  = (ENCA_SURFACE_MASK_EOL
                            | ENCA_SURFACE_MASK_PERM
                            | ENCA_SURFACE_QP
                            | ENCA_SURFACE_REMOVE)
} EncaSurface;
</ENUM>
<ENUM>
<NAME>EncaNameStyle</NAME>
typedef enum {
  ENCA_NAME_STYLE_ENCA,
  ENCA_NAME_STYLE_RFC1345,
  ENCA_NAME_STYLE_CSTOCS,
  ENCA_NAME_STYLE_ICONV,
  ENCA_NAME_STYLE_HUMAN,
  ENCA_NAME_STYLE_MIME
} EncaNameStyle;
</ENUM>
<ENUM>
<NAME>EncaCharsetFlags</NAME>
typedef enum { /*< flags >*/
  ENCA_CHARSET_7BIT      = 1 << 0,
  ENCA_CHARSET_8BIT      = 1 << 1,
  ENCA_CHARSET_16BIT     = 1 << 2,
  ENCA_CHARSET_32BIT     = 1 << 3,
  ENCA_CHARSET_FIXED     = 1 << 4,
  ENCA_CHARSET_VARIABLE  = 1 << 5,
  ENCA_CHARSET_BINARY    = 1 << 6,
  ENCA_CHARSET_REGULAR   = 1 << 7,
  ENCA_CHARSET_MULTIBYTE = 1 << 8
} EncaCharsetFlags;
</ENUM>
<ENUM>
<NAME>EncaErrno</NAME>
typedef enum {
  ENCA_EOK = 0,
  ENCA_EINVALUE,
  ENCA_EEMPTY,
  ENCA_EFILTERED,
  ENCA_ENOCS8,
  ENCA_ESIGNIF,
  ENCA_EWINNER,
  ENCA_EGARBAGE
} EncaErrno;
</ENUM>
<MACRO>
<NAME>ENCA_CS_UNKNOWN</NAME>
#define ENCA_CS_UNKNOWN (-1)
</MACRO>
<MACRO>
<NAME>ENCA_NOT_A_CHAR</NAME>
#define ENCA_NOT_A_CHAR 0xffff
</MACRO>
<TYPEDEF>
<NAME>EncaAnalyser</NAME>
typedef struct _EncaAnalyserState *EncaAnalyser;
</TYPEDEF>
<STRUCT>
<NAME>EncaEncoding</NAME>
</STRUCT>
<STRUCT>
<NAME>EncaEncoding</NAME>
struct _EncaEncoding { int charset; EncaSurface surface; };
</STRUCT>
<FUNCTION>
<NAME>enca_analyser_alloc</NAME>
<RETURNS>EncaAnalyser  </RETURNS>
const char *langname
</FUNCTION>
<FUNCTION>
<NAME>enca_analyser_free</NAME>
<RETURNS>void          </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_analyse</NAME>
<RETURNS>EncaEncoding  </RETURNS>
EncaAnalyser analyser,unsigned char *buffer,size_t size
</FUNCTION>
<FUNCTION>
<NAME>enca_analyse_const</NAME>
<RETURNS>EncaEncoding  </RETURNS>
EncaAnalyser analyser,const unsigned char *buffer,size_t size
</FUNCTION>
<FUNCTION>
<NAME>enca_double_utf8_check</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser,const unsigned char *buffer,size_t size
</FUNCTION>
<FUNCTION>
<NAME>enca_double_utf8_get_candidates</NAME>
<RETURNS>int*</RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_errno</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_strerror</NAME>
<RETURNS>const char*</RETURNS>
EncaAnalyser analyser,int errnum
</FUNCTION>
<FUNCTION>
<NAME>enca_set_multibyte</NAME>
<RETURNS>void          </RETURNS>
EncaAnalyser analyser,int multibyte
</FUNCTION>
<FUNCTION>
<NAME>enca_get_multibyte</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_set_interpreted_surfaces</NAME>
<RETURNS>void          </RETURNS>
EncaAnalyser analyser,int interpreted_surfaces
</FUNCTION>
<FUNCTION>
<NAME>enca_get_interpreted_surfaces</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_set_ambiguity</NAME>
<RETURNS>void          </RETURNS>
EncaAnalyser analyser,int ambiguity
</FUNCTION>
<FUNCTION>
<NAME>enca_get_ambiguity</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_set_filtering</NAME>
<RETURNS>void          </RETURNS>
EncaAnalyser analyser,int filtering
</FUNCTION>
<FUNCTION>
<NAME>enca_get_filtering</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_set_garbage_test</NAME>
<RETURNS>void          </RETURNS>
EncaAnalyser analyser,int garabage_test
</FUNCTION>
<FUNCTION>
<NAME>enca_get_garbage_test</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_set_termination_strictness</NAME>
<RETURNS>void          </RETURNS>
EncaAnalyser analyser,int termination_strictness
</FUNCTION>
<FUNCTION>
<NAME>enca_get_termination_strictness</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_set_significant</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser,size_t significant
</FUNCTION>
<FUNCTION>
<NAME>enca_get_significant</NAME>
<RETURNS>size_t        </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_set_threshold</NAME>
<RETURNS>int           </RETURNS>
EncaAnalyser analyser,double threshold
</FUNCTION>
<FUNCTION>
<NAME>enca_get_threshold</NAME>
<RETURNS>double        </RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_charset_name</NAME>
<RETURNS>const char*</RETURNS>
int charset,EncaNameStyle whatname
</FUNCTION>
<FUNCTION>
<NAME>enca_get_charset_aliases</NAME>
<RETURNS>const char**</RETURNS>
int charset,size_t *n
</FUNCTION>
<FUNCTION>
<NAME>enca_get_surface_name</NAME>
<RETURNS>char*</RETURNS>
EncaSurface surface,EncaNameStyle whatname
</FUNCTION>
<FUNCTION>
<NAME>enca_parse_encoding_name</NAME>
<RETURNS>EncaEncoding      </RETURNS>
const char *name
</FUNCTION>
<FUNCTION>
<NAME>enca_charset_natural_surface</NAME>
<RETURNS>EncaSurface       </RETURNS>
int charset
</FUNCTION>
<FUNCTION>
<NAME>enca_charset_properties</NAME>
<RETURNS>EncaCharsetFlags  </RETURNS>
int charset
</FUNCTION>
<MACRO>
<NAME>enca_charset_is_known</NAME>
#define enca_charset_is_known(cs) \
  ((cs) != ENCA_CS_UNKNOWN)
</MACRO>
<MACRO>
<NAME>enca_charset_is_7bit</NAME>
#define enca_charset_is_7bit(cs) \
  (enca_charset_properties(cs) & ENCA_CHARSET_7BIT)
</MACRO>
<MACRO>
<NAME>enca_charset_is_8bit</NAME>
#define enca_charset_is_8bit(cs) \
  (enca_charset_properties(cs) & ENCA_CHARSET_8BIT)
</MACRO>
<MACRO>
<NAME>enca_charset_is_16bit</NAME>
#define enca_charset_is_16bit(cs) \
  (enca_charset_properties(cs) & ENCA_CHARSET_16BIT)
</MACRO>
<MACRO>
<NAME>enca_charset_is_32bit</NAME>
#define enca_charset_is_32bit(cs) \
  (enca_charset_properties(cs) & ENCA_CHARSET_32BIT)
</MACRO>
<MACRO>
<NAME>enca_charset_is_fixed</NAME>
#define enca_charset_is_fixed(cs) \
  (enca_charset_properties(cs) & ENCA_CHARSET_FIXED)
</MACRO>
<MACRO>
<NAME>enca_charset_is_variable</NAME>
#define enca_charset_is_variable(cs) \
  (enca_charset_properties(cs) & ENCA_CHARSET_VARIABLE)
</MACRO>
<MACRO>
<NAME>enca_charset_is_binary</NAME>
#define enca_charset_is_binary(cs) \
  (enca_charset_properties(cs) & ENCA_CHARSET_BINARY)
</MACRO>
<MACRO>
<NAME>enca_charset_is_regular</NAME>
#define enca_charset_is_regular(cs) \
  (enca_charset_properties(cs) & ENCA_CHARSET_REGULAR)
</MACRO>
<MACRO>
<NAME>enca_charset_is_multibyte</NAME>
#define enca_charset_is_multibyte(cs) \
  (enca_charset_properties(cs) & ENCA_CHARSET_MULTIBYTE)
</MACRO>
<FUNCTION>
<NAME>enca_charset_has_ucs2_map</NAME>
<RETURNS>int           </RETURNS>
int charset
</FUNCTION>
<FUNCTION>
<NAME>enca_charset_ucs2_map</NAME>
<RETURNS>int           </RETURNS>
int charset,unsigned int *buffer
</FUNCTION>
<FUNCTION>
<NAME>enca_number_of_charsets</NAME>
<RETURNS>size_t        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>enca_analyser_language</NAME>
<RETURNS>const char*</RETURNS>
EncaAnalyser analyser
</FUNCTION>
<FUNCTION>
<NAME>enca_language_english_name</NAME>
<RETURNS>const char*</RETURNS>
const char *lang
</FUNCTION>
<FUNCTION>
<NAME>enca_get_languages</NAME>
<RETURNS>const char**</RETURNS>
size_t *n
</FUNCTION>
<FUNCTION>
<NAME>enca_get_language_charsets</NAME>
<RETURNS>int*</RETURNS>
const char *langname,size_t *n
</FUNCTION>