+ case CCL_Extension:
+ switch (EXCMD)
+ {
+#ifndef UTF2000
+ case CCL_ReadMultibyteChar2:
+ if (!src)
+ CCL_INVALID_CMD;
+
+ if (src >= src_end)
+ {
+ src++;
+ goto ccl_read_multibyte_character_suspend;
+ }
+
+ i = *src++;
+ if (i < 0x80)
+ {
+ /* ASCII */
+ reg[rrr] = i;
+ reg[RRR] = LEADING_BYTE_ASCII;
+ }
+ else if (i <= MAX_LEADING_BYTE_OFFICIAL_1)
+ {
+ if (src >= src_end)
+ goto ccl_read_multibyte_character_suspend;
+ reg[RRR] = i;
+ reg[rrr] = (*src++ & 0x7F);
+ }
+ else if (i <= MAX_LEADING_BYTE_OFFICIAL_2)
+ {
+ if ((src + 1) >= src_end)
+ goto ccl_read_multibyte_character_suspend;
+ reg[RRR] = i;
+ i = (*src++ & 0x7F);
+ reg[rrr] = ((i << 7) | (*src & 0x7F));
+ src++;
+ }
+ else if (i == PRE_LEADING_BYTE_PRIVATE_1)
+ {
+ if ((src + 1) >= src_end)
+ goto ccl_read_multibyte_character_suspend;
+ reg[RRR] = *src++;
+ reg[rrr] = (*src++ & 0x7F);
+ }
+ else if (i == PRE_LEADING_BYTE_PRIVATE_2)
+ {
+ if ((src + 2) >= src_end)
+ goto ccl_read_multibyte_character_suspend;
+ reg[RRR] = *src++;
+ i = (*src++ & 0x7F);
+ reg[rrr] = ((i << 7) | (*src & 0x7F));
+ src++;
+ }
+ else
+ {
+ /* INVALID CODE. Return a single byte character. */
+ reg[RRR] = LEADING_BYTE_ASCII;
+ reg[rrr] = i;
+ }
+ break;
+
+ ccl_read_multibyte_character_suspend:
+ src--;
+ if (ccl->last_block)
+ {
+ ic = ccl->eof_ic;
+ goto ccl_repeat;
+ }
+ else
+ CCL_SUSPEND (CCL_STAT_SUSPEND_BY_SRC);
+
+ break;
+#endif
+
+#ifndef UTF2000
+ case CCL_WriteMultibyteChar2:
+ i = reg[RRR]; /* charset */
+ if (i == LEADING_BYTE_ASCII)
+ i = reg[rrr] & 0xFF;
+ else if (XCHARSET_DIMENSION (CHARSET_BY_LEADING_BYTE (i)) == 1)
+ i = (((i - FIELD2_TO_OFFICIAL_LEADING_BYTE) << 7)
+ | (reg[rrr] & 0x7F));
+ else if (i < MAX_LEADING_BYTE_OFFICIAL_2)
+ i = ((i - FIELD1_TO_OFFICIAL_LEADING_BYTE) << 14) | reg[rrr];
+ else
+ i = ((i - FIELD1_TO_PRIVATE_LEADING_BYTE) << 14) | reg[rrr];
+
+ CCL_WRITE_CHAR (i);
+
+ break;
+#endif
+
+ case CCL_TranslateCharacter:
+#if 0
+ /* XEmacs does not have translate_char, and its
+ equivalent nor. We do nothing on this operation. */
+ CCL_MAKE_CHAR (reg[RRR], reg[rrr], i);
+ op = translate_char (GET_TRANSLATION_TABLE (reg[Rrr]),
+ i, -1, 0, 0);
+ SPLIT_CHAR (op, reg[RRR], i, j);
+ if (j != -1)
+ i = (i << 7) | j;
+
+ reg[rrr] = i;
+#endif
+ break;
+
+ case CCL_TranslateCharacterConstTbl:
+#if 0
+ /* XEmacs does not have translate_char, and its
+ equivalent nor. We do nothing on this operation. */
+ op = XINT (ccl_prog[ic]); /* table */
+ ic++;
+ CCL_MAKE_CHAR (reg[RRR], reg[rrr], i);
+ op = translate_char (GET_TRANSLATION_TABLE (op), i, -1, 0, 0);
+ SPLIT_CHAR (op, reg[RRR], i, j);
+ if (j != -1)
+ i = (i << 7) | j;
+
+ reg[rrr] = i;
+#endif
+ break;
+
+ case CCL_IterateMultipleMap:
+ {
+ Lisp_Object map, content, attrib, value;
+ int point, size, fin_ic;
+
+ j = XINT (ccl_prog[ic++]); /* number of maps. */
+ fin_ic = ic + j;
+ op = reg[rrr];
+ if ((j > reg[RRR]) && (j >= 0))
+ {
+ ic += reg[RRR];
+ i = reg[RRR];
+ }
+ else
+ {
+ reg[RRR] = -1;
+ ic = fin_ic;
+ break;
+ }
+
+ for (;i < j;i++)
+ {
+
+ size = XVECTOR (Vcode_conversion_map_vector)->size;
+ point = XINT (ccl_prog[ic++]);
+ if (point >= size) continue;
+ map =
+ XVECTOR (Vcode_conversion_map_vector)->contents[point];
+
+ /* Check map validity. */
+ if (!CONSP (map)) continue;
+ map = XCDR (map);
+ if (!VECTORP (map)) continue;
+ size = XVECTOR (map)->size;
+ if (size <= 1) continue;
+
+ content = XVECTOR (map)->contents[0];
+
+ /* check map type,
+ [STARTPOINT VAL1 VAL2 ...] or
+ [t ELEMENT STARTPOINT ENDPOINT] */
+ if (INTP (content))
+ {
+ point = XUINT (content);
+ point = op - point + 1;
+ if (!((point >= 1) && (point < size))) continue;
+ content = XVECTOR (map)->contents[point];
+ }
+ else if (EQ (content, Qt))
+ {
+ if (size != 4) continue;
+ if ((op >= XUINT (XVECTOR (map)->contents[2]))
+ && (op < XUINT (XVECTOR (map)->contents[3])))
+ content = XVECTOR (map)->contents[1];
+ else
+ continue;
+ }
+ else
+ continue;
+
+ if (NILP (content))
+ continue;
+ else if (INTP (content))
+ {
+ reg[RRR] = i;
+ reg[rrr] = XINT(content);
+ break;
+ }
+ else if (EQ (content, Qt) || EQ (content, Qlambda))
+ {
+ reg[RRR] = i;
+ break;
+ }
+ else if (CONSP (content))
+ {
+ attrib = XCAR (content);
+ value = XCDR (content);
+ if (!INTP (attrib) || !INTP (value))
+ continue;
+ reg[RRR] = i;
+ reg[rrr] = XUINT (value);
+ break;
+ }
+ else if (SYMBOLP (content))
+ CCL_CALL_FOR_MAP_INSTRUCTION (content, fin_ic);
+ else
+ CCL_INVALID_CMD;
+ }
+ if (i == j)
+ reg[RRR] = -1;
+ ic = fin_ic;
+ }
+ break;
+
+ case CCL_MapMultiple:
+ {
+ Lisp_Object map, content, attrib, value;
+ int point, size, map_vector_size;
+ int map_set_rest_length, fin_ic;
+ int current_ic = this_ic;
+
+ /* inhibit recursive call on MapMultiple. */
+ if (stack_idx_of_map_multiple > 0)
+ {
+ if (stack_idx_of_map_multiple <= stack_idx)
+ {
+ stack_idx_of_map_multiple = 0;
+ mapping_stack_pointer = mapping_stack;
+ CCL_INVALID_CMD;
+ }
+ }
+ else
+ mapping_stack_pointer = mapping_stack;
+ stack_idx_of_map_multiple = 0;
+
+ map_set_rest_length =
+ XINT (ccl_prog[ic++]); /* number of maps and separators. */
+ fin_ic = ic + map_set_rest_length;
+ op = reg[rrr];
+
+ if ((map_set_rest_length > reg[RRR]) && (reg[RRR] >= 0))
+ {
+ ic += reg[RRR];
+ i = reg[RRR];
+ map_set_rest_length -= i;
+ }
+ else
+ {
+ ic = fin_ic;
+ reg[RRR] = -1;
+ mapping_stack_pointer = mapping_stack;
+ break;
+ }
+
+ if (mapping_stack_pointer <= (mapping_stack + 1))
+ {
+ /* Set up initial state. */
+ mapping_stack_pointer = mapping_stack;
+ PUSH_MAPPING_STACK (0, op);
+ reg[RRR] = -1;
+ }
+ else
+ {
+ /* Recover after calling other ccl program. */
+ int orig_op;
+
+ POP_MAPPING_STACK (map_set_rest_length, orig_op);
+ POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
+ switch (op)
+ {
+ case -1:
+ /* Regard it as Qnil. */
+ op = orig_op;
+ i++;
+ ic++;
+ map_set_rest_length--;
+ break;
+ case -2:
+ /* Regard it as Qt. */
+ op = reg[rrr];
+ i++;
+ ic++;
+ map_set_rest_length--;
+ break;
+ case -3:
+ /* Regard it as Qlambda. */
+ op = orig_op;
+ i += map_set_rest_length;
+ ic += map_set_rest_length;
+ map_set_rest_length = 0;
+ break;
+ default:
+ /* Regard it as normal mapping. */
+ i += map_set_rest_length;
+ ic += map_set_rest_length;
+ POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
+ break;
+ }
+ }
+ map_vector_size = XVECTOR (Vcode_conversion_map_vector)->size;
+
+ do {
+ for (;map_set_rest_length > 0;i++, ic++, map_set_rest_length--)
+ {
+ point = XINT(ccl_prog[ic]);
+ if (point < 0)
+ {
+ /* +1 is for including separator. */
+ point = -point + 1;
+ if (mapping_stack_pointer
+ >= &mapping_stack[MAX_MAP_SET_LEVEL])
+ CCL_INVALID_CMD;
+ PUSH_MAPPING_STACK (map_set_rest_length - point,
+ reg[rrr]);
+ map_set_rest_length = point;
+ reg[rrr] = op;
+ continue;
+ }
+
+ if (point >= map_vector_size) continue;
+ map = (XVECTOR (Vcode_conversion_map_vector)
+ ->contents[point]);
+
+ /* Check map validity. */
+ if (!CONSP (map)) continue;
+ map = XCDR (map);
+ if (!VECTORP (map)) continue;
+ size = XVECTOR (map)->size;
+ if (size <= 1) continue;
+
+ content = XVECTOR (map)->contents[0];
+
+ /* check map type,
+ [STARTPOINT VAL1 VAL2 ...] or
+ [t ELEMENT STARTPOINT ENDPOINT] */
+ if (INTP (content))
+ {
+ point = XUINT (content);
+ point = op - point + 1;
+ if (!((point >= 1) && (point < size))) continue;
+ content = XVECTOR (map)->contents[point];
+ }
+ else if (EQ (content, Qt))
+ {
+ if (size != 4) continue;
+ if ((op >= XUINT (XVECTOR (map)->contents[2])) &&
+ (op < XUINT (XVECTOR (map)->contents[3])))
+ content = XVECTOR (map)->contents[1];
+ else
+ continue;
+ }
+ else
+ continue;
+
+ if (NILP (content))
+ continue;
+
+ reg[RRR] = i;
+ if (INTP (content))
+ {
+ op = XINT (content);
+ i += map_set_rest_length - 1;
+ ic += map_set_rest_length - 1;
+ POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
+ map_set_rest_length++;
+ }
+ else if (CONSP (content))
+ {
+ attrib = XCAR (content);
+ value = XCDR (content);
+ if (!INTP (attrib) || !INTP (value))
+ continue;
+ op = XUINT (value);
+ i += map_set_rest_length - 1;
+ ic += map_set_rest_length - 1;
+ POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
+ map_set_rest_length++;
+ }
+ else if (EQ (content, Qt))
+ {
+ op = reg[rrr];
+ }
+ else if (EQ (content, Qlambda))
+ {
+ i += map_set_rest_length;
+ ic += map_set_rest_length;
+ break;
+ }
+ else if (SYMBOLP (content))
+ {
+ if (mapping_stack_pointer
+ >= &mapping_stack[MAX_MAP_SET_LEVEL])
+ CCL_INVALID_CMD;
+ PUSH_MAPPING_STACK (map_set_rest_length, reg[rrr]);
+ PUSH_MAPPING_STACK (map_set_rest_length, op);
+ stack_idx_of_map_multiple = stack_idx + 1;
+ CCL_CALL_FOR_MAP_INSTRUCTION (content, current_ic);
+ }
+ else
+ CCL_INVALID_CMD;
+ }
+ if (mapping_stack_pointer <= (mapping_stack + 1))
+ break;
+ POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
+ i += map_set_rest_length;
+ ic += map_set_rest_length;
+ POP_MAPPING_STACK (map_set_rest_length, reg[rrr]);
+ } while (1);
+
+ ic = fin_ic;
+ }
+ reg[rrr] = op;
+ break;
+
+ case CCL_MapSingle:
+ {
+ Lisp_Object map, attrib, value, content;
+ int size, point;
+ j = XINT (ccl_prog[ic++]); /* map_id */
+ op = reg[rrr];
+ if (j >= XVECTOR (Vcode_conversion_map_vector)->size)
+ {
+ reg[RRR] = -1;
+ break;
+ }
+ map = XVECTOR (Vcode_conversion_map_vector)->contents[j];
+ if (!CONSP (map))
+ {
+ reg[RRR] = -1;
+ break;
+ }
+ map = XCDR (map);
+ if (!VECTORP (map))
+ {
+ reg[RRR] = -1;
+ break;
+ }
+ size = XVECTOR (map)->size;
+ point = XUINT (XVECTOR (map)->contents[0]);
+ point = op - point + 1;
+ reg[RRR] = 0;
+ if ((size <= 1) ||
+ (!((point >= 1) && (point < size))))
+ reg[RRR] = -1;
+ else
+ {
+ reg[RRR] = 0;
+ content = XVECTOR (map)->contents[point];
+ if (NILP (content))
+ reg[RRR] = -1;
+ else if (INTP (content))
+ reg[rrr] = XINT (content);
+ else if (EQ (content, Qt));
+ else if (CONSP (content))
+ {
+ attrib = XCAR (content);
+ value = XCDR (content);
+ if (!INTP (attrib) || !INTP (value))
+ continue;
+ reg[rrr] = XUINT(value);
+ break;
+ }
+ else if (SYMBOLP (content))
+ CCL_CALL_FOR_MAP_INSTRUCTION (content, ic);
+ else
+ reg[RRR] = -1;
+ }
+ }
+ break;
+
+ default:
+ CCL_INVALID_CMD;
+ }
+ break;
+