Lines Matching full:group
79 That is, a sometimes-optional 'group' byte, followed by 1 and sometimes 2
127 group byte is for a single byte char set or not we use this define: */
138 each group byte to introduce a fixed-width encoding (to make it faster to
139 count characters), we use a convention of doubling up on the group byte
144 Next, you will notice that the list of group bytes has some gaps.
183 as group '0', as a place to tuck this exceptions list.*/
188 LOTUS added a new group 0x14 to hold Unicode values not otherwise
205 translations even faster,sometimes the optimization group byte can be dropped
207 group byte that is dropped is called the 'optimization group'.
209 For Notes, the optimzation group is always 0x1.*/
211 /* For 1-2-3 files, the optimzation group is stored in the header of the 1-2-3
215 optimization group as part of the name of the converter (LMBCS-1, LMBCS-2,
229 some loops and searches, we define a value for that last group converter:*/
231 #define ULMBCS_GRP_LAST 0x13 /* last LMBCS group that has a converter */
269 arranged by Unicode values (including ranges) either lists which group
283 /* And here's a simple way to see if a group falls in an appropriate range */
410 The default return is group 0x01. Note that for
507 we use, the optimization group, and the group (if any) that matches the
556 optimization group. So, we put the common stuff into a worker function,
665 * because those cannot be represented in the Unicode group.
681 ulmbcs_byte_t group, /* The group to try */
684 ulmbcs_byte_t * lastConverterIndex, /* output: track last successful group used */
689 UConverterSharedData * xcnv = extraInfo->OptGrpConverter[group];
696 U_ASSERT(group<ULMBCS_GRP_UNICODE);
705 groups_tried[group] = TRUE;
709 *lastConverterIndex = group;
712 except with the exception group.
714 U_ASSERT((firstByte <= ULMBCS_C0END) || (firstByte >= ULMBCS_C1START) || (group == ULMBCS_GRP_EXCEPT));
716 /* use converted data: first write 0, 1 or two group bytes */
717 if (group != ULMBCS_GRP_EXCEPT && extraInfo->OptGroup != group)
719 *pLMBCS++ = group;
720 if (bytesConverted == 1 && group >= ULMBCS_DOUBLEOPTGROUP_START)
722 *pLMBCS++ = group;
752 know we are writing LMBCS using the Unicode group
800 2. Look up group in table & try that (could be
801 A) Unicode group
802 B) control group,
804 or ambiguous SBCS or MBCS group (on to step 4...)
807 A) The optimization group
808 B) The locale group
809 C) The last group that succeeded with this string.
810 D) every other group that's relevent (single or double)
811 E) If its single-byte ambiguous, try the exceptions group
844 ulmbcs_byte_t group = FindLMBCSUniRange(uniChar);
846 if (group == ULMBCS_GRP_UNICODE) /* (Strategy 2A) */
852 else if (group == ULMBCS_GRP_CTRL) /* (Strategy 2B) */
867 else if (group < ULMBCS_GRP_UNICODE) /* (Strategy 2C) */
871 extraInfo, group, pLMBCS, &uniChar,
874 if (!bytes_written) /* the ambiguous group cases (Strategy 3) */
878 /* check for non-default optimization group (Strategy 3A )*/
880 && ULMBCS_AMBIGUOUS_MATCH(group, extraInfo->OptGroup))
886 /* check for locale optimization group (Strategy 3B) */
889 && (ULMBCS_AMBIGUOUS_MATCH(group, extraInfo->localeConverterIndex)))
895 /* check for last optimization group used for this string (Strategy 3C) */
898 && (ULMBCS_AMBIGUOUS_MATCH(group, lastConverterIndex)))
911 grp_start = (ulmbcs_byte_t)((group == ULMBCS_AMBIGUOUS_MBCS)
914 group == ULMBCS_AMBIGUOUS_MBCS)
928 /* a final conversion fallback to the exceptions group if its likely
980 /* A function to call when we are looking at the Unicode group byte in LMBCS */
984 uint8_t HighCh = *(*ppLMBCSin)++; /* Big-endian Unicode in LMBCS compatibility group*/
1049 ulmbcs_byte_t group;
1052 if (CurByte == ULMBCS_GRP_CTRL) /* Control character group - no opt group update */
1060 if (CurByte == ULMBCS_GRP_UNICODE) /* Unicode compatibility group: BigEndian UTF16 */
1069 group = CurByte; /* group byte is in the source */
1071 if (group > ULMBCS_GRP_LAST || (cnv = extraInfo->OptGrpConverter[group]) == NULL)
1073 /* this is not a valid group byte - no converter*/
1076 else if (group >= ULMBCS_DOUBLEOPTGROUP_START) /* double byte conversion */
1081 /* check for LMBCS doubled-group-byte case */
1082 if (*args->source == group) {
1111 /* Lookup value must include opt group */
1112 bytes[0] = group;
1118 else if (CurByte >= ULMBCS_C1START) /* group byte is implicit */
1121 group = extraInfo->OptGroup;
1122 cnv = extraInfo->OptGrpConverter[group];
1123 if (group >= ULMBCS_DOUBLEOPTGROUP_START) /* double byte conversion */
