Lines Matching refs:enc
125 isNever(const ENCODING *enc, const char *p)
131 utf8_isName2(const ENCODING *enc, const char *p)
137 utf8_isName3(const ENCODING *enc, const char *p)
145 utf8_isNmstrt2(const ENCODING *enc, const char *p)
151 utf8_isNmstrt3(const ENCODING *enc, const char *p)
159 utf8_isInvalid2(const ENCODING *enc, const char *p)
165 utf8_isInvalid3(const ENCODING *enc, const char *p)
171 utf8_isInvalid4(const ENCODING *enc, const char *p)
177 ENCODING enc;
197 #define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *) (enc))
236 #define MINBPC(enc) ((enc)->minBytesPerChar)
239 #define MINBPC(enc) 1
242 #define SB_BYTE_TYPE(enc, p) \
243 (((struct normal_encoding *)(enc))->type[(unsigned char)*(p)])
247 sb_byteType(const ENCODING *enc, const char *p)
249 return SB_BYTE_TYPE(enc, p);
251 #define BYTE_TYPE(enc, p) \
252 (AS_NORMAL_ENCODING(enc)->byteType(enc, p))
254 #define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
258 #define BYTE_TO_ASCII(enc, p) \
259 (AS_NORMAL_ENCODING(enc)->byteToAscii(enc, p))
261 sb_byteToAscii(const ENCODING *enc, const char *p)
266 #define BYTE_TO_ASCII(enc, p) (*(p))
269 #define IS_NAME_CHAR(enc, p, n) \
270 (AS_NORMAL_ENCODING(enc)->isName ## n(enc, p))
271 #define IS_NMSTRT_CHAR(enc, p, n) \
272 (AS_NORMAL_ENCODING(enc)->isNmstrt ## n(enc, p))
273 #define IS_INVALID_CHAR(enc, p, n) \
274 (AS_NORMAL_ENCODING(enc)->isInvalid ## n(enc, p))
277 #define IS_NAME_CHAR_MINBPC(enc, p) \
278 (AS_NORMAL_ENCODING(enc)->isNameMin(enc, p))
279 #define IS_NMSTRT_CHAR_MINBPC(enc, p) \
280 (AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc, p))
282 #define IS_NAME_CHAR_MINBPC(enc, p) (0)
283 #define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
287 #define CHAR_MATCHES(enc, p, c) \
288 (AS_NORMAL_ENCODING(enc)->charMatches(enc, p, c))
290 sb_charMatches(const ENCODING *enc, const char *p, int c)
296 #define CHAR_MATCHES(enc, p, c) (*(p) == c)
322 utf8_toUtf8(const ENCODING *enc,
341 utf8_toUtf16(const ENCODING *enc,
348 switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
429 latin1_toUtf8(const ENCODING *enc,
454 latin1_toUtf16(const ENCODING *enc,
487 ascii_toUtf8(const ENCODING *enc,
540 E ## toUtf8(const ENCODING *enc, \
603 E ## toUtf16(const ENCODING *enc, \
639 #define LITTLE2_BYTE_TYPE(enc, p) \
641 enc))->type[(unsigned char)*(p)] \
643 #define LITTLE2_BYTE_TO_ASCII(enc, p) ((p)[1] == 0 ? (p)[0] : -1)
644 #define LITTLE2_CHAR_MATCHES(enc, p, c) ((p)[1] == 0 && (p)[0] == c)
645 #define LITTLE2_IS_NAME_CHAR_MINBPC(enc, p) \
647 #define LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
653 little2_byteType(const ENCODING *enc, const char *p)
655 return LITTLE2_BYTE_TYPE(enc, p);
659 little2_byteToAscii(const ENCODING *enc, const char *p)
661 return LITTLE2_BYTE_TO_ASCII(enc, p);
665 little2_charMatches(const ENCODING *enc, const char *p, int c)
667 return LITTLE2_CHAR_MATCHES(enc, p, c);
671 little2_isNameMin(const ENCODING *enc, const char *p)
673 return LITTLE2_IS_NAME_CHAR_MINBPC(enc, p);
677 little2_isNmstrtMin(const ENCODING *enc, const char *p)
679 return LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p);
689 #define MINBPC(enc) 2
691 #define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
692 #define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p)
693 #define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c)
694 #define IS_NAME_CHAR(enc, p, n) 0
695 #define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p)
696 #define IS_NMSTRT_CHAR(enc, p, n) (0)
697 #define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
780 #define BIG2_BYTE_TYPE(enc, p) \
782 ? ((struct normal_encoding *)(enc))->type[(unsigned char)(p)[1]] \
784 #define BIG2_BYTE_TO_ASCII(enc, p) ((p)[0] == 0 ? (p)[1] : -1)
785 #define BIG2_CHAR_MATCHES(enc, p, c) ((p)[0] == 0 && (p)[1] == c)
786 #define BIG2_IS_NAME_CHAR_MINBPC(enc, p) \
788 #define BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
794 big2_byteType(const ENCODING *enc, const char *p)
796 return BIG2_BYTE_TYPE(enc, p);
800 big2_byteToAscii(const ENCODING *enc, const char *p)
802 return BIG2_BYTE_TO_ASCII(enc, p);
806 big2_charMatches(const ENCODING *enc, const char *p, int c)
808 return BIG2_CHAR_MATCHES(enc, p, c);
812 big2_isNameMin(const ENCODING *enc, const char *p)
814 return BIG2_IS_NAME_CHAR_MINBPC(enc, p);
818 big2_isNmstrtMin(const ENCODING *enc, const char *p)
820 return BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p);
830 #define MINBPC(enc) 2
832 #define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
833 #define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p)
834 #define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c)
835 #define IS_NAME_CHAR(enc, p, n) 0
836 #define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p)
837 #define IS_NMSTRT_CHAR(enc, p, n) (0)
838 #define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
941 initUpdatePosition(const ENCODING *enc, const char *ptr,
944 normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
948 toAscii(const ENCODING *enc, const char *ptr, const char *end)
952 XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
976 parsePseudoAttribute(const ENCODING *enc,
990 if (!isSpace(toAscii(enc, ptr, end))) {
995 ptr += enc->minBytesPerChar;
996 } while (isSpace(toAscii(enc, ptr, end)));
1003 c = toAscii(enc, ptr, end);
1015 ptr += enc->minBytesPerChar;
1016 } while (isSpace(c = toAscii(enc, ptr, end)));
1023 ptr += enc->minBytesPerChar;
1029 ptr += enc->minBytesPerChar;
1030 c = toAscii(enc, ptr, end);
1032 ptr += enc->minBytesPerChar;
1033 c = toAscii(enc, ptr, end);
1040 ptr += enc->minBytesPerChar;
1042 for (;; ptr += enc->minBytesPerChar) {
1043 c = toAscii(enc, ptr, end);
1056 *nextTokPtr = ptr + enc->minBytesPerChar;
1086 const ENCODING *enc,
1099 ptr += 5 * enc->minBytesPerChar;
1100 end -= 2 * enc->minBytesPerChar;
1101 if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)
1106 if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) {
1117 if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
1130 if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) {
1131 int c = toAscii(enc, val, end);
1139 *encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar);
1140 if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
1147 if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone)
1152 if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) {
1156 else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) {
1164 while (isSpace(toAscii(enc, ptr, end)))
1165 ptr += enc->minBytesPerChar;
1255 #define AS_UNKNOWN_ENCODING(enc) ((const struct unknown_encoding *) (enc))
1264 unknown_isName(const ENCODING *enc, const char *p)
1266 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1274 unknown_isNmstrt(const ENCODING *enc, const char *p)
1276 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1284 unknown_isInvalid(const ENCODING *enc, const char *p)
1286 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1292 unknown_toUtf8(const ENCODING *enc,
1296 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1311 *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
1326 unknown_toUtf16(const ENCODING *enc,
1330 const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1336 *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
1419 e->normal.enc.utf8Convert = unknown_toUtf8;
1420 e->normal.enc.utf16Convert = unknown_toUtf16;
1421 return &(e->normal.enc);
1485 #define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16)
1486 #define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i)
1489 encoding indices to encodings; INIT_ENC_INDEX(enc) is the index of
1498 const INIT_ENCODING *enc,
1508 encPtr = enc->encPtr;
1518 switch (INIT_ENC_INDEX(enc)) {
1528 if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
1540 if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
1548 if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC
1549 || INIT_ENC_INDEX(enc) == UTF_16_ENC)
1555 if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
1570 int e = INIT_ENC_INDEX(enc);
1591 if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC)
1614 *encPtr = encodingTable[INIT_ENC_INDEX(enc)];
1645 ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);
1646 if (enc)
1647 ((struct normal_encoding *)enc)->type[ASCII_COLON] = BT_COLON;
1648 return enc;
