LCOV - code coverage report
Current view: top level - lkbce/include/linux - nls.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 13 13 100.0 %
Date: 2017-01-25 Functions: 3 3 100.0 %

          Line data    Source code
       1             : #ifndef _LINUX_NLS_H
       2             : #define _LINUX_NLS_H
       3             : 
       4             : #include <linux/init.h>
       5             : 
       6             : /* Unicode has changed over the years.  Unicode code points no longer
       7             :  * fit into 16 bits; as of Unicode 5 valid code points range from 0
       8             :  * to 0x10ffff (17 planes, where each plane holds 65536 code points).
       9             :  *
      10             :  * The original decision to represent Unicode characters as 16-bit
      11             :  * wchar_t values is now outdated.  But plane 0 still includes the
      12             :  * most commonly used characters, so we will retain it.  The newer
      13             :  * 32-bit unicode_t type can be used when it is necessary to
      14             :  * represent the full Unicode character set.
      15             :  */
      16             : 
      17             : /* Plane-0 Unicode character */
      18           1 : typedef u16 wchar_t;
      19             : #define MAX_WCHAR_T     0xffff
      20             : 
      21             : /* Arbitrary Unicode character */
      22             : typedef u32 unicode_t;
      23           1 : 
      24             : struct nls_table {
      25             :         const char *charset;
      26             :         const char *alias;
      27             :         int (*uni2char) (wchar_t uni, unsigned char *out, int boundlen);
      28             :         int (*char2uni) (const unsigned char *rawstring, int boundlen,
      29             :                          wchar_t *uni);
      30             :         const unsigned char *charset2lower;
      31             :         const unsigned char *charset2upper;
      32             :         struct module *owner;
      33             :         struct nls_table *next;
      34             : };
      35             : 
      36             : /* this value hold the maximum octet of charset */
      37             : #define NLS_MAX_CHARSET_SIZE 6 /* for UTF-8 */
      38             : 
      39             : /* Byte order for UTF-16 strings */
      40             : enum utf16_endian {
      41             :         UTF16_HOST_ENDIAN,
      42             :         UTF16_LITTLE_ENDIAN,
      43             :         UTF16_BIG_ENDIAN
      44             : };
      45             : 
      46             : /* nls.c */
      47             : extern int register_nls(struct nls_table *);
      48             : extern int unregister_nls(struct nls_table *);
      49             : extern struct nls_table *load_nls(char *);
      50             : extern void unload_nls(struct nls_table *);
      51             : extern struct nls_table *load_nls_default(void);
      52             : 
      53             : extern int utf8_to_utf32(const u8 *s, int len, unicode_t *pu);
      54             : extern int utf32_to_utf8(unicode_t u, u8 *s, int maxlen);
      55             : extern int utf8s_to_utf16s(const u8 *s, int len, wchar_t *pwcs);
      56             : extern int utf16s_to_utf8s(const wchar_t *pwcs, int len,
      57             :                 enum utf16_endian endian, u8 *s, int maxlen);
      58             : 
      59             : static inline unsigned char nls_tolower(struct nls_table *t, unsigned char c)
      60             : {
      61           6 :         unsigned char nc = t->charset2lower[c];
      62             : 
      63          18 :         return nc ? nc : c;
      64             : }
      65             : 
      66             : static inline unsigned char nls_toupper(struct nls_table *t, unsigned char c)
      67             : {
      68          12 :         unsigned char nc = t->charset2upper[c];
      69             : 
      70          36 :         return nc ? nc : c;
      71             : }
      72             : 
      73             : static inline int nls_strnicmp(struct nls_table *t, const unsigned char *s1,
      74             :                 const unsigned char *s2, int len)
      75             : {
      76           6 :         while (len--) {
      77          12 :                 if (nls_tolower(t, *s1++) != nls_tolower(t, *s2++))
      78           3 :                         return 1;
      79           1 :         }
      80           1 : 
      81           1 :         return 0;
      82           1 : }
      83             : 
      84             : /*
      85             :  * nls_nullsize - return length of null character for codepage
      86             :  * @codepage - codepage for which to return length of NULL terminator
      87             :  *
      88             :  * Since we can't guarantee that the null terminator will be a particular
      89             :  * length, we have to check against the codepage. If there's a problem
      90             :  * determining it, assume a single-byte NULL terminator.
      91             :  */
      92             : static inline int
      93             : nls_nullsize(const struct nls_table *codepage)
      94             : {
      95             :         int charlen;
      96             :         char tmp[NLS_MAX_CHARSET_SIZE];
      97             : 
      98             :         charlen = codepage->uni2char(0, tmp, NLS_MAX_CHARSET_SIZE);
      99             : 
     100             :         return charlen > 0 ? charlen : 1;
     101             : }
     102             : 
     103             : #define MODULE_ALIAS_NLS(name)  MODULE_ALIAS("nls_" __stringify(name))
     104             : 
     105             : #endif /* _LINUX_NLS_H */
     106             : 

Generated by: LCOV version 1.10