From d984a59f3d91e0c9c3cc1c86471d3ba9f3967969 Mon Sep 17 00:00:00 2001 From: Nandini Rebello Date: Fri, 12 Oct 2018 13:42:13 +0530 Subject: [PATCH] util: adding 8 national sms alphabets Adding national language tables for hindi,kannada,malayalam, oriya,punjabi,tamil,telugu and urdu. --- src/smsutil.c | 4 +- src/smsutil.h | 8 + src/util.c | 1867 +++++++++++++++++++++++++++++++++++++++++++++++++ src/util.h | 8 + 4 files changed, 1885 insertions(+), 2 deletions(-) diff --git a/src/smsutil.c b/src/smsutil.c index dfa838de..90f158b2 100644 --- a/src/smsutil.c +++ b/src/smsutil.c @@ -2280,10 +2280,10 @@ char *sms_decode_text(GSList *sms_list) * If language is not defined in 3GPP TS 23.038, * implementations are instructed to ignore it */ - if (locking_shift > SMS_ALPHABET_GUJARATI) + if (locking_shift > SMS_ALPHABET_URDU) locking_shift = GSM_DIALECT_DEFAULT; - if (single_shift > SMS_ALPHABET_GUJARATI) + if (single_shift > SMS_ALPHABET_URDU) single_shift = GSM_DIALECT_DEFAULT; converted = convert_gsm_to_utf8_with_lang(buf, written, diff --git a/src/smsutil.h b/src/smsutil.h index 3f585cb9..0adba51c 100644 --- a/src/smsutil.h +++ b/src/smsutil.h @@ -161,6 +161,14 @@ enum sms_alphabet { SMS_ALPHABET_PORTUGUESE, SMS_ALPHABET_BENGALI, SMS_ALPHABET_GUJARATI, + SMS_ALPHABET_HINDI, + SMS_ALPHABET_KANNADA, + SMS_ALPHABET_MALAYALAM, + SMS_ALPHABET_ORIYA, + SMS_ALPHABET_PUNJABI, + SMS_ALPHABET_TAMIL, + SMS_ALPHABET_TELUGU, + SMS_ALPHABET_URDU, }; enum sms_mwi_type { diff --git a/src/util.c b/src/util.c index 70d72d72..31bc5c9c 100644 --- a/src/util.c +++ b/src/util.c @@ -608,6 +608,1346 @@ static const struct codepoint guj_ext_unicode[] = { { 0x20AC, 0x1B65 } }; +/* Appendix A.2.6. in 3GPP TS23.038 V.8.2.0 */ +static const struct codepoint hin_ext_gsm[] = { + { 0x00, 0x0040 }, + { 0x01, 0x00A3 }, + { 0x02, 0x0024 }, + { 0x03, 0x00A5 }, + { 0x04, 0x00BF }, + { 0x05, 0x0022 }, + { 0x06, 0x00A4 }, + { 0x07, 0x0025 }, + { 0x08, 0x0026 }, + { 0x09, 0x0027 }, + { 0x0A, 0x000C }, /* See NOTE 3 */ + { 0x0B, 0x002A }, + { 0x0C, 0x002B }, + { 0x0E, 0x002D }, + { 0x0F, 0x002F }, + { 0x10, 0x003C }, + { 0x11, 0x003D }, + { 0x12, 0x003E }, + { 0x13, 0x00A1 }, + { 0x14, 0x005E }, + { 0x15, 0x00A1 }, + { 0x16, 0x005F }, + { 0x17, 0x0023 }, + { 0x18, 0x002A }, + { 0x19, 0x0964 }, + { 0x1A, 0x0965 }, + { 0x1B, 0x0020 }, /* See NOTE 1 */ + { 0x1C, 0x0966 }, + { 0x1D, 0x0967 }, + { 0x1E, 0x0968 }, + { 0x1F, 0x0969 }, + { 0x20, 0x096A }, + { 0x21, 0x096B }, + { 0x22, 0x096C }, + { 0x23, 0x096D }, + { 0x24, 0x096E }, + { 0x25, 0x096F }, + { 0x26, 0x0951 }, + { 0x27, 0x0952 }, + { 0x28, 0x007B }, + { 0x29, 0x007D }, + { 0x2A, 0x0953 }, + { 0x2B, 0x0954 }, + { 0x2C, 0x0958 }, + { 0x2D, 0x0959 }, + { 0x2E, 0x095A }, + { 0x2F, 0x005C }, + { 0x30, 0x095B }, + { 0x31, 0x095C }, + { 0x32, 0x095D }, + { 0x33, 0x095E }, + { 0x34, 0x095F }, + { 0x35, 0x0960 }, + { 0x36, 0x0961 }, + { 0x37, 0x0962 }, + { 0x38, 0x0963 }, + { 0x39, 0x0970 }, + { 0x3A, 0x0971 }, + { 0x3C, 0x005B }, + { 0x3D, 0x007E }, + { 0x3E, 0x005D }, + { 0x40, 0x007C }, + { 0x41, 0x0041 }, + { 0x42, 0x0042 }, + { 0x43, 0x0043 }, + { 0x44, 0x0044 }, + { 0x45, 0x0045 }, + { 0x46, 0x0046 }, + { 0x47, 0x0047 }, + { 0x48, 0x0048 }, + { 0x49, 0x0049 }, + { 0x4A, 0x004A }, + { 0x4B, 0x004B }, + { 0x4C, 0x004C }, + { 0x4D, 0x004D }, + { 0x4E, 0x004E }, + { 0x4F, 0x004F }, + { 0x50, 0x0050 }, + { 0x51, 0x0051 }, + { 0x52, 0x0052 }, + { 0x53, 0x0053 }, + { 0x54, 0x0054 }, + { 0x55, 0x0055 }, + { 0x56, 0x0056 }, + { 0x57, 0x0057 }, + { 0x58, 0x0058 }, + { 0x59, 0x0059 }, + { 0x5A, 0x005A }, + { 0x65, 0x20AC } +}; + +static const struct codepoint hin_ext_unicode[] = { + { 0x000C, 0x1B0A }, + { 0x0022, 0x1B05 }, + { 0x0023, 0x1B17 }, + { 0x0024, 0x1B02 }, + { 0x0025, 0x1B07 }, + { 0x0026, 0x1B08 }, + { 0x0027, 0x1B09 }, + { 0x002A, 0x1B0B }, + { 0x002A, 0x1B18 }, + { 0x002B, 0x1B0C }, + { 0x002D, 0x1B0E }, + { 0x002F, 0x1B0F }, + { 0x003C, 0x1B10 }, + { 0x003D, 0x1B11 }, + { 0x003E, 0x1B12 }, + { 0x0040, 0x1B00 }, + { 0x0041, 0x1B41 }, + { 0x0042, 0x1B42 }, + { 0x0043, 0x1B43 }, + { 0x0044, 0x1B44 }, + { 0x0045, 0x1B45 }, + { 0x0046, 0x1B46 }, + { 0x0047, 0x1B47 }, + { 0x0048, 0x1B48 }, + { 0x0049, 0x1B49 }, + { 0x004A, 0x1B4A }, + { 0x004B, 0x1B4B }, + { 0x004C, 0x1B4C }, + { 0x004D, 0x1B4D }, + { 0x004E, 0x1B4E }, + { 0x004F, 0x1B4F }, + { 0x0050, 0x1B50 }, + { 0x0051, 0x1B51 }, + { 0x0052, 0x1B52 }, + { 0x0053, 0x1B53 }, + { 0x0054, 0x1B54 }, + { 0x0055, 0x1B55 }, + { 0x0056, 0x1B56 }, + { 0x0057, 0x1B57 }, + { 0x0058, 0x1B58 }, + { 0x0059, 0x1B59 }, + { 0x005A, 0x1B5A }, + { 0x005B, 0x1B3C }, + { 0x005C, 0x1B2F }, + { 0x005D, 0x1B3E }, + { 0x005E, 0x1B14 }, + { 0x005F, 0x1B16 }, + { 0x007B, 0x1B28 }, + { 0x007C, 0x1B40 }, + { 0x007D, 0x1B29 }, + { 0x007E, 0x1B3D }, + { 0x00A1, 0x1B13 }, + { 0x00A1, 0x1B15 }, + { 0x00A3, 0x1B01 }, + { 0x00A4, 0x1B06 }, + { 0x00A5, 0x1B03 }, + { 0x00BF, 0x1B04 }, + { 0x0951, 0x1B26 }, + { 0x0952, 0x1B27 }, + { 0x0953, 0x1B2A }, + { 0x0954, 0x1B2B }, + { 0x0958, 0x1B2C }, + { 0x0959, 0x1B2D }, + { 0x095A, 0x1B2E }, + { 0x095B, 0x1B30 }, + { 0x095C, 0x1B31 }, + { 0x095D, 0x1B32 }, + { 0x095E, 0x1B33 }, + { 0x095F, 0x1B34 }, + { 0x0960, 0x1B35 }, + { 0x0961, 0x1B36 }, + { 0x0962, 0x1B37 }, + { 0x0963, 0x1B38 }, + { 0x0964, 0x1B19 }, + { 0x0965, 0x1B1A }, + { 0x0966, 0x1B1C }, + { 0x0967, 0x1B1D }, + { 0x0968, 0x1B1E }, + { 0x0969, 0x1B1F }, + { 0x096A, 0x1B20 }, + { 0x096B, 0x1B21 }, + { 0x096C, 0x1B22 }, + { 0x096D, 0x1B23 }, + { 0x096E, 0x1B24 }, + { 0x096F, 0x1B25 }, + { 0x0970, 0x1B39 }, + { 0x0971, 0x1B3A }, + { 0x20AC, 0x1B65 } +}; + +/* Appendix A.2.7. in 3GPP TS23.038 V.8.2.0 */ +static const struct codepoint kan_ext_gsm[] = { + { 0x00, 0x0040 }, + { 0x01, 0x00A3 }, + { 0x02, 0x0024 }, + { 0x03, 0x00A5 }, + { 0x04, 0x00BF }, + { 0x05, 0x0022 }, + { 0x06, 0x00A4 }, + { 0x07, 0x0025 }, + { 0x08, 0x0026 }, + { 0x09, 0x0027 }, + { 0x0A, 0x000C }, /* See NOTE 3 */ + { 0x0B, 0x002A }, + { 0x0C, 0x002B }, + { 0x0E, 0x002D }, + { 0x0F, 0x002F }, + { 0x10, 0x003C }, + { 0x11, 0x003D }, + { 0x12, 0x003E }, + { 0x13, 0x00A1 }, + { 0x14, 0x005E }, + { 0x15, 0x00A1 }, + { 0x16, 0x005F }, + { 0x17, 0x0023 }, + { 0x18, 0x002A }, + { 0x19, 0x0964 }, + { 0x1A, 0x0965 }, + { 0x1B, 0x0020 }, /* See NOTE 1 */ + { 0x1C, 0x0CE6 }, + { 0x1D, 0x0CE7 }, + { 0x1E, 0x0CE8 }, + { 0x1F, 0x0CE9 }, + { 0x20, 0x0CEA }, + { 0x21, 0x0CEB }, + { 0x22, 0x0CEC }, + { 0x23, 0x0CED }, + { 0x24, 0x0CEE }, + { 0x25, 0x0CEF }, + { 0x26, 0x0CDE }, + { 0x27, 0x0CF1 }, + { 0x28, 0x007B }, + { 0x29, 0x007D }, + { 0x2A, 0x0CF2 }, + { 0x2F, 0x005C }, + { 0x3C, 0x005D }, + { 0x3D, 0x007E }, + { 0x3E, 0x005D }, + { 0x40, 0x007C }, + { 0x41, 0x0041 }, + { 0x42, 0x0042 }, + { 0x43, 0x0043 }, + { 0x44, 0x0044 }, + { 0x45, 0x0045 }, + { 0x46, 0x0046 }, + { 0x47, 0x0047 }, + { 0x48, 0x0048 }, + { 0x49, 0x0049 }, + { 0x4A, 0x004A }, + { 0x4B, 0x004B }, + { 0x4C, 0x004C }, + { 0x4D, 0x004D }, + { 0x4E, 0x004E }, + { 0x4F, 0x004F }, + { 0x50, 0x0050 }, + { 0x51, 0x0051 }, + { 0x52, 0x0052 }, + { 0x53, 0x0053 }, + { 0x54, 0x0054 }, + { 0x55, 0x0055 }, + { 0x56, 0x0056 }, + { 0x57, 0x0057 }, + { 0x58, 0x0058 }, + { 0x59, 0x0059 }, + { 0x5A, 0x005A }, + { 0x65, 0x20AC } +}; + +static const struct codepoint kan_ext_unicode[] = { + { 0x000C, 0x1B0A }, + { 0x0022, 0x1B05 }, + { 0x0023, 0x1B17 }, + { 0x0024, 0x1B02 }, + { 0x0025, 0x1B07 }, + { 0x0026, 0x1B08 }, + { 0x0027, 0x1B09 }, + { 0x002A, 0x1B0B }, + { 0x002A, 0x1B18 }, + { 0x002B, 0x1B0C }, + { 0x002D, 0x1B0E }, + { 0x002F, 0x1B0F }, + { 0x003C, 0x1B10 }, + { 0x003D, 0x1B11 }, + { 0x003E, 0x1B12 }, + { 0x0040, 0x1B00 }, + { 0x0041, 0x1B41 }, + { 0x0042, 0x1B42 }, + { 0x0043, 0x1B43 }, + { 0x0044, 0x1B44 }, + { 0x0045, 0x1B45 }, + { 0x0046, 0x1B46 }, + { 0x0047, 0x1B47 }, + { 0x0048, 0x1B48 }, + { 0x0049, 0x1B49 }, + { 0x004A, 0x1B4A }, + { 0x004B, 0x1B4B }, + { 0x004C, 0x1B4C }, + { 0x004D, 0x1B4D }, + { 0x004E, 0x1B4E }, + { 0x004F, 0x1B4F }, + { 0x0050, 0x1B50 }, + { 0x0051, 0x1B51 }, + { 0x0052, 0x1B52 }, + { 0x0053, 0x1B53 }, + { 0x0054, 0x1B54 }, + { 0x0055, 0x1B55 }, + { 0x0056, 0x1B56 }, + { 0x0057, 0x1B57 }, + { 0x0058, 0x1B58 }, + { 0x0059, 0x1B59 }, + { 0x005A, 0x1B5A }, + { 0x005C, 0x1B2F }, + { 0x005D, 0x1B3C }, + { 0x005D, 0x1B3E }, + { 0x005E, 0x1B14 }, + { 0x005F, 0x1B16 }, + { 0x007B, 0x1B28 }, + { 0x007C, 0x1B40 }, + { 0x007D, 0x1B29 }, + { 0x007E, 0x1B3D }, + { 0x00A1, 0x1B13 }, + { 0x00A1, 0x1B15 }, + { 0x00A3, 0x1B01 }, + { 0x00A4, 0x1B06 }, + { 0x00A5, 0x1B03 }, + { 0x00BF, 0x1B04 }, + { 0x0964, 0x1B19 }, + { 0x0965, 0x1B1A }, + { 0x0CDE, 0x1B26 }, + { 0x0CE6, 0x1B1C }, + { 0x0CE7, 0x1B1D }, + { 0x0CE8, 0x1B1E }, + { 0x0CE9, 0x1B1F }, + { 0x0CEA, 0x1B20 }, + { 0x0CEB, 0x1B21 }, + { 0x0CEC, 0x1B22 }, + { 0x0CED, 0x1B23 }, + { 0x0CEE, 0x1B24 }, + { 0x0CEF, 0x1B25 }, + { 0x0CF1, 0x1B27 }, + { 0x0CF2, 0x1B2A }, + { 0x20AC, 0x1B65 } +}; + +/* Appendix A.2.8. in 3GPP TS23.038 V.8.2.0 */ +static const struct codepoint mal_ext_gsm[] = { + { 0x00, 0x0040 }, + { 0x01, 0x00A3 }, + { 0x02, 0x0024 }, + { 0x03, 0x00A5 }, + { 0x04, 0x00BF }, + { 0x05, 0x0022 }, + { 0x06, 0x00A4 }, + { 0x07, 0x0025 }, + { 0x08, 0x0026 }, + { 0x09, 0x0027 }, + { 0x0A, 0x000C }, /* See NOTE 3 */ + { 0x0B, 0x002A }, + { 0x0C, 0x002B }, + { 0x0E, 0x002D }, + { 0x0F, 0x002F }, + { 0x10, 0x003C }, + { 0x11, 0x003D }, + { 0x12, 0x003E }, + { 0x13, 0x00A1 }, + { 0x14, 0x005E }, + { 0x15, 0x00A1 }, + { 0x16, 0x005F }, + { 0x17, 0x0023 }, + { 0x18, 0x002A }, + { 0x19, 0x0964 }, + { 0x1A, 0x0965 }, + { 0x1B, 0x0020 }, /* See NOTE 1 */ + { 0x1C, 0x0D66 }, + { 0x1D, 0x0D67 }, + { 0x1E, 0x0D68 }, + { 0x1F, 0x0D69 }, + { 0x20, 0x0D6A }, + { 0x21, 0x0D6B }, + { 0x22, 0x0D6C }, + { 0x23, 0x0D6D }, + { 0x24, 0x0D6E }, + { 0x25, 0x0D6F }, + { 0x26, 0x0D70 }, + { 0x27, 0x0D71 }, + { 0x28, 0x007B }, + { 0x29, 0x007D }, + { 0x2A, 0x0D72 }, + { 0x2B, 0x0D73 }, + { 0x2C, 0x0D74 }, + { 0x2D, 0x0D75 }, + { 0x2E, 0x0D7A }, + { 0x2F, 0x005C }, + { 0x30, 0x0D7B }, + { 0x31, 0x0D7C }, + { 0x32, 0x0D7D }, + { 0x33, 0x0D7E }, + { 0x34, 0x0D7F }, + { 0x3C, 0x005B }, + { 0x3D, 0x007E }, + { 0x3E, 0x005D }, + { 0x40, 0x007C }, + { 0x41, 0x0041 }, + { 0x42, 0x0042 }, + { 0x43, 0x0043 }, + { 0x44, 0x0044 }, + { 0x45, 0x0045 }, + { 0x46, 0x0046 }, + { 0x47, 0x0047 }, + { 0x48, 0x0048 }, + { 0x49, 0x0049 }, + { 0x4A, 0x004A }, + { 0x4B, 0x004B }, + { 0x4C, 0x004C }, + { 0x4D, 0x004D }, + { 0x4E, 0x004E }, + { 0x4F, 0x004F }, + { 0x50, 0x0050 }, + { 0x51, 0x0051 }, + { 0x52, 0x0052 }, + { 0x53, 0x0053 }, + { 0x54, 0x0054 }, + { 0x55, 0x0055 }, + { 0x56, 0x0056 }, + { 0x57, 0x0057 }, + { 0x58, 0x0058 }, + { 0x59, 0x0059 }, + { 0x5A, 0x005A }, + { 0x65, 0x20AC } +}; + +static const struct codepoint mal_ext_unicode[] = { + { 0x000C, 0x1B0A }, + { 0x0022, 0x1B05 }, + { 0x0023, 0x1B17 }, + { 0x0024, 0x1B02 }, + { 0x0025, 0x1B07 }, + { 0x0026, 0x1B08 }, + { 0x0027, 0x1B09 }, + { 0x002A, 0x1B0B }, + { 0x002A, 0x1B18 }, + { 0x002B, 0x1B0C }, + { 0x002D, 0x1B0E }, + { 0x002F, 0x1B0F }, + { 0x003C, 0x1B10 }, + { 0x003D, 0x1B11 }, + { 0x003E, 0x1B12 }, + { 0x0040, 0x1B00 }, + { 0x0041, 0x1B41 }, + { 0x0042, 0x1B42 }, + { 0x0043, 0x1B43 }, + { 0x0044, 0x1B44 }, + { 0x0045, 0x1B45 }, + { 0x0046, 0x1B46 }, + { 0x0047, 0x1B47 }, + { 0x0048, 0x1B48 }, + { 0x0049, 0x1B49 }, + { 0x004A, 0x1B4A }, + { 0x004B, 0x1B4B }, + { 0x004C, 0x1B4C }, + { 0x004D, 0x1B4D }, + { 0x004E, 0x1B4E }, + { 0x004F, 0x1B4F }, + { 0x0050, 0x1B50 }, + { 0x0051, 0x1B51 }, + { 0x0052, 0x1B52 }, + { 0x0053, 0x1B53 }, + { 0x0054, 0x1B54 }, + { 0x0055, 0x1B55 }, + { 0x0056, 0x1B56 }, + { 0x0057, 0x1B57 }, + { 0x0058, 0x1B58 }, + { 0x0059, 0x1B59 }, + { 0x005A, 0x1B5A }, + { 0x005B, 0x1B3C }, + { 0x005C, 0x1B2F }, + { 0x005D, 0x1B3E }, + { 0x005E, 0x1B14 }, + { 0x005F, 0x1B16 }, + { 0x007B, 0x1B28 }, + { 0x007C, 0x1B40 }, + { 0x007D, 0x1B29 }, + { 0x007E, 0x1B3D }, + { 0x00A1, 0x1B13 }, + { 0x00A1, 0x1B15 }, + { 0x00A3, 0x1B01 }, + { 0x00A4, 0x1B06 }, + { 0x00A5, 0x1B03 }, + { 0x00BF, 0x1B04 }, + { 0x0964, 0x1B19 }, + { 0x0965, 0x1B1A }, + { 0x0D66, 0x1B1C }, + { 0x0D67, 0x1B1D }, + { 0x0D68, 0x1B1E }, + { 0x0D69, 0x1B1F }, + { 0x0D6A, 0x1B20 }, + { 0x0D6B, 0x1B21 }, + { 0x0D6C, 0x1B22 }, + { 0x0D6D, 0x1B23 }, + { 0x0D6E, 0x1B24 }, + { 0x0D6F, 0x1B25 }, + { 0x0D70, 0x1B26 }, + { 0x0D71, 0x1B27 }, + { 0x0D72, 0x1B2A }, + { 0x0D73, 0x1B2B }, + { 0x0D74, 0x1B2C }, + { 0x0D75, 0x1B2D }, + { 0x0D7A, 0x1B2E }, + { 0x0D7B, 0x1B30 }, + { 0x0D7C, 0x1B31 }, + { 0x0D7D, 0x1B32 }, + { 0x0D7E, 0x1B33 }, + { 0x0D7F, 0x1B34 }, + { 0x20AC, 0x1B65 } +}; + +/* Appendix A.2.9. in 3GPP TS23.038 V.8.2.0 */ +static const struct codepoint ori_ext_gsm[] = { + { 0x00, 0x0040 }, + { 0x01, 0x00A3 }, + { 0x02, 0x0024 }, + { 0x03, 0x00A5 }, + { 0x04, 0x00BF }, + { 0x05, 0x0022 }, + { 0x06, 0x00A4 }, + { 0x07, 0x0025 }, + { 0x08, 0x0026 }, + { 0x09, 0x0027 }, + { 0x0A, 0x000C }, /* See NOTE 3 */ + { 0x0B, 0x002A }, + { 0x0C, 0x002B }, + { 0x0E, 0x002D }, + { 0x0F, 0x002F }, + { 0x10, 0x003C }, + { 0x11, 0x003D }, + { 0x12, 0x003E }, + { 0x13, 0x00A1 }, + { 0x14, 0x005E }, + { 0x15, 0x00A1 }, + { 0x16, 0x005F }, + { 0x17, 0x0023 }, + { 0x18, 0x002A }, + { 0x19, 0x0964 }, + { 0x1A, 0x0965 }, + { 0x1B, 0x0020 }, /* See NOTE 1 */ + { 0x1C, 0x0B66 }, + { 0x1D, 0x0B67 }, + { 0x1E, 0x0B68 }, + { 0x1F, 0x0B69 }, + { 0x20, 0x0B6A }, + { 0x21, 0x0B6B }, + { 0x22, 0x0B6C }, + { 0x23, 0x0B6D }, + { 0x24, 0x0B6E }, + { 0x25, 0x0B6F }, + { 0x26, 0x0B5C }, + { 0x27, 0x0B5D }, + { 0x28, 0x007B }, + { 0x29, 0x007D }, + { 0x2A, 0x0B5F }, + { 0x2B, 0x0B70 }, + { 0x2C, 0x0B71 }, + { 0x2F, 0x005C }, + { 0x3C, 0x005B }, + { 0x3D, 0x007E }, + { 0x3E, 0x005D }, + { 0x40, 0x007C }, + { 0x41, 0x0041 }, + { 0x42, 0x0042 }, + { 0x43, 0x0043 }, + { 0x44, 0x0044 }, + { 0x45, 0x0045 }, + { 0x46, 0x0046 }, + { 0x47, 0x0047 }, + { 0x48, 0x0048 }, + { 0x49, 0x0049 }, + { 0x4A, 0x004A }, + { 0x4B, 0x004B }, + { 0x4C, 0x004C }, + { 0x4D, 0x004D }, + { 0x4E, 0x004E }, + { 0x4F, 0x004F }, + { 0x50, 0x0050 }, + { 0x51, 0x0051 }, + { 0x52, 0x0052 }, + { 0x53, 0x0053 }, + { 0x54, 0x0054 }, + { 0x55, 0x0055 }, + { 0x56, 0x0056 }, + { 0x57, 0x0057 }, + { 0x58, 0x0058 }, + { 0x59, 0x0059 }, + { 0x5A, 0x005A }, + { 0x65, 0x20AC } +}; + +static const struct codepoint ori_ext_unicode[] = { + { 0x000C, 0x1B0A }, + { 0x0022, 0x1B05 }, + { 0x0023, 0x1B17 }, + { 0x0024, 0x1B02 }, + { 0x0025, 0x1B07 }, + { 0x0026, 0x1B08 }, + { 0x0027, 0x1B09 }, + { 0x002A, 0x1B0B }, + { 0x002A, 0x1B18 }, + { 0x002B, 0x1B0C }, + { 0x002D, 0x1B0E }, + { 0x002F, 0x1B0F }, + { 0x003C, 0x1B10 }, + { 0x003D, 0x1B11 }, + { 0x003E, 0x1B12 }, + { 0x0040, 0x1B00 }, + { 0x0041, 0x1B41 }, + { 0x0042, 0x1B42 }, + { 0x0043, 0x1B43 }, + { 0x0044, 0x1B44 }, + { 0x0045, 0x1B45 }, + { 0x0046, 0x1B46 }, + { 0x0047, 0x1B47 }, + { 0x0048, 0x1B48 }, + { 0x0049, 0x1B49 }, + { 0x004A, 0x1B4A }, + { 0x004B, 0x1B4B }, + { 0x004C, 0x1B4C }, + { 0x004D, 0x1B4D }, + { 0x004E, 0x1B4E }, + { 0x004F, 0x1B4F }, + { 0x0050, 0x1B50 }, + { 0x0051, 0x1B51 }, + { 0x0052, 0x1B52 }, + { 0x0053, 0x1B53 }, + { 0x0054, 0x1B54 }, + { 0x0055, 0x1B55 }, + { 0x0056, 0x1B56 }, + { 0x0057, 0x1B57 }, + { 0x0058, 0x1B58 }, + { 0x0059, 0x1B59 }, + { 0x005A, 0x1B5A }, + { 0x005B, 0x1B3C }, + { 0x005C, 0x1B2F }, + { 0x005D, 0x1B3E }, + { 0x005E, 0x1B14 }, + { 0x005F, 0x1B16 }, + { 0x007B, 0x1B28 }, + { 0x007C, 0x1B40 }, + { 0x007D, 0x1B29 }, + { 0x007E, 0x1B3D }, + { 0x00A1, 0x1B13 }, + { 0x00A1, 0x1B15 }, + { 0x00A3, 0x1B01 }, + { 0x00A4, 0x1B06 }, + { 0x00A5, 0x1B03 }, + { 0x00BF, 0x1B04 }, + { 0x0964, 0x1B19 }, + { 0x0965, 0x1B1A }, + { 0x0B5C, 0x1B26 }, + { 0x0B5D, 0x1B27 }, + { 0x0B5F, 0x1B2A }, + { 0x0B66, 0x1B1C }, + { 0x0B67, 0x1B1D }, + { 0x0B68, 0x1B1E }, + { 0x0B69, 0x1B1F }, + { 0x0B6A, 0x1B20 }, + { 0x0B6B, 0x1B21 }, + { 0x0B6C, 0x1B22 }, + { 0x0B6D, 0x1B23 }, + { 0x0B6E, 0x1B24 }, + { 0x0B6F, 0x1B25 }, + { 0x0B70, 0x1B2B }, + { 0x0B71, 0x1B2C }, + { 0x20AC, 0x1B65 } +}; + +/* Appendix A.2.10. in 3GPP TS23.038 V.8.2.0 */ +static const struct codepoint pun_ext_gsm[] = { + { 0x00, 0x0040 }, + { 0x01, 0x00A3 }, + { 0x02, 0x0024 }, + { 0x03, 0x00A5 }, + { 0x04, 0x00BF }, + { 0x05, 0x0022 }, + { 0x06, 0x00A4 }, + { 0x07, 0x0025 }, + { 0x08, 0x0026 }, + { 0x09, 0x0027 }, + { 0x0A, 0x000C }, /* See NOTE 3 */ + { 0x0B, 0x002A }, + { 0x0C, 0x002B }, + { 0x0E, 0x002D }, + { 0x0F, 0x002F }, + { 0x10, 0x003C }, + { 0x11, 0x003D }, + { 0x12, 0x003E }, + { 0x13, 0x00A1 }, + { 0x14, 0x005E }, + { 0x15, 0x00A1 }, + { 0x16, 0x005F }, + { 0x17, 0x0023 }, + { 0x18, 0x002A }, + { 0x19, 0x0964 }, + { 0x1A, 0x0965 }, + { 0x1B, 0x0020 }, /* See NOTE 1 */ + { 0x1C, 0x0A66 }, + { 0x1D, 0x0A67 }, + { 0x1E, 0x0A68 }, + { 0x1F, 0x0A69 }, + { 0x20, 0x0A6A }, + { 0x21, 0x0A6B }, + { 0x22, 0x0A6C }, + { 0x23, 0x0A6D }, + { 0x24, 0x0A6E }, + { 0x25, 0x0A6F }, + { 0x26, 0x0A59 }, + { 0x27, 0x0A5A }, + { 0x28, 0x007B }, + { 0x29, 0x007D }, + { 0x2A, 0x0A5B }, + { 0x2B, 0x0A5C }, + { 0x2C, 0x0A5E }, + { 0x2D, 0x0A75 }, + { 0x2F, 0x005C }, + { 0x3C, 0x005B }, + { 0x3D, 0x007E }, + { 0x3E, 0x005D }, + { 0x40, 0x007C }, + { 0x41, 0x0041 }, + { 0x42, 0x0042 }, + { 0x43, 0x0043 }, + { 0x44, 0x0044 }, + { 0x45, 0x0045 }, + { 0x46, 0x0046 }, + { 0x47, 0x0047 }, + { 0x48, 0x0048 }, + { 0x49, 0x0049 }, + { 0x4A, 0x004A }, + { 0x4B, 0x004B }, + { 0x4C, 0x004C }, + { 0x4D, 0x004D }, + { 0x4E, 0x004E }, + { 0x4F, 0x004F }, + { 0x50, 0x0050 }, + { 0x51, 0x0051 }, + { 0x52, 0x0052 }, + { 0x53, 0x0053 }, + { 0x54, 0x0054 }, + { 0x55, 0x0055 }, + { 0x56, 0x0056 }, + { 0x57, 0x0057 }, + { 0x58, 0x0058 }, + { 0x59, 0x0059 }, + { 0x5A, 0x005A }, + { 0x65, 0x20AC } +}; + +static const struct codepoint pun_ext_unicode[] = { + { 0x000C, 0x1B0A }, + { 0x0022, 0x1B05 }, + { 0x0023, 0x1B17 }, + { 0x0024, 0x1B02 }, + { 0x0025, 0x1B07 }, + { 0x0026, 0x1B08 }, + { 0x0027, 0x1B09 }, + { 0x002A, 0x1B0B }, + { 0x002A, 0x1B18 }, + { 0x002B, 0x1B0C }, + { 0x002D, 0x1B0E }, + { 0x002F, 0x1B0F }, + { 0x003C, 0x1B10 }, + { 0x003D, 0x1B11 }, + { 0x003E, 0x1B12 }, + { 0x0040, 0x1B00 }, + { 0x0041, 0x1B41 }, + { 0x0042, 0x1B42 }, + { 0x0043, 0x1B43 }, + { 0x0044, 0x1B44 }, + { 0x0045, 0x1B45 }, + { 0x0046, 0x1B46 }, + { 0x0047, 0x1B47 }, + { 0x0048, 0x1B48 }, + { 0x0049, 0x1B49 }, + { 0x004A, 0x1B4A }, + { 0x004B, 0x1B4B }, + { 0x004C, 0x1B4C }, + { 0x004D, 0x1B4D }, + { 0x004E, 0x1B4E }, + { 0x004F, 0x1B4F }, + { 0x0050, 0x1B50 }, + { 0x0051, 0x1B51 }, + { 0x0052, 0x1B52 }, + { 0x0053, 0x1B53 }, + { 0x0054, 0x1B54 }, + { 0x0055, 0x1B55 }, + { 0x0056, 0x1B56 }, + { 0x0057, 0x1B57 }, + { 0x0058, 0x1B58 }, + { 0x0059, 0x1B59 }, + { 0x005A, 0x1B5A }, + { 0x005B, 0x1B3C }, + { 0x005C, 0x1B2F }, + { 0x005D, 0x1B3E }, + { 0x005E, 0x1B14 }, + { 0x005F, 0x1B16 }, + { 0x007B, 0x1B28 }, + { 0x007C, 0x1B40 }, + { 0x007D, 0x1B29 }, + { 0x007E, 0x1B3D }, + { 0x00A1, 0x1B13 }, + { 0x00A1, 0x1B15 }, + { 0x00A3, 0x1B01 }, + { 0x00A4, 0x1B06 }, + { 0x00A5, 0x1B03 }, + { 0x00BF, 0x1B04 }, + { 0x0964, 0x1B19 }, + { 0x0965, 0x1B1A }, + { 0x0A59, 0x1B26 }, + { 0x0A5A, 0x1B27 }, + { 0x0A5B, 0x1B2A }, + { 0x0A5C, 0x1B2B }, + { 0x0A5E, 0x1B2C }, + { 0x0A66, 0x1B1C }, + { 0x0A67, 0x1B1D }, + { 0x0A68, 0x1B1E }, + { 0x0A69, 0x1B1F }, + { 0x0A6A, 0x1B20 }, + { 0x0A6B, 0x1B21 }, + { 0x0A6C, 0x1B22 }, + { 0x0A6D, 0x1B23 }, + { 0x0A6E, 0x1B24 }, + { 0x0A6F, 0x1B25 }, + { 0x0A75, 0x1B2D }, + { 0x20AC, 0x1B65 } +}; + +/* Appendix A.2.11. in 3GPP TS23.038 V.8.2.0 */ +static const struct codepoint tam_ext_gsm[] = { + { 0x00, 0x0040 }, + { 0x01, 0x00A3 }, + { 0x02, 0x0024 }, + { 0x03, 0x00A5 }, + { 0x04, 0x00BF }, + { 0x05, 0x0022 }, + { 0x06, 0x00A4 }, + { 0x07, 0x0025 }, + { 0x08, 0x0026 }, + { 0x09, 0x0027 }, + { 0x0A, 0x000C }, /* See NOTE 3 */ + { 0x0B, 0x002A }, + { 0x0C, 0x002B }, + { 0x0E, 0x002D }, + { 0x0F, 0x002F }, + { 0x10, 0x003C }, + { 0x11, 0x003D }, + { 0x12, 0x003E }, + { 0x13, 0x00A1 }, + { 0x14, 0x005E }, + { 0x15, 0x00A1 }, + { 0x16, 0x005F }, + { 0x17, 0x0023 }, + { 0x18, 0x002A }, + { 0x19, 0x0964 }, + { 0x1A, 0x0965 }, + { 0x1B, 0x0020 }, /* See NOTE 1 */ + { 0x1C, 0x0BE6 }, + { 0x1D, 0x0BE7 }, + { 0x1E, 0x0BE8 }, + { 0x1F, 0x0BE9 }, + { 0x20, 0x0BEA }, + { 0x21, 0x0BEB }, + { 0x22, 0x0BEC }, + { 0x23, 0x0BED }, + { 0x24, 0x0BEE }, + { 0x25, 0x0BEF }, + { 0x26, 0x0BF3 }, + { 0x27, 0x0BF4 }, + { 0x28, 0x007B }, + { 0x29, 0x007D }, + { 0x2A, 0x0BF5 }, + { 0x2B, 0x0BF6 }, + { 0x2C, 0x0BF7 }, + { 0x2D, 0x0BF8 }, + { 0x2E, 0x0BFA }, + { 0x2F, 0x005C }, + { 0x3C, 0x005B }, + { 0x3D, 0x007E }, + { 0x3E, 0x005D }, + { 0x40, 0x007C }, + { 0x41, 0x0041 }, + { 0x42, 0x0042 }, + { 0x43, 0x0043 }, + { 0x44, 0x0044 }, + { 0x45, 0x0045 }, + { 0x46, 0x0046 }, + { 0x47, 0x0047 }, + { 0x48, 0x0048 }, + { 0x49, 0x0049 }, + { 0x4A, 0x004A }, + { 0x4B, 0x004B }, + { 0x4C, 0x004C }, + { 0x4D, 0x004D }, + { 0x4E, 0x004E }, + { 0x4F, 0x004F }, + { 0x50, 0x0050 }, + { 0x51, 0x0051 }, + { 0x52, 0x0052 }, + { 0x53, 0x0053 }, + { 0x54, 0x0054 }, + { 0x55, 0x0055 }, + { 0x56, 0x0056 }, + { 0x57, 0x0057 }, + { 0x58, 0x0058 }, + { 0x59, 0x0059 }, + { 0x5A, 0x005A }, + { 0x65, 0x20AC } +}; + +static const struct codepoint tam_ext_unicode[] = { + { 0x000C, 0x1B0A }, + { 0x0022, 0x1B05 }, + { 0x0023, 0x1B17 }, + { 0x0024, 0x1B02 }, + { 0x0025, 0x1B07 }, + { 0x0026, 0x1B08 }, + { 0x0027, 0x1B09 }, + { 0x002A, 0x1B0B }, + { 0x002A, 0x1B18 }, + { 0x002B, 0x1B0C }, + { 0x002D, 0x1B0E }, + { 0x002F, 0x1B0F }, + { 0x003C, 0x1B10 }, + { 0x003D, 0x1B11 }, + { 0x003E, 0x1B12 }, + { 0x0040, 0x1B00 }, + { 0x0041, 0x1B41 }, + { 0x0042, 0x1B42 }, + { 0x0043, 0x1B43 }, + { 0x0044, 0x1B44 }, + { 0x0045, 0x1B45 }, + { 0x0046, 0x1B46 }, + { 0x0047, 0x1B47 }, + { 0x0048, 0x1B48 }, + { 0x0049, 0x1B49 }, + { 0x004A, 0x1B4A }, + { 0x004B, 0x1B4B }, + { 0x004C, 0x1B4C }, + { 0x004D, 0x1B4D }, + { 0x004E, 0x1B4E }, + { 0x004F, 0x1B4F }, + { 0x0050, 0x1B50 }, + { 0x0051, 0x1B51 }, + { 0x0052, 0x1B52 }, + { 0x0053, 0x1B53 }, + { 0x0054, 0x1B54 }, + { 0x0055, 0x1B55 }, + { 0x0056, 0x1B56 }, + { 0x0057, 0x1B57 }, + { 0x0058, 0x1B58 }, + { 0x0059, 0x1B59 }, + { 0x005A, 0x1B5A }, + { 0x005B, 0x1B3C }, + { 0x005C, 0x1B2F }, + { 0x005D, 0x1B3E }, + { 0x005E, 0x1B14 }, + { 0x005F, 0x1B16 }, + { 0x007B, 0x1B28 }, + { 0x007C, 0x1B40 }, + { 0x007D, 0x1B29 }, + { 0x007E, 0x1B3D }, + { 0x00A1, 0x1B13 }, + { 0x00A1, 0x1B15 }, + { 0x00A3, 0x1B01 }, + { 0x00A4, 0x1B06 }, + { 0x00A5, 0x1B03 }, + { 0x00BF, 0x1B04 }, + { 0x0964, 0x1B19 }, + { 0x0965, 0x1B1A }, + { 0x0BE6, 0x1B1C }, + { 0x0BE7, 0x1B1D }, + { 0x0BE8, 0x1B1E }, + { 0x0BE9, 0x1B1F }, + { 0x0BEA, 0x1B20 }, + { 0x0BEB, 0x1B21 }, + { 0x0BEC, 0x1B22 }, + { 0x0BED, 0x1B23 }, + { 0x0BEE, 0x1B24 }, + { 0x0BEF, 0x1B25 }, + { 0x0BF3, 0x1B26 }, + { 0x0BF4, 0x1B27 }, + { 0x0BF5, 0x1B2A }, + { 0x0BF6, 0x1B2B }, + { 0x0BF7, 0x1B2C }, + { 0x0BF8, 0x1B2D }, + { 0x0BFA, 0x1B2E }, + { 0x20AC, 0x1B65 } +}; + +/* Appendix A.2.12. in 3GPP TS23.038 V.8.2.0 */ +static const struct codepoint tel_ext_gsm[] = { + { 0x00, 0x0040 }, + { 0x01, 0x00A3 }, + { 0x02, 0x0024 }, + { 0x03, 0x00A5 }, + { 0x04, 0x00BF }, + { 0x05, 0x0022 }, + { 0x06, 0x00A4 }, + { 0x07, 0x0025 }, + { 0x08, 0x0026 }, + { 0x09, 0x0027 }, + { 0x0A, 0x000C }, /* See NOTE 3 */ + { 0x0B, 0x002A }, + { 0x0C, 0x002B }, + { 0x0E, 0x002D }, + { 0x0F, 0x002F }, + { 0x10, 0x003C }, + { 0x11, 0x003D }, + { 0x12, 0x003E }, + { 0x13, 0x00A1 }, + { 0x14, 0x005E }, + { 0x15, 0x00A1 }, + { 0x16, 0x005F }, + { 0x17, 0x0023 }, + { 0x18, 0x002A }, + { 0x1B, 0x0020 }, /* See NOTE 1 */ + { 0x1C, 0x0C66 }, + { 0x1D, 0x0C67 }, + { 0x1E, 0x0C68 }, + { 0x1F, 0x0C69 }, + { 0x20, 0x0C6A }, + { 0x21, 0x0C6B }, + { 0x22, 0x0C6C }, + { 0x23, 0x0C6D }, + { 0x24, 0x0C6E }, + { 0x25, 0x0C6F }, + { 0x26, 0x0C58 }, + { 0x27, 0x0C59 }, + { 0x28, 0x007B }, + { 0x29, 0x007D }, + { 0x2A, 0x0C78 }, + { 0x2B, 0x0C79 }, + { 0x2C, 0x0C7A }, + { 0x2D, 0x0C7B }, + { 0x2E, 0x0C7C }, + { 0x2F, 0x005C }, + { 0x30, 0x0C7D }, + { 0x31, 0x0C7E }, + { 0x32, 0x0C7F }, + { 0x3C, 0x005B }, + { 0x3D, 0x007E }, + { 0x3E, 0x005D }, + { 0x40, 0x007C }, + { 0x41, 0x0041 }, + { 0x42, 0x0042 }, + { 0x43, 0x0043 }, + { 0x44, 0x0044 }, + { 0x45, 0x0045 }, + { 0x46, 0x0046 }, + { 0x47, 0x0047 }, + { 0x48, 0x0048 }, + { 0x49, 0x0049 }, + { 0x4A, 0x004A }, + { 0x4B, 0x004B }, + { 0x4C, 0x004C }, + { 0x4D, 0x004D }, + { 0x4E, 0x004E }, + { 0x4F, 0x004F }, + { 0x50, 0x0050 }, + { 0x51, 0x0051 }, + { 0x52, 0x0052 }, + { 0x53, 0x0053 }, + { 0x54, 0x0054 }, + { 0x55, 0x0055 }, + { 0x56, 0x0056 }, + { 0x57, 0x0057 }, + { 0x58, 0x0058 }, + { 0x59, 0x0059 }, + { 0x5A, 0x005A } +}; + +static const struct codepoint tel_ext_unicode[] = { + { 0x000C, 0x1B0A }, + { 0x0022, 0x1B05 }, + { 0x0023, 0x1B17 }, + { 0x0024, 0x1B02 }, + { 0x0025, 0x1B07 }, + { 0x0026, 0x1B08 }, + { 0x0027, 0x1B09 }, + { 0x002A, 0x1B0B }, + { 0x002A, 0x1B18 }, + { 0x002B, 0x1B0C }, + { 0x002D, 0x1B0E }, + { 0x002F, 0x1B0F }, + { 0x003C, 0x1B10 }, + { 0x003D, 0x1B11 }, + { 0x003E, 0x1B12 }, + { 0x0040, 0x1B00 }, + { 0x0041, 0x1B41 }, + { 0x0042, 0x1B42 }, + { 0x0043, 0x1B43 }, + { 0x0044, 0x1B44 }, + { 0x0045, 0x1B45 }, + { 0x0046, 0x1B46 }, + { 0x0047, 0x1B47 }, + { 0x0048, 0x1B48 }, + { 0x0049, 0x1B49 }, + { 0x004A, 0x1B4A }, + { 0x004B, 0x1B4B }, + { 0x004C, 0x1B4C }, + { 0x004D, 0x1B4D }, + { 0x004E, 0x1B4E }, + { 0x004F, 0x1B4F }, + { 0x0050, 0x1B50 }, + { 0x0051, 0x1B51 }, + { 0x0052, 0x1B52 }, + { 0x0053, 0x1B53 }, + { 0x0054, 0x1B54 }, + { 0x0055, 0x1B55 }, + { 0x0056, 0x1B56 }, + { 0x0057, 0x1B57 }, + { 0x0058, 0x1B58 }, + { 0x0059, 0x1B59 }, + { 0x005A, 0x1B5A }, + { 0x005B, 0x1B3C }, + { 0x005C, 0x1B2F }, + { 0x005D, 0x1B3E }, + { 0x005E, 0x1B14 }, + { 0x005F, 0x1B16 }, + { 0x007B, 0x1B28 }, + { 0x007C, 0x1B40 }, + { 0x007D, 0x1B29 }, + { 0x007E, 0x1B3D }, + { 0x00A1, 0x1B13 }, + { 0x00A1, 0x1B15 }, + { 0x00A3, 0x1B01 }, + { 0x00A4, 0x1B06 }, + { 0x00A5, 0x1B03 }, + { 0x00BF, 0x1B04 }, + { 0x0C58, 0x1B26 }, + { 0x0C59, 0x1B27 }, + { 0x0C66, 0x1B1C }, + { 0x0C67, 0x1B1D }, + { 0x0C68, 0x1B1E }, + { 0x0C69, 0x1B1F }, + { 0x0C6A, 0x1B20 }, + { 0x0C6B, 0x1B21 }, + { 0x0C6C, 0x1B22 }, + { 0x0C6D, 0x1B23 }, + { 0x0C6E, 0x1B24 }, + { 0x0C6F, 0x1B25 }, + { 0x0C78, 0x1B2A }, + { 0x0C79, 0x1B2B }, + { 0x0C7A, 0x1B2C }, + { 0x0C7B, 0x1B2D }, + { 0x0C7C, 0x1B2E }, + { 0x0C7D, 0x1B30 }, + { 0x0C7E, 0x1B31 }, + { 0x0C7F, 0x1B32 } +}; + +/* Appendix A.2.13. in 3GPP TS23.038 V.8.2.0 */ +static const struct codepoint urd_ext_gsm[] = { + { 0x00, 0x0040 }, + { 0x01, 0x00A3 }, + { 0x02, 0x0024 }, + { 0x03, 0x00A5 }, + { 0x04, 0x00BF }, + { 0x05, 0x0022 }, + { 0x06, 0x00A4 }, + { 0x07, 0x0025 }, + { 0x08, 0x0026 }, + { 0x09, 0x0027 }, + { 0x0A, 0x000C }, /* See NOTE 3 */ + { 0x0B, 0x002A }, + { 0x0C, 0x002B }, + { 0x0E, 0x002D }, + { 0x0F, 0x002F }, + { 0x10, 0x003C }, + { 0x11, 0x003D }, + { 0x12, 0x003E }, + { 0x13, 0x00A1 }, + { 0x14, 0x005E }, + { 0x15, 0x00A1 }, + { 0x16, 0x005F }, + { 0x17, 0x0023 }, + { 0x18, 0x002A }, + { 0x19, 0x0600 }, + { 0x1A, 0x0601 }, + { 0x1B, 0x0020 }, /* See NOTE 1 */ + { 0x1C, 0x06F0 }, + { 0x1D, 0x06F1 }, + { 0x1E, 0x06F2 }, + { 0x1F, 0x06F3 }, + { 0x20, 0x06F4 }, + { 0x21, 0x06F5 }, + { 0x22, 0x06F6 }, + { 0x23, 0x06F7 }, + { 0x24, 0x06F8 }, + { 0x25, 0x06F9 }, + { 0x26, 0x060C }, + { 0x27, 0x060D }, + { 0x28, 0x007B }, + { 0x29, 0x007D }, + { 0x2A, 0x060E }, + { 0x2B, 0x060F }, + { 0x2C, 0x0610 }, + { 0x2D, 0x0611 }, + { 0x2E, 0x0612 }, + { 0x2F, 0x005C }, + { 0x30, 0x0613 }, + { 0x31, 0x0614 }, + { 0x32, 0x061B }, + { 0x33, 0x061F }, + { 0x34, 0x0640 }, + { 0x35, 0x0652 }, + { 0x36, 0x0658 }, + { 0x37, 0x066B }, + { 0x38, 0x066C }, + { 0x39, 0x0672 }, + { 0x3A, 0x0673 }, + { 0x3B, 0x06CD }, + { 0x3C, 0x005B }, + { 0x3D, 0x007E }, + { 0x3E, 0x005D }, + { 0x3F, 0x06D4 }, + { 0x40, 0x007C }, + { 0x41, 0x0041 }, + { 0x42, 0x0042 }, + { 0x43, 0x0043 }, + { 0x44, 0x0044 }, + { 0x45, 0x0045 }, + { 0x46, 0x0046 }, + { 0x47, 0x0047 }, + { 0x48, 0x0048 }, + { 0x49, 0x0049 }, + { 0x4A, 0x004A }, + { 0x4B, 0x004B }, + { 0x4C, 0x004C }, + { 0x4D, 0x004D }, + { 0x4E, 0x004E }, + { 0x4F, 0x004F }, + { 0x50, 0x0050 }, + { 0x51, 0x0051 }, + { 0x52, 0x0052 }, + { 0x53, 0x0053 }, + { 0x54, 0x0054 }, + { 0x55, 0x0055 }, + { 0x56, 0x0056 }, + { 0x57, 0x0057 }, + { 0x58, 0x0058 }, + { 0x59, 0x0059 }, + { 0x5A, 0x005A }, + { 0x65, 0x20AC } +}; + +static const struct codepoint urd_ext_unicode[] = { + { 0x000C, 0x1B0A }, + { 0x0022, 0x1B05 }, + { 0x0023, 0x1B17 }, + { 0x0024, 0x1B02 }, + { 0x0025, 0x1B07 }, + { 0x0026, 0x1B08 }, + { 0x0027, 0x1B09 }, + { 0x002A, 0x1B0B }, + { 0x002A, 0x1B18 }, + { 0x002B, 0x1B0C }, + { 0x002D, 0x1B0E }, + { 0x002F, 0x1B0F }, + { 0x003C, 0x1B10 }, + { 0x003D, 0x1B11 }, + { 0x003E, 0x1B12 }, + { 0x0040, 0x1B00 }, + { 0x0041, 0x1B41 }, + { 0x0042, 0x1B42 }, + { 0x0043, 0x1B43 }, + { 0x0044, 0x1B44 }, + { 0x0045, 0x1B45 }, + { 0x0046, 0x1B46 }, + { 0x0047, 0x1B47 }, + { 0x0048, 0x1B48 }, + { 0x0049, 0x1B49 }, + { 0x004A, 0x1B4A }, + { 0x004B, 0x1B4B }, + { 0x004C, 0x1B4C }, + { 0x004D, 0x1B4D }, + { 0x004E, 0x1B4E }, + { 0x004F, 0x1B4F }, + { 0x0050, 0x1B50 }, + { 0x0051, 0x1B51 }, + { 0x0052, 0x1B52 }, + { 0x0053, 0x1B53 }, + { 0x0054, 0x1B54 }, + { 0x0055, 0x1B55 }, + { 0x0056, 0x1B56 }, + { 0x0057, 0x1B57 }, + { 0x0058, 0x1B58 }, + { 0x0059, 0x1B59 }, + { 0x005A, 0x1B5A }, + { 0x005B, 0x1B3C }, + { 0x005C, 0x1B2F }, + { 0x005D, 0x1B3E }, + { 0x005E, 0x1B14 }, + { 0x005F, 0x1B16 }, + { 0x007B, 0x1B28 }, + { 0x007C, 0x1B40 }, + { 0x007D, 0x1B29 }, + { 0x007E, 0x1B3D }, + { 0x00A1, 0x1B13 }, + { 0x00A1, 0x1B15 }, + { 0x00A3, 0x1B01 }, + { 0x00A4, 0x1B06 }, + { 0x00A5, 0x1B03 }, + { 0x00BF, 0x1B04 }, + { 0x0600, 0x1B19 }, + { 0x0601, 0x1B1A }, + { 0x060C, 0x1B26 }, + { 0x060D, 0x1B27 }, + { 0x060E, 0x1B2A }, + { 0x060F, 0x1B2B }, + { 0x0610, 0x1B2C }, + { 0x0611, 0x1B2D }, + { 0x0612, 0x1B2E }, + { 0x0613, 0x1B30 }, + { 0x0614, 0x1B31 }, + { 0x061B, 0x1B32 }, + { 0x061F, 0x1B33 }, + { 0x0640, 0x1B34 }, + { 0x0652, 0x1B35 }, + { 0x0658, 0x1B36 }, + { 0x066B, 0x1B37 }, + { 0x066C, 0x1B38 }, + { 0x0672, 0x1B39 }, + { 0x0673, 0x1B3A }, + { 0x06CD, 0x1B3B }, + { 0x06D4, 0x1B3F }, + { 0x06F0, 0x1B1C }, + { 0x06F1, 0x1B1D }, + { 0x06F2, 0x1B1E }, + { 0x06F3, 0x1B1F }, + { 0x06F4, 0x1B20 }, + { 0x06F5, 0x1B21 }, + { 0x06F6, 0x1B22 }, + { 0x06F7, 0x1B23 }, + { 0x06F8, 0x1B24 }, + { 0x06F9, 0x1B25 }, + { 0x20AC, 0x1B65 } +}; + /* Used for conversion of GSM to Unicode */ static const unsigned short def_gsm[] = { 0x0040, 0x00A3, 0x0024, 0x00A5, 0x00E8, 0x00E9, 0x00F9, 0x00EC, @@ -880,6 +2220,429 @@ static const struct codepoint guj_unicode[] = { { 0x0AF1, 0x7F } }; +/* Appendix A.3.6 in 3GPP TS23.038 */ +static const unsigned short hin_gsm[] = { + 0x0901, 0x0902, 0x0903, 0x0905, 0x0906, 0x0907, 0x0908, 0x0909, + 0x090A, 0x090B, 0x000A, 0x090C, 0x090D, 0x000D, 0x090E, 0x090F, + 0x0910, 0x0911, 0x0912, 0x0913, 0x0914, 0x0915, 0x0916, 0x0917, + 0x0918, 0x0919, 0x091A, 0x00A0, 0x091B, 0x091C, 0x091D, 0x091E, + 0x0020, 0x0021, 0x091F, 0x0920, 0x0921, 0x0922, 0x0923, 0x0924, + 0x0029, 0x0028, 0x0925, 0x0926, 0x002C, 0x0927, 0x002E, 0x0928, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, + 0x0038, 0x0039, 0x003A, 0x003B, 0x0929, 0x092A, 0x092B, 0x003F, + 0x092C, 0x092D, 0x092E, 0x092F, 0x0930, 0x0931, 0x0932, 0x0933, + 0x0934, 0x0935, 0x0936, 0x0937, 0x0938, 0x0939, 0x093C, 0x093D, + 0x093E, 0x093F, 0x0940, 0x0941, 0x0942, 0x0943, 0x0944, 0x0945, + 0x0946, 0x0947, 0x0948, 0x0949, 0x094A, 0x094B, 0x094C, 0x094D, + 0x0950, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, + 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, + 0x0078, 0x0079, 0x007A, 0x0972, 0x097B, 0x097C, 0x097E, 0x097F +}; + +static const struct codepoint hin_unicode[] = { + { 0x000A, 0x0A }, { 0x000D, 0x0D }, { 0x0020, 0x20 }, { 0x0021, 0x21 }, + { 0x0028, 0x29 }, { 0x0029, 0x28 }, { 0x002C, 0x2C }, { 0x002E, 0x2E }, + { 0x0030, 0x30 }, { 0x0031, 0x31 }, { 0x0032, 0x32 }, { 0x0033, 0x33 }, + { 0x0034, 0x34 }, { 0x0035, 0x35 }, { 0x0036, 0x36 }, { 0x0037, 0x37 }, + { 0x0038, 0x38 }, { 0x0039, 0x39 }, { 0x003A, 0x3A }, { 0x003B, 0x3B }, + { 0x003F, 0x3F }, { 0x0061, 0x61 }, { 0x0062, 0x62 }, { 0x0063, 0x63 }, + { 0x0064, 0x64 }, { 0x0065, 0x65 }, { 0x0066, 0x66 }, { 0x0067, 0x67 }, + { 0x0068, 0x68 }, { 0x0069, 0x69 }, { 0x006A, 0x6A }, { 0x006B, 0x6B }, + { 0x006C, 0x6C }, { 0x006D, 0x6D }, { 0x006E, 0x6E }, { 0x006F, 0x6F }, + { 0x0070, 0x70 }, { 0x0071, 0x71 }, { 0x0072, 0x72 }, { 0x0073, 0x73 }, + { 0x0074, 0x74 }, { 0x0075, 0x75 }, { 0x0076, 0x76 }, { 0x0077, 0x77 }, + { 0x0078, 0x78 }, { 0x0079, 0x79 }, { 0x007A, 0x7A }, { 0x00A0, 0x20 }, + { 0x0901, 0x00 }, { 0x0902, 0x01 }, { 0x0903, 0x02 }, { 0x0905, 0x03 }, + { 0x0906, 0x04 }, { 0x0907, 0x05 }, { 0x0908, 0x06 }, { 0x0909, 0x07 }, + { 0x090A, 0x08 }, { 0x090B, 0x09 }, { 0x090C, 0x0B }, { 0x090D, 0x0C }, + { 0x090E, 0x0E }, { 0x090F, 0x0F }, { 0x0910, 0x10 }, { 0x0911, 0x11 }, + { 0x0912, 0x12 }, { 0x0913, 0x13 }, { 0x0914, 0x14 }, { 0x0915, 0x15 }, + { 0x0916, 0x16 }, { 0x0917, 0x17 }, { 0x0918, 0x18 }, { 0x0919, 0x19 }, + { 0x091A, 0x1A }, { 0x091B, 0x1C }, { 0x091C, 0x1D }, { 0x091D, 0x1E }, + { 0x091E, 0x1F }, { 0x091F, 0x22 }, { 0x0920, 0x23 }, { 0x0921, 0x24 }, + { 0x0922, 0x25 }, { 0x0923, 0x26 }, { 0x0924, 0x27 }, { 0x0925, 0x2A }, + { 0x0926, 0x2B }, { 0x0927, 0x2D }, { 0x0928, 0x2F }, { 0x0929, 0x3C }, + { 0x092A, 0x3D }, { 0x092B, 0x3E }, { 0x092C, 0x40 }, { 0x092D, 0x41 }, + { 0x092E, 0x42 }, { 0x092F, 0x43 }, { 0x0930, 0x44 }, { 0x0931, 0x45 }, + { 0x0932, 0x46 }, { 0x0933, 0x47 }, { 0x0934, 0x48 }, { 0x0935, 0x49 }, + { 0x0936, 0x4A }, { 0x0937, 0x4B }, { 0x0938, 0x4C }, { 0x0939, 0x4D }, + { 0x093C, 0x4E }, { 0x093D, 0x4F }, { 0x093E, 0x50 }, { 0x093F, 0x51 }, + { 0x0940, 0x52 }, { 0x0941, 0x53 }, { 0x0942, 0x54 }, { 0x0943, 0x55 }, + { 0x0944, 0x56 }, { 0x0945, 0x57 }, { 0x0946, 0x58 }, { 0x0947, 0x59 }, + { 0x0948, 0x5A }, { 0x0949, 0x5B }, { 0x094A, 0x5C }, { 0x094B, 0x5D }, + { 0x094C, 0x5E }, { 0x094D, 0x5F }, { 0x0950, 0x60 }, { 0x0972, 0x7B }, + { 0x097B, 0x7C }, { 0x097C, 0x7D }, { 0x097E, 0x7E }, { 0x097F, 0x7F } +}; + +/* Appendix A.3.7 in 3GPP TS23.038 */ +static const unsigned short kan_gsm[] = { + 0x0020, 0x0C82, 0x0C83, 0x0C85, 0x0C86, 0x0C87, 0x0C88, 0x0C89, + 0x0C8A, 0x0C8B, 0x000A, 0x0C8C, 0x0020, 0x000D, 0x0C8E, 0x0C8F, + 0x0C90, 0x0020, 0x0C92, 0x0C93, 0x0C94, 0x0C95, 0x0C96, 0x0C97, + 0x0C98, 0x0C99, 0x0C9A, 0x00A0, 0x0C9B, 0x0C9C, 0x0C9D, 0x0C9E, + 0x0020, 0x0021, 0x0C9F, 0x0CA0, 0x0CAA, 0x0CA2, 0x0CA3, 0x0CA4, + 0x0029, 0x0028, 0x0CA5, 0x0CA6, 0x002C, 0x0CA7, 0x002E, 0x0CA8, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, + 0x0038, 0x0039, 0x003A, 0x003B, 0x0020, 0x0CAA, 0x0CAB, 0x003F, + 0x0CAC, 0x0CAD, 0x0CAE, 0x0CAF, 0x0CB0, 0x0CB1, 0x0CB2, 0x0CB3, + 0x0020, 0x0CB5, 0x0CB6, 0x0CB7, 0x0CB8, 0x0CB9, 0x0CBC, 0x0CBD, + 0x0CBE, 0x0CBF, 0x0CC0, 0x0CC1, 0x0CC2, 0x0CC3, 0x0CC4, 0x0020, + 0x0CC6, 0x0CC7, 0x0CC8, 0x0020, 0x0CCA, 0x0CCB, 0x0CCC, 0x0CCD, + 0x0CD5, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, + 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, + 0x0078, 0x0079, 0x007A, 0x0CD6, 0x0CE0, 0x0CE1, 0x0CE2, 0x0CE3 +}; + +static const struct codepoint kan_unicode[] = { + { 0x000A, 0x0A }, { 0x000D, 0x0D }, { 0x0020, 0x20 }, { 0x0021, 0x21 }, + { 0x0028, 0x29 }, { 0x0029, 0x28 }, { 0x002C, 0x2C }, { 0x002E, 0x2E }, + { 0x0030, 0x30 }, { 0x0031, 0x31 }, { 0x0032, 0x32 }, { 0x0033, 0x33 }, + { 0x0034, 0x34 }, { 0x0035, 0x35 }, { 0x0036, 0x36 }, { 0x0037, 0x37 }, + { 0x0038, 0x38 }, { 0x0039, 0x39 }, { 0x003A, 0x3A }, { 0x003B, 0x3B }, + { 0x003F, 0x3F }, { 0x0061, 0x61 }, { 0x0062, 0x62 }, { 0x0063, 0x63 }, + { 0x0064, 0x64 }, { 0x0065, 0x65 }, { 0x0066, 0x66 }, { 0x0067, 0x67 }, + { 0x0068, 0x68 }, { 0x0069, 0x69 }, { 0x006A, 0x6A }, { 0x006B, 0x6B }, + { 0x006C, 0x6C }, { 0x006D, 0x6D }, { 0x006E, 0x6E }, { 0x006F, 0x6F }, + { 0x0070, 0x70 }, { 0x0071, 0x71 }, { 0x0072, 0x72 }, { 0x0073, 0x73 }, + { 0x0074, 0x74 }, { 0x0075, 0x75 }, { 0x0076, 0x76 }, { 0x0077, 0x77 }, + { 0x0078, 0x78 }, { 0x0079, 0x79 }, { 0x007A, 0x7A }, { 0x00A0, 0x20 }, + { 0x0C82, 0x01 }, { 0x0C83, 0x02 }, { 0x0C85, 0x03 }, { 0x0C86, 0x04 }, + { 0x0C87, 0x05 }, { 0x0C88, 0x06 }, { 0x0C89, 0x07 }, { 0x0C8A, 0x08 }, + { 0x0C8B, 0x09 }, { 0x0C8C, 0x0B }, { 0x0C8E, 0x0E }, { 0x0C8F, 0x0F }, + { 0x0C90, 0x10 }, { 0x0C92, 0x12 }, { 0x0C93, 0x13 }, { 0x0C94, 0x14 }, + { 0x0C95, 0x15 }, { 0x0C96, 0x16 }, { 0x0C97, 0x17 }, { 0x0C98, 0x18 }, + { 0x0C99, 0x19 }, { 0x0C9A, 0x1A }, { 0x0C9B, 0x1C }, { 0x0C9C, 0x1D }, + { 0x0C9D, 0x1E }, { 0x0C9E, 0x1F }, { 0x0C9F, 0x22 }, { 0x0CA0, 0x23 }, + { 0x0CA2, 0x25 }, { 0x0CA3, 0x26 }, { 0x0CA4, 0x27 }, { 0x0CA5, 0x2A }, + { 0x0CA6, 0x2B }, { 0x0CA7, 0x2D }, { 0x0CA8, 0x2F }, { 0x0CAA, 0x3D }, + { 0x0CAB, 0x3E }, { 0x0CAC, 0x40 }, { 0x0CAD, 0x41 }, { 0x0CAE, 0x42 }, + { 0x0CAF, 0x43 }, { 0x0CB0, 0x44 }, { 0x0CB1, 0x45 }, { 0x0CB2, 0x46 }, + { 0x0CB3, 0x47 }, { 0x0CB5, 0x49 }, { 0x0CB6, 0x4A }, { 0x0CB7, 0x4B }, + { 0x0CB8, 0x4C }, { 0x0CB9, 0x4D }, { 0x0CBC, 0x4E }, { 0x0CBD, 0x4F }, + { 0x0CBE, 0x50 }, { 0x0CBF, 0x51 }, { 0x0CC0, 0x52 }, { 0x0CC1, 0x53 }, + { 0x0CC2, 0x54 }, { 0x0CC3, 0x55 }, { 0x0CC4, 0x56 }, { 0x0CC6, 0x58 }, + { 0x0CC7, 0x59 }, { 0x0CC8, 0x5A }, { 0x0CCA, 0x5C }, { 0x0CCB, 0x5D }, + { 0x0CCC, 0x5E }, { 0x0CCD, 0x5F }, { 0x0CD5, 0x60 }, { 0x0CD6, 0x7B }, + { 0x0CE0, 0x7C }, { 0x0CE1, 0x7D }, { 0x0CE2, 0x7E }, { 0x0CE3, 0x7F } +}; + +/* Appendix A.3.8 in 3GPP TS23.038 */ +static const unsigned short mal_gsm[] = { + 0x0020, 0x0D02, 0x0D03, 0x0D05, 0x0D06, 0x0D07, 0x0D08, 0x0D09, + 0x0D0A, 0x0D0B, 0x000A, 0x0D0C, 0x0020, 0x000D, 0x0D0E, 0x0D0F, + 0x0D10, 0x0020, 0x0D12, 0x0D13, 0x0D14, 0x0D15, 0x0D16, 0x0D17, + 0x0D18, 0x0D19, 0x0D1A, 0x00A0, 0x0D1B, 0x0D1C, 0x0D1D, 0x0D1E, + 0x0020, 0x0021, 0x0D1F, 0x0D20, 0x0D21, 0x0D22, 0x0D23, 0x0D24, + 0x0029, 0x0028, 0x0D25, 0x0D26, 0x002C, 0x0D27, 0x002C, 0x0D28, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, + 0x0038, 0x0039, 0x003A, 0x003B, 0x0020, 0x0D2A, 0x0D2B, 0x003F, + 0x0D2C, 0x0D2D, 0x0D2E, 0x0D2F, 0x0D30, 0x0D31, 0x0D32, 0x0D33, + 0x0D34, 0x0D35, 0x0D36, 0x0D37, 0x0D38, 0x0D39, 0x0020, 0x0D3D, + 0x0D3E, 0x0D3F, 0x0D40, 0x0D41, 0x0D42, 0x0D43, 0x0D44, 0x0020, + 0x0D46, 0x0D47, 0x0D48, 0x0020, 0x0D4A, 0x0D4B, 0x0D4C, 0x0D4D, + 0x0D57, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, + 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, + 0x0078, 0x0079, 0x007A, 0x0D60, 0x0D61, 0x0D62, 0x0D63, 0x0D79 +}; + +static const struct codepoint mal_unicode[] = { + { 0x000A, 0x0A }, { 0x000D, 0x0D }, { 0x0020, 0x20 }, { 0x0021, 0x21 }, + { 0x0028, 0x29 }, { 0x0029, 0x28 }, { 0x002C, 0x2E }, { 0x0030, 0x30 }, + { 0x0031, 0x31 }, { 0x0032, 0x32 }, { 0x0033, 0x33 }, { 0x0034, 0x34 }, + { 0x0035, 0x35 }, { 0x0036, 0x36 }, { 0x0037, 0x37 }, { 0x0038, 0x38 }, + { 0x0039, 0x39 }, { 0x003A, 0x3A }, { 0x003B, 0x3B }, { 0x003F, 0x3F }, + { 0x0061, 0x61 }, { 0x0062, 0x62 }, { 0x0063, 0x63 }, { 0x0064, 0x64 }, + { 0x0065, 0x65 }, { 0x0066, 0x66 }, { 0x0067, 0x67 }, { 0x0068, 0x68 }, + { 0x0069, 0x69 }, { 0x006A, 0x6A }, { 0x006B, 0x6B }, { 0x006C, 0x6C }, + { 0x006D, 0x6D }, { 0x006E, 0x6E }, { 0x006F, 0x6F }, { 0x0070, 0x70 }, + { 0x0071, 0x71 }, { 0x0072, 0x72 }, { 0x0073, 0x73 }, { 0x0074, 0x74 }, + { 0x0075, 0x75 }, { 0x0076, 0x76 }, { 0x0077, 0x77 }, { 0x0078, 0x78 }, + { 0x0079, 0x79 }, { 0x007A, 0x7A }, { 0x00A0, 0x20 }, { 0x0D02, 0x01 }, + { 0x0D03, 0x02 }, { 0x0D05, 0x03 }, { 0x0D06, 0x04 }, { 0x0D07, 0x05 }, + { 0x0D08, 0x06 }, { 0x0D09, 0x07 }, { 0x0D0A, 0x08 }, { 0x0D0B, 0x09 }, + { 0x0D0C, 0x0B }, { 0x0D0E, 0x0E }, { 0x0D0F, 0x0F }, { 0x0D10, 0x10 }, + { 0x0D12, 0x12 }, { 0x0D13, 0x13 }, { 0x0D14, 0x14 }, { 0x0D15, 0x15 }, + { 0x0D16, 0x16 }, { 0x0D17, 0x17 }, { 0x0D18, 0x18 }, { 0x0D19, 0x19 }, + { 0x0D1A, 0x1A }, { 0x0D1B, 0x1C }, { 0x0D1C, 0x1D }, { 0x0D1D, 0x1E }, + { 0x0D1E, 0x1F }, { 0x0D1F, 0x22 }, { 0x0D20, 0x23 }, { 0x0D21, 0x24 }, + { 0x0D22, 0x25 }, { 0x0D23, 0x26 }, { 0x0D24, 0x27 }, { 0x0D25, 0x2A }, + { 0x0D26, 0x2B }, { 0x0D27, 0x2D }, { 0x0D28, 0x2F }, { 0x0D2A, 0x3D }, + { 0x0D2B, 0x3E }, { 0x0D2C, 0x40 }, { 0x0D2D, 0x41 }, { 0x0D2E, 0x42 }, + { 0x0D2F, 0x43 }, { 0x0D30, 0x44 }, { 0x0D31, 0x45 }, { 0x0D32, 0x46 }, + { 0x0D33, 0x47 }, { 0x0D34, 0x48 }, { 0x0D35, 0x49 }, { 0x0D36, 0x4A }, + { 0x0D37, 0x4B }, { 0x0D38, 0x4C }, { 0x0D39, 0x4D }, { 0x0D3D, 0x4F }, + { 0x0D3E, 0x50 }, { 0x0D3F, 0x51 }, { 0x0D40, 0x52 }, { 0x0D41, 0x53 }, + { 0x0D42, 0x54 }, { 0x0D43, 0x55 }, { 0x0D44, 0x56 }, { 0x0D46, 0x58 }, + { 0x0D47, 0x59 }, { 0x0D48, 0x5A }, { 0x0D4A, 0x5C }, { 0x0D4B, 0x5D }, + { 0x0D4C, 0x5E }, { 0x0D4D, 0x5F }, { 0x0D57, 0x60 }, { 0x0D60, 0x7B }, + { 0x0D61, 0x7C }, { 0x0D62, 0x7D }, { 0x0D63, 0x7E }, { 0x0D79, 0x7F } +}; + +/* Appendix A.3.9 in 3GPP TS23.038 */ +static const unsigned short ori_gsm[] = { + 0x0B01, 0x0B02, 0x0B03, 0x0B05, 0x0B06, 0x0B07, 0x0B08, 0x0B09, + 0x0B0A, 0x0B0B, 0x000A, 0x0B0C, 0x0020, 0x000D, 0x0020, 0x0B0F, + 0x0B10, 0x0020, 0x0020, 0x0B13, 0x0B14, 0x0B15, 0x0B16, 0x0B17, + 0x0B18, 0x0B19, 0x0B1A, 0x00A0, 0x0B1B, 0x0B1C, 0x0B1D, 0x0B1E, + 0x0020, 0x0021, 0x0B1F, 0x0B20, 0x0B21, 0x0B22, 0x0B23, 0x0B24, + 0x0029, 0x0028, 0x0B25, 0x0B26, 0x002C, 0x0B27, 0x002E, 0x0B28, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, + 0x0038, 0x0039, 0x003A, 0x003B, 0x0020, 0x0B2A, 0x0B2B, 0x003F, + 0x0B2C, 0x0B2D, 0x0B2E, 0x0B2F, 0x0B30, 0x0020, 0x0B32, 0x0B33, + 0x0020, 0x0B35, 0x0B36, 0x0B37, 0x0B38, 0x0B39, 0x0B3C, 0x0B3D, + 0x0B3E, 0x0B3F, 0x0B40, 0x0B41, 0x0B42, 0x0B43, 0x0B44, 0x0020, + 0x0020, 0x0B47, 0x0B48, 0x0020, 0x0020, 0x0B4B, 0x0B4C, 0x0B4D, + 0x0B56, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, + 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, + 0x0078, 0x0079, 0x007A, 0x0B57, 0x0B60, 0x0B61, 0x0B62, 0x0B63 +}; + +static const struct codepoint ori_unicode[] = { + { 0x000A, 0x0A }, { 0x000D, 0x0D }, { 0x0020, 0x20 }, { 0x0021, 0x21 }, + { 0x0028, 0x29 }, { 0x0029, 0x28 }, { 0x002C, 0x2C }, { 0x002E, 0x2E }, + { 0x0030, 0x30 }, { 0x0031, 0x31 }, { 0x0032, 0x32 }, { 0x0033, 0x33 }, + { 0x0034, 0x34 }, { 0x0035, 0x35 }, { 0x0036, 0x36 }, { 0x0037, 0x37 }, + { 0x0038, 0x38 }, { 0x0039, 0x39 }, { 0x003A, 0x3A }, { 0x003B, 0x3B }, + { 0x003F, 0x3F }, { 0x0061, 0x61 }, { 0x0062, 0x62 }, { 0x0063, 0x63 }, + { 0x0064, 0x64 }, { 0x0065, 0x65 }, { 0x0066, 0x66 }, { 0x0067, 0x67 }, + { 0x0068, 0x68 }, { 0x0069, 0x69 }, { 0x006A, 0x6A }, { 0x006B, 0x6B }, + { 0x006C, 0x6C }, { 0x006D, 0x6D }, { 0x006E, 0x6E }, { 0x006F, 0x6F }, + { 0x0070, 0x70 }, { 0x0071, 0x71 }, { 0x0072, 0x72 }, { 0x0073, 0x73 }, + { 0x0074, 0x74 }, { 0x0075, 0x75 }, { 0x0076, 0x76 }, { 0x0077, 0x77 }, + { 0x0078, 0x78 }, { 0x0079, 0x79 }, { 0x007A, 0x7A }, { 0x00A0, 0x20 }, + { 0x0B01, 0x00 }, { 0x0B02, 0x01 }, { 0x0B03, 0x02 }, { 0x0B05, 0x03 }, + { 0x0B06, 0x04 }, { 0x0B07, 0x05 }, { 0x0B08, 0x06 }, { 0x0B09, 0x07 }, + { 0x0B0A, 0x08 }, { 0x0B0B, 0x09 }, { 0x0B0C, 0x0B }, { 0x0B0F, 0x0F }, + { 0x0B10, 0x10 }, { 0x0B13, 0x13 }, { 0x0B14, 0x14 }, { 0x0B15, 0x15 }, + { 0x0B16, 0x16 }, { 0x0B17, 0x17 }, { 0x0B18, 0x18 }, { 0x0B19, 0x19 }, + { 0x0B1A, 0x1A }, { 0x0B1B, 0x1C }, { 0x0B1C, 0x1D }, { 0x0B1D, 0x1E }, + { 0x0B1E, 0x1F }, { 0x0B1F, 0x22 }, { 0x0B20, 0x23 }, { 0x0B21, 0x24 }, + { 0x0B22, 0x25 }, { 0x0B23, 0x26 }, { 0x0B24, 0x27 }, { 0x0B25, 0x2A }, + { 0x0B26, 0x2B }, { 0x0B27, 0x2D }, { 0x0B28, 0x2F }, { 0x0B2A, 0x3D }, + { 0x0B2B, 0x3E }, { 0x0B2C, 0x40 }, { 0x0B2D, 0x41 }, { 0x0B2E, 0x42 }, + { 0x0B2F, 0x43 }, { 0x0B30, 0x44 }, { 0x0B32, 0x46 }, { 0x0B33, 0x47 }, + { 0x0B35, 0x49 }, { 0x0B36, 0x4A }, { 0x0B37, 0x4B }, { 0x0B38, 0x4C }, + { 0x0B39, 0x4D }, { 0x0B3C, 0x4E }, { 0x0B3D, 0x4F }, { 0x0B3E, 0x50 }, + { 0x0B3F, 0x51 }, { 0x0B40, 0x52 }, { 0x0B41, 0x53 }, { 0x0B42, 0x54 }, + { 0x0B43, 0x55 }, { 0x0B44, 0x56 }, { 0x0B47, 0x59 }, { 0x0B48, 0x5A }, + { 0x0B4B, 0x5D }, { 0x0B4C, 0x5E }, { 0x0B4D, 0x5F }, { 0x0B56, 0x60 }, + { 0x0B57, 0x7B }, { 0x0B60, 0x7C }, { 0x0B61, 0x7D }, { 0x0B62, 0x7E }, + { 0x0B63, 0x7F } +}; + +/* Appendix A.3.10 in 3GPP TS23.038 */ +static const unsigned short pun_gsm[] = { + 0x0A01, 0x0A02, 0x0A03, 0x0A05, 0x0A06, 0x0A07, 0x0A08, 0x0A09, + 0x0A0A, 0x0020, 0x000A, 0x0020, 0x0020, 0x000D, 0x0020, 0x0A0F, + 0x0A10, 0x0020, 0x0020, 0x0A13, 0x0A14, 0x0A15, 0x0A16, 0x0A17, + 0x0A18, 0x0A19, 0x0A1A, 0x00A0, 0x0A1B, 0x0A1C, 0x0A1D, 0x0A1E, + 0x0020, 0x0021, 0x0A1F, 0x0A20, 0x0A21, 0x0A22, 0x0A23, 0x0A24, + 0x0029, 0x0028, 0x0A25, 0x0A26, 0x002C, 0x0A27, 0x002E, 0x0A28, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, + 0x0038, 0x0039, 0x003A, 0x003B, 0x0020, 0x0A2A, 0x0A2B, 0x003F, + 0x0A2C, 0x0A2D, 0x0A2E, 0x0A2F, 0x0A30, 0x0020, 0x0A32, 0x0A33, + 0x0020, 0x0A35, 0x0A36, 0x0020, 0x0A38, 0x0A39, 0x0A3C, 0x0020, + 0x0A3E, 0x0A3F, 0x0A40, 0x0A41, 0x0A42, 0x0020, 0x0020, 0x0020, + 0x0020, 0x0A47, 0x0A48, 0x0020, 0x0020, 0x0A4B, 0x0A4C, 0x0A4D, + 0x0A51, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, + 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, + 0x0078, 0x0079, 0x007A, 0x0A70, 0x0A71, 0x0A72, 0x0A73, 0x0A74 +}; + +static const struct codepoint pun_unicode[] = { + { 0x000A, 0x0A }, { 0x000D, 0x0D }, { 0x0020, 0x20 }, { 0x0021, 0x21 }, + { 0x0028, 0x29 }, { 0x0029, 0x28 }, { 0x002C, 0x2C }, { 0x002E, 0x2E }, + { 0x0030, 0x30 }, { 0x0031, 0x31 }, { 0x0032, 0x32 }, { 0x0033, 0x33 }, + { 0x0034, 0x34 }, { 0x0035, 0x35 }, { 0x0036, 0x36 }, { 0x0037, 0x37 }, + { 0x0038, 0x38 }, { 0x0039, 0x39 }, { 0x003A, 0x3A }, { 0x003B, 0x3B }, + { 0x003F, 0x3F }, { 0x0061, 0x61 }, { 0x0062, 0x62 }, { 0x0063, 0x63 }, + { 0x0064, 0x64 }, { 0x0065, 0x65 }, { 0x0066, 0x66 }, { 0x0067, 0x67 }, + { 0x0068, 0x68 }, { 0x0069, 0x69 }, { 0x006A, 0x6A }, { 0x006B, 0x6B }, + { 0x006C, 0x6C }, { 0x006D, 0x6D }, { 0x006E, 0x6E }, { 0x006F, 0x6F }, + { 0x0070, 0x70 }, { 0x0071, 0x71 }, { 0x0072, 0x72 }, { 0x0073, 0x73 }, + { 0x0074, 0x74 }, { 0x0075, 0x75 }, { 0x0076, 0x76 }, { 0x0077, 0x77 }, + { 0x0078, 0x78 }, { 0x0079, 0x79 }, { 0x007A, 0x7A }, { 0x00A0, 0x20 }, + { 0x0A01, 0x00 }, { 0x0A02, 0x01 }, { 0x0A03, 0x02 }, { 0x0A05, 0x03 }, + { 0x0A06, 0x04 }, { 0x0A07, 0x05 }, { 0x0A08, 0x06 }, { 0x0A09, 0x07 }, + { 0x0A0A, 0x08 }, { 0x0A0F, 0x0F }, { 0x0A10, 0x10 }, { 0x0A13, 0x13 }, + { 0x0A14, 0x14 }, { 0x0A15, 0x15 }, { 0x0A16, 0x16 }, { 0x0A17, 0x17 }, + { 0x0A18, 0x18 }, { 0x0A19, 0x19 }, { 0x0A1A, 0x1A }, { 0x0A1B, 0x1C }, + { 0x0A1C, 0x1D }, { 0x0A1D, 0x1E }, { 0x0A1E, 0x1F }, { 0x0A1F, 0x22 }, + { 0x0A20, 0x23 }, { 0x0A21, 0x24 }, { 0x0A22, 0x25 }, { 0x0A23, 0x26 }, + { 0x0A24, 0x27 }, { 0x0A25, 0x2A }, { 0x0A26, 0x2B }, { 0x0A27, 0x2D }, + { 0x0A28, 0x2F }, { 0x0A2A, 0x3D }, { 0x0A2B, 0x3E }, { 0x0A2C, 0x40 }, + { 0x0A2D, 0x41 }, { 0x0A2E, 0x42 }, { 0x0A2F, 0x43 }, { 0x0A30, 0x44 }, + { 0x0A32, 0x46 }, { 0x0A33, 0x47 }, { 0x0A35, 0x49 }, { 0x0A36, 0x4A }, + { 0x0A38, 0x4C }, { 0x0A39, 0x4D }, { 0x0A3C, 0x4E }, { 0x0A3E, 0x50 }, + { 0x0A3F, 0x51 }, { 0x0A40, 0x52 }, { 0x0A41, 0x53 }, { 0x0A42, 0x54 }, + { 0x0A47, 0x59 }, { 0x0A48, 0x5A }, { 0x0A4B, 0x5D }, { 0x0A4C, 0x5E }, + { 0x0A4D, 0x5F }, { 0x0A51, 0x60 }, { 0x0A70, 0x7B }, { 0x0A71, 0x7C }, + { 0x0A72, 0x7D }, { 0x0A73, 0x7E }, { 0x0A74, 0x7F } +}; + +/* Appendix A.3.11 in 3GPP TS23.038 */ +static const unsigned short tam_gsm[] = { + 0x0020, 0x0B82, 0x0B83, 0x0B85, 0x0B86, 0x0B87, 0x0B88, 0x0B89, + 0x0B8A, 0x0020, 0x000A, 0x0020, 0x0020, 0x000D, 0x0B8E, 0x0B8F, + 0x0B90, 0x0020, 0x0B92, 0x0B93, 0x0B94, 0x0B95, 0x0020, 0x0020, + 0x0020, 0x0B99, 0x0B9A, 0x00A0, 0x0020, 0x0B9C, 0x0020, 0x0B9E, + 0x0020, 0x0021, 0x0B9F, 0x0020, 0x0020, 0x0020, 0x0BA3, 0x0BA4, + 0x0029, 0x0028, 0x0020, 0x0020, 0x002C, 0x0020, 0x002E, 0x0BA8, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, + 0x0038, 0x0039, 0x003A, 0x003B, 0x0BA9, 0x0BAA, 0x0020, 0x003F, + 0x0020, 0x0020, 0x0BAE, 0x0BAF, 0x0BB0, 0x0BB1, 0x0BB2, 0x0BB3, + 0x0BB4, 0x0BB5, 0x0BB6, 0x0BB7, 0x0BB8, 0x0BB9, 0x0020, 0x0020, + 0x0BBE, 0x0BBF, 0x0BC0, 0x0BC1, 0x0BC2, 0x0020, 0x0020, 0x0020, + 0x0BC6, 0x0BC7, 0x0BC8, 0x0020, 0x0BCA, 0x0BCB, 0x0BCC, 0x0BCD, + 0x0BD0, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, + 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, + 0x0078, 0x0079, 0x007A, 0x0BD7, 0x0BF0, 0x0BF1, 0x0BF2, 0x0BF9 +}; + +static const struct codepoint tam_unicode[] = { + { 0x000A, 0x0A }, { 0x000D, 0x0D }, { 0x0020, 0x20 }, { 0x0021, 0x21 }, + { 0x0028, 0x29 }, { 0x0029, 0x28 }, { 0x002C, 0x2C }, { 0x002E, 0x2E }, + { 0x0030, 0x30 }, { 0x0031, 0x31 }, { 0x0032, 0x32 }, { 0x0033, 0x33 }, + { 0x0034, 0x34 }, { 0x0035, 0x35 }, { 0x0036, 0x36 }, { 0x0037, 0x37 }, + { 0x0038, 0x38 }, { 0x0039, 0x39 }, { 0x003A, 0x3A }, { 0x003B, 0x3B }, + { 0x003F, 0x3F }, { 0x0061, 0x61 }, { 0x0062, 0x62 }, { 0x0063, 0x63 }, + { 0x0064, 0x64 }, { 0x0065, 0x65 }, { 0x0066, 0x66 }, { 0x0067, 0x67 }, + { 0x0068, 0x68 }, { 0x0069, 0x69 }, { 0x006A, 0x6A }, { 0x006B, 0x6B }, + { 0x006C, 0x6C }, { 0x006D, 0x6D }, { 0x006E, 0x6E }, { 0x006F, 0x6F }, + { 0x0070, 0x70 }, { 0x0071, 0x71 }, { 0x0072, 0x72 }, { 0x0073, 0x73 }, + { 0x0074, 0x74 }, { 0x0075, 0x75 }, { 0x0076, 0x76 }, { 0x0077, 0x77 }, + { 0x0078, 0x78 }, { 0x0079, 0x79 }, { 0x007A, 0x7A }, { 0x00A0, 0x20 }, + { 0x0B82, 0x01 }, { 0x0B83, 0x02 }, { 0x0B85, 0x03 }, { 0x0B86, 0x04 }, + { 0x0B87, 0x05 }, { 0x0B88, 0x06 }, { 0x0B89, 0x07 }, { 0x0B8A, 0x08 }, + { 0x0B8E, 0x0E }, { 0x0B8F, 0x0F }, { 0x0B90, 0x10 }, { 0x0B92, 0x12 }, + { 0x0B93, 0x13 }, { 0x0B94, 0x14 }, { 0x0B95, 0x15 }, { 0x0B99, 0x19 }, + { 0x0B9A, 0x1A }, { 0x0B9C, 0x1D }, { 0x0B9E, 0x1F }, { 0x0B9F, 0x22 }, + { 0x0BA3, 0x26 }, { 0x0BA4, 0x27 }, { 0x0BA8, 0x2F }, { 0x0BA9, 0x3C }, + { 0x0BAA, 0x3D }, { 0x0BAE, 0x42 }, { 0x0BAF, 0x43 }, { 0x0BB0, 0x44 }, + { 0x0BB1, 0x45 }, { 0x0BB2, 0x46 }, { 0x0BB3, 0x47 }, { 0x0BB4, 0x48 }, + { 0x0BB5, 0x49 }, { 0x0BB6, 0x4A }, { 0x0BB7, 0x4B }, { 0x0BB8, 0x4C }, + { 0x0BB9, 0x4D }, { 0x0BBE, 0x50 }, { 0x0BBF, 0x51 }, { 0x0BC0, 0x52 }, + { 0x0BC1, 0x53 }, { 0x0BC2, 0x54 }, { 0x0BC6, 0x58 }, { 0x0BC7, 0x59 }, + { 0x0BC8, 0x5A }, { 0x0BCA, 0x5C }, { 0x0BCB, 0x5D }, { 0x0BCC, 0x5E }, + { 0x0BCD, 0x5F }, { 0x0BD0, 0x60 }, { 0x0BD7, 0x7B }, { 0x0BF0, 0x7C }, + { 0x0BF1, 0x7D }, { 0x0BF2, 0x7E }, { 0x0BF9, 0x7F } +}; + +/* Appendix A.3.12 in 3GPP TS23.038 */ +static const unsigned short tel_gsm[] = { + 0x0C01, 0x0C02, 0x0C03, 0x0C05, 0x0C06, 0x0C07, 0x0C08, 0x0C09, + 0x0C0A, 0x0C0B, 0x000A, 0x0C0C, 0x0020, 0x000D, 0x0C0E, 0x0C0F, + 0x0C10, 0x0020, 0x0C12, 0x0C13, 0x0C14, 0x0C15, 0x0C16, 0x0C17, + 0x0C18, 0x0C19, 0x0C1A, 0x00A0, 0x0C1B, 0x0C1C, 0x0C1D, 0x0C1E, + 0x0020, 0x0021, 0x0C1F, 0x0C20, 0x0C21, 0x0C22, 0x0C23, 0x0C24, + 0x0029, 0x0028, 0x0C25, 0x0C26, 0x002C, 0x0C27, 0x002E, 0x0C28, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, + 0x0038, 0x0039, 0x003A, 0x003B, 0x0020, 0x0C2A, 0x0C2B, 0x003F, + 0x0C2C, 0x0C2D, 0x0C2E, 0x0C2F, 0x0C30, 0x0C31, 0x0C32, 0x0C33, + 0x0020, 0x0C35, 0x0C36, 0x0C37, 0x0C38, 0x0C39, 0x0020, 0x0C3D, + 0x0C3E, 0x0C3F, 0x0C40, 0x0C41, 0x0C42, 0x0C43, 0x0C44, 0x0020, + 0x0C46, 0x0C47, 0x0C48, 0x0020, 0x0C4A, 0x0C4B, 0x0C4C, 0x0C4D, + 0x0C55, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, + 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, + 0x0078, 0x0079, 0x007A, 0x0C56, 0x0C60, 0x0C61, 0x0C62, 0x0C63 +}; + +static const struct codepoint tel_unicode[] = { + { 0x000A, 0x0A }, { 0x000D, 0x0D }, { 0x0020, 0x20 }, { 0x0021, 0x21 }, + { 0x0028, 0x29 }, { 0x0029, 0x28 }, { 0x002C, 0x2C }, { 0x002E, 0x2E }, + { 0x0030, 0x30 }, { 0x0031, 0x31 }, { 0x0032, 0x32 }, { 0x0033, 0x33 }, + { 0x0034, 0x34 }, { 0x0035, 0x35 }, { 0x0036, 0x36 }, { 0x0037, 0x37 }, + { 0x0038, 0x38 }, { 0x0039, 0x39 }, { 0x003A, 0x3A }, { 0x003B, 0x3B }, + { 0x003F, 0x3F }, { 0x0061, 0x61 }, { 0x0062, 0x62 }, { 0x0063, 0x63 }, + { 0x0064, 0x64 }, { 0x0065, 0x65 }, { 0x0066, 0x66 }, { 0x0067, 0x67 }, + { 0x0068, 0x68 }, { 0x0069, 0x69 }, { 0x006A, 0x6A }, { 0x006B, 0x6B }, + { 0x006C, 0x6C }, { 0x006D, 0x6D }, { 0x006E, 0x6E }, { 0x006F, 0x6F }, + { 0x0070, 0x70 }, { 0x0071, 0x71 }, { 0x0072, 0x72 }, { 0x0073, 0x73 }, + { 0x0074, 0x74 }, { 0x0075, 0x75 }, { 0x0076, 0x76 }, { 0x0077, 0x77 }, + { 0x0078, 0x78 }, { 0x0079, 0x79 }, { 0x007A, 0x7A }, { 0x00A0, 0x20 }, + { 0x0C01, 0x00 }, { 0x0C02, 0x01 }, { 0x0C03, 0x02 }, { 0x0C05, 0x03 }, + { 0x0C06, 0x04 }, { 0x0C07, 0x05 }, { 0x0C08, 0x06 }, { 0x0C09, 0x07 }, + { 0x0C0A, 0x08 }, { 0x0C0B, 0x09 }, { 0x0C0C, 0x0B }, { 0x0C0E, 0x0E }, + { 0x0C0F, 0x0F }, { 0x0C10, 0x10 }, { 0x0C12, 0x12 }, { 0x0C13, 0x13 }, + { 0x0C14, 0x14 }, { 0x0C15, 0x15 }, { 0x0C16, 0x16 }, { 0x0C17, 0x17 }, + { 0x0C18, 0x18 }, { 0x0C19, 0x19 }, { 0x0C1A, 0x1A }, { 0x0C1B, 0x1C }, + { 0x0C1C, 0x1D }, { 0x0C1D, 0x1E }, { 0x0C1E, 0x1F }, { 0x0C1F, 0x22 }, + { 0x0C20, 0x23 }, { 0x0C21, 0x24 }, { 0x0C22, 0x25 }, { 0x0C23, 0x26 }, + { 0x0C24, 0x27 }, { 0x0C25, 0x2A }, { 0x0C26, 0x2B }, { 0x0C27, 0x2D }, + { 0x0C28, 0x2F }, { 0x0C2A, 0x3D }, { 0x0C2B, 0x3E }, { 0x0C2C, 0x40 }, + { 0x0C2D, 0x41 }, { 0x0C2E, 0x42 }, { 0x0C2F, 0x43 }, { 0x0C30, 0x44 }, + { 0x0C31, 0x45 }, { 0x0C32, 0x46 }, { 0x0C33, 0x47 }, { 0x0C35, 0x49 }, + { 0x0C36, 0x4A }, { 0x0C37, 0x4B }, { 0x0C38, 0x4C }, { 0x0C39, 0x4D }, + { 0x0C3D, 0x4F }, { 0x0C3E, 0x50 }, { 0x0C3F, 0x51 }, { 0x0C40, 0x52 }, + { 0x0C41, 0x53 }, { 0x0C42, 0x54 }, { 0x0C43, 0x55 }, { 0x0C44, 0x56 }, + { 0x0C46, 0x58 }, { 0x0C47, 0x59 }, { 0x0C48, 0x5A }, { 0x0C4A, 0x5C }, + { 0x0C4B, 0x5D }, { 0x0C4C, 0x5E }, { 0x0C4D, 0x5F }, { 0x0C55, 0x60 }, + { 0x0C56, 0x7B }, { 0x0C60, 0x7C }, { 0x0C61, 0x7D }, { 0x0C62, 0x7E }, + { 0x0C63, 0x7F } +}; + +/* Appendix A.3.13 in 3GPP TS23.038 */ +static const unsigned short urd_gsm[] = { + 0x0627, 0x0622, 0x0628, 0x067B, 0x0680, 0x067E, 0x06A6, 0x062A, + 0x06C2, 0x067F, 0x000A, 0x0679, 0x067D, 0x000D, 0x067A, 0x067C, + 0x062B, 0x062C, 0x0681, 0x0684, 0x0683, 0x0685, 0x0686, 0x0687, + 0x062D, 0x062E, 0x062F, 0x00A0, 0x068C, 0x0688, 0x0689, 0x068A, + 0x0020, 0x0021, 0x068F, 0x068D, 0x0630, 0x0631, 0x0691, 0x0693, + 0x0029, 0x0028, 0x0699, 0x0632, 0x002C, 0x0696, 0x002E, 0x0698, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, + 0x0038, 0x0039, 0x003A, 0x003B, 0x069A, 0x0633, 0x0634, 0x003F, + 0x0635, 0x0636, 0x0637, 0x0638, 0x0639, 0x0641, 0x0642, 0x06A9, + 0x06AA, 0x06AB, 0x06AF, 0x06B3, 0x06B1, 0x0644, 0x0645, 0x0646, + 0x06BA, 0x06BB, 0x06BC, 0x0648, 0x06C4, 0x06D5, 0x06C1, 0x06BE, + 0x0621, 0x06CC, 0x06D0, 0x06D2, 0x064D, 0x0650, 0x064F, 0x0657, + 0x0654, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, + 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, + 0x0078, 0x0079, 0x007A, 0x0655, 0x0651, 0x0653, 0x0656, 0x0670 +}; + +const struct codepoint urd_unicode[] = { + { 0x000A, 0x0A }, { 0x000D, 0x0D }, { 0x0020, 0x20 }, { 0x0021, 0x21 }, + { 0x0028, 0x29 }, { 0x0029, 0x28 }, { 0x002C, 0x2C }, { 0x002E, 0x2E }, + { 0x0030, 0x30 }, { 0x0031, 0x31 }, { 0x0032, 0x32 }, { 0x0033, 0x33 }, + { 0x0034, 0x34 }, { 0x0035, 0x35 }, { 0x0036, 0x36 }, { 0x0037, 0x37 }, + { 0x0038, 0x38 }, { 0x0039, 0x39 }, { 0x003A, 0x3A }, { 0x003B, 0x3B }, + { 0x003F, 0x3F }, { 0x0061, 0x61 }, { 0x0062, 0x62 }, { 0x0063, 0x63 }, + { 0x0064, 0x64 }, { 0x0065, 0x65 }, { 0x0066, 0x66 }, { 0x0067, 0x67 }, + { 0x0068, 0x68 }, { 0x0069, 0x69 }, { 0x006A, 0x6A }, { 0x006B, 0x6B }, + { 0x006C, 0x6C }, { 0x006D, 0x6D }, { 0x006E, 0x6E }, { 0x006F, 0x6F }, + { 0x0070, 0x70 }, { 0x0071, 0x71 }, { 0x0072, 0x72 }, { 0x0073, 0x73 }, + { 0x0074, 0x74 }, { 0x0075, 0x75 }, { 0x0076, 0x76 }, { 0x0077, 0x77 }, + { 0x0078, 0x78 }, { 0x0079, 0x79 }, { 0x007A, 0x7A }, { 0x00A0, 0x20 }, + { 0x0621, 0x58 }, { 0x0622, 0x01 }, { 0x0627, 0x00 }, { 0x0628, 0x02 }, + { 0x062A, 0x07 }, { 0x062B, 0x10 }, { 0x062C, 0x11 }, { 0x062D, 0x18 }, + { 0x062E, 0x19 }, { 0x062F, 0x1A }, { 0x0630, 0x24 }, { 0x0631, 0x25 }, + { 0x0632, 0x2B }, { 0x0633, 0x3D }, { 0x0634, 0x3E }, { 0x0635, 0x40 }, + { 0x0636, 0x41 }, { 0x0637, 0x42 }, { 0x0638, 0x43 }, { 0x0639, 0x44 }, + { 0x0641, 0x45 }, { 0x0642, 0x46 }, { 0x0644, 0x4D }, { 0x0645, 0x4E }, + { 0x0646, 0x4F }, { 0x0648, 0x53 }, { 0x064D, 0x5C }, { 0x064F, 0x5E }, + { 0x0650, 0x5D }, { 0x0651, 0x7C }, { 0x0653, 0x7D }, { 0x0654, 0x60 }, + { 0x0655, 0x7B }, { 0x0656, 0x7E }, { 0x0657, 0x5F }, { 0x0670, 0x7F }, + { 0x0679, 0x0B }, { 0x067A, 0x0E }, { 0x067B, 0x03 }, { 0x067C, 0x0F }, + { 0x067D, 0x0C }, { 0x067E, 0x05 }, { 0x067F, 0x09 }, { 0x0680, 0x04 }, + { 0x0681, 0x12 }, { 0x0683, 0x14 }, { 0x0684, 0x13 }, { 0x0685, 0x15 }, + { 0x0686, 0x16 }, { 0x0687, 0x17 }, { 0x0688, 0x1D }, { 0x0689, 0x1E }, + { 0x068A, 0x1F }, { 0x068C, 0x1C }, { 0x068D, 0x23 }, { 0x068F, 0x22 }, + { 0x0691, 0x26 }, { 0x0693, 0x27 }, { 0x0696, 0x2D }, { 0x0698, 0x2F }, + { 0x0699, 0x2A }, { 0x069A, 0x3C }, { 0x06A6, 0x06 }, { 0x06A9, 0x47 }, + { 0x06AA, 0x48 }, { 0x06AB, 0x49 }, { 0x06AF, 0x4A }, { 0x06B1, 0x4C }, + { 0x06B3, 0x4B }, { 0x06BA, 0x50 }, { 0x06BB, 0x51 }, { 0x06BC, 0x52 }, + { 0x06BE, 0x57 }, { 0x06C1, 0x56 }, { 0x06C2, 0x08 }, { 0x06C4, 0x54 }, + { 0x06CC, 0x59 }, { 0x06D0, 0x5A }, { 0x06D2, 0x5B }, { 0x06D5, 0x55 } +}; + static int compare_codepoints(const void *a, const void *b) { const struct codepoint *ca = (const struct codepoint *) a; @@ -961,6 +2724,54 @@ static gboolean populate_locking_shift(struct conversion_table *t, t->locking_u = guj_unicode; t->locking_len_u = TABLE_SIZE(guj_unicode); return TRUE; + + case GSM_DIALECT_HINDI: + t->locking_g = hin_gsm; + t->locking_u = hin_unicode; + t->locking_len_u = TABLE_SIZE(hin_unicode); + return TRUE; + + case GSM_DIALECT_KANNADA: + t->locking_g = kan_gsm; + t->locking_u = kan_unicode; + t->locking_len_u = TABLE_SIZE(kan_unicode); + return TRUE; + + case GSM_DIALECT_MALAYALAM: + t->locking_g = mal_gsm; + t->locking_u = mal_unicode; + t->locking_len_u = TABLE_SIZE(mal_unicode); + return TRUE; + + case GSM_DIALECT_ORIYA: + t->locking_g = ori_gsm; + t->locking_u = ori_unicode; + t->locking_len_u = TABLE_SIZE(ori_unicode); + return TRUE; + + case GSM_DIALECT_PUNJABI: + t->locking_g = pun_gsm; + t->locking_u = pun_unicode; + t->locking_len_u = TABLE_SIZE(pun_unicode); + return TRUE; + + case GSM_DIALECT_TAMIL: + t->locking_g = tam_gsm; + t->locking_u = tam_unicode; + t->locking_len_u = TABLE_SIZE(tam_unicode); + return TRUE; + + case GSM_DIALECT_TELUGU: + t->locking_g = tel_gsm; + t->locking_u = tel_unicode; + t->locking_len_u = TABLE_SIZE(tel_unicode); + return TRUE; + + case GSM_DIALECT_URDU: + t->locking_g = urd_gsm; + t->locking_u = urd_unicode; + t->locking_len_u = TABLE_SIZE(urd_unicode); + return TRUE; } return FALSE; @@ -1011,6 +2822,62 @@ static gboolean populate_single_shift(struct conversion_table *t, t->single_u = guj_ext_unicode; t->single_len_u = TABLE_SIZE(guj_ext_unicode); return TRUE; + + case GSM_DIALECT_HINDI: + t->single_g = hin_ext_gsm; + t->single_len_g = TABLE_SIZE(hin_ext_gsm); + t->single_u = hin_ext_unicode; + t->single_len_u = TABLE_SIZE(hin_ext_unicode); + return TRUE; + + case GSM_DIALECT_KANNADA: + t->single_g = kan_ext_gsm; + t->single_len_g = TABLE_SIZE(kan_ext_gsm); + t->single_u = kan_ext_unicode; + t->single_len_u = TABLE_SIZE(kan_ext_unicode); + return TRUE; + + case GSM_DIALECT_MALAYALAM: + t->single_g = mal_ext_gsm; + t->single_len_g = TABLE_SIZE(mal_ext_gsm); + t->single_u = mal_ext_unicode; + t->single_len_u = TABLE_SIZE(mal_ext_unicode); + return TRUE; + + case GSM_DIALECT_ORIYA: + t->single_g = ori_ext_gsm; + t->single_len_g = TABLE_SIZE(ori_ext_gsm); + t->single_u = ori_ext_unicode; + t->single_len_u = TABLE_SIZE(ori_ext_unicode); + return TRUE; + + case GSM_DIALECT_PUNJABI: + t->single_g = pun_ext_gsm; + t->single_len_g = TABLE_SIZE(pun_ext_gsm); + t->single_u = pun_ext_unicode; + t->single_len_u = TABLE_SIZE(pun_ext_unicode); + return TRUE; + + case GSM_DIALECT_TAMIL: + t->single_g = tam_ext_gsm; + t->single_len_g = TABLE_SIZE(tam_ext_gsm); + t->single_u = tam_ext_unicode; + t->single_len_u = TABLE_SIZE(tam_ext_unicode); + return TRUE; + + case GSM_DIALECT_TELUGU: + t->single_g = tel_ext_gsm; + t->single_len_g = TABLE_SIZE(tel_ext_gsm); + t->single_u = tel_ext_unicode; + t->single_len_u = TABLE_SIZE(tel_ext_unicode); + return TRUE; + + case GSM_DIALECT_URDU: + t->single_g = urd_ext_gsm; + t->single_len_g = TABLE_SIZE(urd_ext_gsm); + t->single_u = urd_ext_unicode; + t->single_len_u = TABLE_SIZE(urd_ext_unicode); + return TRUE; } return FALSE; diff --git a/src/util.h b/src/util.h index 193eb8b8..aaaed8ce 100644 --- a/src/util.h +++ b/src/util.h @@ -26,6 +26,14 @@ enum gsm_dialect { GSM_DIALECT_PORTUGUESE, GSM_DIALECT_BENGALI, GSM_DIALECT_GUJARATI, + GSM_DIALECT_HINDI, + GSM_DIALECT_KANNADA, + GSM_DIALECT_MALAYALAM, + GSM_DIALECT_ORIYA, + GSM_DIALECT_PUNJABI, + GSM_DIALECT_TAMIL, + GSM_DIALECT_TELUGU, + GSM_DIALECT_URDU, }; char *convert_gsm_to_utf8(const unsigned char *text, long len, long *items_read,