(xic_create_fontsetname): If ADSTYLE field is not a wild

[gnu-emacs] / src / ccl.c

diff --git a/src/ccl.c b/src/ccl.c
index e8eac521a3a4025095024b21a05ae6e3916454e3..779755cf39eb6589934945ada26b6d667cc67e35 100644 (file)
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1,7 +1,9 @@
 /* CCL (Code Conversion Language) interpreter.
 /* CCL (Code Conversion Language) interpreter.

-   Copyright (C) 1995, 1997 Electrotechnical Laboratory, JAPAN.
-   Copyright (C) 2001 Free Software Foundation, Inc.
-   Licensed to the Free Software Foundation.
+   Copyright (C) 2001, 2002, 2003, 2004, 2005,
+                 2006 Free Software Foundation, Inc.
+   Copyright (C) 1995, 1997, 1998, 2003, 2004, 2005
+     National Institute of Advanced Industrial Science and Technology (AIST)
+     Registration Number H14PRO021

 
 This file is part of GNU Emacs.
 
 
 This file is part of GNU Emacs.
 


@@ -17,28 +19,18 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GNU Emacs; see the file COPYING.  If not, write to
 
 You should have received a copy of the GNU General Public License
 along with GNU Emacs; see the file COPYING.  If not, write to

-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */

 
 

-#ifdef emacs

 #include <config.h>
 #include <config.h>

-#endif

 
 #include <stdio.h>
 
 
 #include <stdio.h>
 

-#ifdef emacs
-

 #include "lisp.h"
 #include "charset.h"
 #include "ccl.h"
 #include "coding.h"
 
 #include "lisp.h"
 #include "charset.h"
 #include "ccl.h"
 #include "coding.h"
 

-#else  /* not emacs */
-
-#include "mulelib.h"
-
-#endif /* not emacs */
-

 /* This contains all code conversion map available to CCL.  */
 Lisp_Object Vcode_conversion_map_vector;
 
 /* This contains all code conversion map available to CCL.  */
 Lisp_Object Vcode_conversion_map_vector;
 


@@ -59,12 +51,21 @@ Lisp_Object Qcode_conversion_map_id;
 Lisp_Object Qccl_program_idx;
 
 /* Table of registered CCL programs.  Each element is a vector of
 Lisp_Object Qccl_program_idx;
 
 /* Table of registered CCL programs.  Each element is a vector of

-   NAME, CCL_PROG, and RESOLVEDP where NAME (symbol) is the name of
-   the program, CCL_PROG (vector) is the compiled code of the program,
-   RESOLVEDP (t or nil) is the flag to tell if symbols in CCL_PROG is
-   already resolved to index numbers or not.  */
+   NAME, CCL_PROG, RESOLVEDP, and UPDATEDP, where NAME (symbol) is the
+   name of the program, CCL_PROG (vector) is the compiled code of the
+   program, RESOLVEDP (t or nil) is the flag to tell if symbols in
+   CCL_PROG is already resolved to index numbers or not, UPDATEDP (t
+   or nil) is the flat to tell if the CCL program is updated after it
+   was once used.  */

 Lisp_Object Vccl_program_table;
 
 Lisp_Object Vccl_program_table;
 

+/* Vector of registered hash tables for translation.  */
+Lisp_Object Vtranslation_hash_table_vector;
+
+/* Return a hash table of id number ID.  */
+#define GET_HASH_TABLE(id) \
+  (XHASH_TABLE (XCDR(XVECTOR(Vtranslation_hash_table_vector)->contents[(id)])))
+

 /* CCL (Code Conversion Language) is a simple language which has
    operations on one input buffer, one output buffer, and 7 registers.
    The syntax of CCL is described in `ccl.el'.  Emacs Lisp function
 /* CCL (Code Conversion Language) is a simple language which has
    operations on one input buffer, one output buffer, and 7 registers.
    The syntax of CCL is described in `ccl.el'.  Emacs Lisp function


@@ -429,7 +430,7 @@ Lisp_Object Vccl_program_table;
                                        extended_command (rrr,RRR,Rrr,ARGS)
                                      */
 
                                        extended_command (rrr,RRR,Rrr,ARGS)
                                      */
 

-/* 
+/*

    Here after, Extended CCL Instructions.
    Bit length of extended command is 14.
    Therefore, the instruction code range is 0..16384(0x3fff).
    Here after, Extended CCL Instructions.
    Bit length of extended command is 14.
    Therefore, the instruction code range is 0..16384(0x3fff).


@@ -487,7 +488,7 @@ Lisp_Object Vccl_program_table;
                                        3:MAP-ID1
                                        4:MAP-ID2
                                        ...
                                        3:MAP-ID1
                                        4:MAP-ID2
                                        ...

-                                    */ 
+                                    */

 
 /* Map the code in reg[rrr] by MAPs starting from the Nth (N =
    reg[RRR]) map.
 
 /* Map the code in reg[rrr] by MAPs starting from the Nth (N =
    reg[RRR]) map.


@@ -565,7 +566,7 @@ Lisp_Object Vccl_program_table;
    where
        STARTPOINT is an offset to be used for indexing a map,
        ENDPOINT is a maximum index number of a map,
    where
        STARTPOINT is an offset to be used for indexing a map,
        ENDPOINT is a maximum index number of a map,

-       VAL and VALn is a number, nil, t, or lambda.  
+       VAL and VALn is a number, nil, t, or lambda.

 
    Valid index range of a map of type (a) is:
        STARTPOINT <= index < STARTPOINT + map_size - 1
 
    Valid index range of a map of type (a) is:
        STARTPOINT <= index < STARTPOINT + map_size - 1


@@ -629,14 +630,17 @@ do                                                                \
          {                                                     \
            ccl_prog = ccl_prog_stack_struct[0].ccl_prog;       \
            ic = ccl_prog_stack_struct[0].ic;                   \
          {                                                     \
            ccl_prog = ccl_prog_stack_struct[0].ccl_prog;       \
            ic = ccl_prog_stack_struct[0].ic;                   \

+           eof_ic = ccl_prog_stack_struct[0].eof_ic;           \

          }                                                     \
        CCL_INVALID_CMD;                                        \
       }                                                                \
     ccl_prog_stack_struct[stack_idx].ccl_prog = ccl_prog;      \
     ccl_prog_stack_struct[stack_idx].ic = (ret_ic);            \
          }                                                     \
        CCL_INVALID_CMD;                                        \
       }                                                                \
     ccl_prog_stack_struct[stack_idx].ccl_prog = ccl_prog;      \
     ccl_prog_stack_struct[stack_idx].ic = (ret_ic);            \

+    ccl_prog_stack_struct[stack_idx].eof_ic = eof_ic;          \

     stack_idx++;                                               \
     ccl_prog = called_ccl.prog;                                        \
     ic = CCL_HEADER_MAIN;                                      \
     stack_idx++;                                               \
     ccl_prog = called_ccl.prog;                                        \
     ic = CCL_HEADER_MAIN;                                      \

+    eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]);              \

     goto ccl_repeat;                                           \
   }                                                            \
 while (0)
     goto ccl_repeat;                                           \
   }                                                            \
 while (0)


@@ -652,6 +656,18 @@ while (0)
                                          set reg[RRR] to -1.
                                     */
 
                                          set reg[RRR] to -1.
                                     */
 

+#define CCL_LookupIntConstTbl 0x13 /* Lookup multibyte character by
+                                     integer key.  Afterwards R7 set
+                                     to 1 iff lookup succeeded.
+                                     1:ExtendedCOMMNDRrrRRRXXXXXXXX
+                                     2:ARGUMENT(Hash table ID) */
+
+#define CCL_LookupCharConstTbl 0x14 /* Lookup integer by multibyte
+                                      character key.  Afterwards R7 set
+                                      to 1 iff lookup succeeded.
+                                      1:ExtendedCOMMNDRrrRRRrrrXXXXX
+                                      2:ARGUMENT(Hash table ID) */
+

 /* CCL arithmetic/logical operators. */
 #define CCL_PLUS       0x00    /* X = Y + Z */
 #define CCL_MINUS      0x01    /* X = Y - Z */
 /* CCL arithmetic/logical operators. */
 #define CCL_PLUS       0x00    /* X = Y + Z */
 #define CCL_MINUS      0x01    /* X = Y - Z */


@@ -701,6 +717,8 @@ while (0)
 
 /* Terminate CCL program because of invalid command.  Should not occur
    in the normal case.  */
 
 /* Terminate CCL program because of invalid command.  Should not occur
    in the normal case.  */

+#ifndef CCL_DEBUG
+

 #define CCL_INVALID_CMD                        \
 do                                     \
   {                                    \
 #define CCL_INVALID_CMD                        \
 do                                     \
   {                                    \


@@ -709,6 +727,19 @@ do                                 \
   }                                    \
 while(0)
 
   }                                    \
 while(0)
 

+#else
+
+#define CCL_INVALID_CMD                        \
+do                                     \
+  {                                    \
+    ccl_debug_hook (this_ic);          \
+    ccl->status = CCL_STAT_INVALID_CMD;        \
+    goto ccl_error_handler;            \
+  }                                    \
+while(0)
+
+#endif
+

 /* Encode one character CH to multibyte form and write to the current
    output buffer.  If CH is less than 256, CH is written as is.  */
 #define CCL_WRITE_CHAR(ch)                                             \
 /* Encode one character CH to multibyte form and write to the current
    output buffer.  If CH is less than 256, CH is written as is.  */
 #define CCL_WRITE_CHAR(ch)                                             \


@@ -721,7 +752,7 @@ while(0)
        if (bytes == 1)                                                 \
          {                                                             \
            *dst++ = (ch);                                              \
        if (bytes == 1)                                                 \
          {                                                             \
            *dst++ = (ch);                                              \

-           if ((ch) >= 0x80 && (ch) < 0xA0)                            \
+           if (extra_bytes && (ch) >= 0x80 && (ch) < 0xA0)             \

              /* We may have to convert this eight-bit char to          \
                 multibyte form later.  */                              \
              extra_bytes++;                                            \
              /* We may have to convert this eight-bit char to          \
                 multibyte form later.  */                              \
              extra_bytes++;                                            \


@@ -800,7 +831,8 @@ while(0)
       }                                                        \
     else if (ccl->last_block)                          \
       {                                                        \
       }                                                        \
     else if (ccl->last_block)                          \
       {                                                        \

-        ic = ccl->eof_ic;                              \
+       REG = -1;                                       \
+        ic = eof_ic;                                   \

         goto ccl_repeat;                               \
       }                                                        \
     else                                               \
         goto ccl_repeat;                               \
       }                                                        \
     else                                               \


@@ -843,17 +875,25 @@ while(0)
 
 #ifdef CCL_DEBUG
 #define CCL_DEBUG_BACKTRACE_LEN 256
 
 #ifdef CCL_DEBUG
 #define CCL_DEBUG_BACKTRACE_LEN 256

-int ccl_backtrace_table[CCL_BACKTRACE_TABLE];
+int ccl_backtrace_table[CCL_DEBUG_BACKTRACE_LEN];

 int ccl_backtrace_idx;
 int ccl_backtrace_idx;

+
+int
+ccl_debug_hook (int ic)
+{
+  return ic;
+}
+

 #endif
 
 struct ccl_prog_stack
   {
     Lisp_Object *ccl_prog;     /* Pointer to an array of CCL code.  */
     int ic;                    /* Instruction Counter.  */
 #endif
 
 struct ccl_prog_stack
   {
     Lisp_Object *ccl_prog;     /* Pointer to an array of CCL code.  */
     int ic;                    /* Instruction Counter.  */

+    int eof_ic;                        /* Instruction Counter to jump on EOF.  */

   };
 
   };
 

-/* For the moment, we only support depth 256 of stack.  */ 
+/* For the moment, we only support depth 256 of stack.  */

 static struct ccl_prog_stack ccl_prog_stack_struct[256];
 
 int
 static struct ccl_prog_stack ccl_prog_stack_struct[256];
 
 int


@@ -878,9 +918,11 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
      each of them will be converted to multibyte form of 2-byte
      sequence.  For that conversion, we remember how many more bytes
      we must keep in DESTINATION in this variable.  */
      each of them will be converted to multibyte form of 2-byte
      sequence.  For that conversion, we remember how many more bytes
      we must keep in DESTINATION in this variable.  */

-  int extra_bytes = 0;
+  int extra_bytes = ccl->eight_bit_control;
+  int eof_ic = ccl->eof_ic;
+  int eof_hit = 0;

 
 

-  if (ic >= ccl->eof_ic)
+  if (ic >= eof_ic)

     ic = CCL_HEADER_MAIN;
 
   if (ccl->buf_magnification == 0) /* We can't produce any bytes.  */
     ic = CCL_HEADER_MAIN;
 
   if (ccl->buf_magnification == 0) /* We can't produce any bytes.  */


@@ -1076,24 +1118,26 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
 
            if (stack_idx >= 256
                || prog_id < 0
 
            if (stack_idx >= 256
                || prog_id < 0

-               || prog_id >= XVECTOR (Vccl_program_table)->size
-               || (slot = XVECTOR (Vccl_program_table)->contents[prog_id],
-                   !VECTORP (slot))
-               || !VECTORP (XVECTOR (slot)->contents[1]))
+               || prog_id >= ASIZE (Vccl_program_table)
+               || (slot = AREF (Vccl_program_table, prog_id), !VECTORP (slot))
+               || !VECTORP (AREF (slot, 1)))

              {
                if (stack_idx > 0)
                  {
                    ccl_prog = ccl_prog_stack_struct[0].ccl_prog;
                    ic = ccl_prog_stack_struct[0].ic;
              {
                if (stack_idx > 0)
                  {
                    ccl_prog = ccl_prog_stack_struct[0].ccl_prog;
                    ic = ccl_prog_stack_struct[0].ic;

+                   eof_ic = ccl_prog_stack_struct[0].eof_ic;

                  }
                CCL_INVALID_CMD;
              }
                  }
                CCL_INVALID_CMD;
              }

-           
+

            ccl_prog_stack_struct[stack_idx].ccl_prog = ccl_prog;
            ccl_prog_stack_struct[stack_idx].ic = ic;
            ccl_prog_stack_struct[stack_idx].ccl_prog = ccl_prog;
            ccl_prog_stack_struct[stack_idx].ic = ic;

+           ccl_prog_stack_struct[stack_idx].eof_ic = eof_ic;

            stack_idx++;
            stack_idx++;

-           ccl_prog = XVECTOR (XVECTOR (slot)->contents[1])->contents;
+           ccl_prog = XVECTOR (AREF (slot, 1))->contents;

            ic = CCL_HEADER_MAIN;
            ic = CCL_HEADER_MAIN;

+           eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]);

          }
          break;
 
          }
          break;
 


@@ -1123,6 +1167,9 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
              stack_idx--;
              ccl_prog = ccl_prog_stack_struct[stack_idx].ccl_prog;
              ic = ccl_prog_stack_struct[stack_idx].ic;
              stack_idx--;
              ccl_prog = ccl_prog_stack_struct[stack_idx].ccl_prog;
              ic = ccl_prog_stack_struct[stack_idx].ic;

+             eof_ic = ccl_prog_stack_struct[stack_idx].eof_ic;
+             if (eof_hit)
+               ic = eof_ic;

              break;
            }
          if (src)
              break;
            }
          if (src)


@@ -1252,7 +1299,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                  src++;
                  goto ccl_read_multibyte_character_suspend;
                }
                  src++;
                  goto ccl_read_multibyte_character_suspend;
                }

-             
+

              if (!ccl->multibyte)
                {
                  int bytes;
              if (!ccl->multibyte)
                {
                  int bytes;


@@ -1266,7 +1313,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
              i = *src++;
              if (i == '\n' && ccl->eol_type != CODING_EOL_LF)
                {
              i = *src++;
              if (i == '\n' && ccl->eol_type != CODING_EOL_LF)
                {

-                 /* We are encoding.  */ 
+                 /* We are encoding.  */

                  if (ccl->eol_type == CODING_EOL_CRLF)
                    {
                      if (ccl->cr_consumed)
                  if (ccl->eol_type == CODING_EOL_CRLF)
                    {
                      if (ccl->cr_consumed)


@@ -1359,7 +1406,8 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
              src--;
              if (ccl->last_block)
                {
              src--;
              if (ccl->last_block)
                {

-                 ic = ccl->eof_ic;
+                 ic = eof_ic;
+                 eof_hit = 1;

                  goto ccl_repeat;
                }
              else
                  goto ccl_repeat;
                }
              else


@@ -1391,7 +1439,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
              SPLIT_CHAR (op, reg[RRR], i, j);
              if (j != -1)
                i = (i << 7) | j;
              SPLIT_CHAR (op, reg[RRR], i, j);
              if (j != -1)
                i = (i << 7) | j;

-             
+

              reg[rrr] = i;
              break;
 
              reg[rrr] = i;
              break;
 


@@ -1403,10 +1451,56 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
              SPLIT_CHAR (op, reg[RRR], i, j);
              if (j != -1)
                i = (i << 7) | j;
              SPLIT_CHAR (op, reg[RRR], i, j);
              if (j != -1)
                i = (i << 7) | j;

-             
+

              reg[rrr] = i;
              break;
 
              reg[rrr] = i;
              break;
 

+           case CCL_LookupIntConstTbl:
+             op = XINT (ccl_prog[ic]); /* table */
+             ic++;
+             {
+               struct Lisp_Hash_Table *h = GET_HASH_TABLE (op);
+
+               op = hash_lookup (h, make_number (reg[RRR]), NULL);
+               if (op >= 0)
+                 {
+                   Lisp_Object opl;
+                   opl = HASH_VALUE (h, op);
+                   if (!CHAR_VALID_P (XINT (opl), 0))
+                     CCL_INVALID_CMD;
+                   SPLIT_CHAR (XINT (opl), reg[RRR], i, j);
+                   if (j != -1)
+                     i = (i << 7) | j;
+                   reg[rrr] = i;
+                   reg[7] = 1; /* r7 true for success */
+                 }
+               else
+                 reg[7] = 0;
+             }
+             break;
+
+           case CCL_LookupCharConstTbl:
+             op = XINT (ccl_prog[ic]); /* table */
+             ic++;
+             CCL_MAKE_CHAR (reg[RRR], reg[rrr], i);
+             {
+               struct Lisp_Hash_Table *h = GET_HASH_TABLE (op);
+
+               op = hash_lookup (h, make_number (i), NULL);
+               if (op >= 0)
+                 {
+                   Lisp_Object opl;
+                   opl = HASH_VALUE (h, op);
+                   if (!INTEGERP (opl))
+                     CCL_INVALID_CMD;
+                   reg[RRR] = XINT (opl);
+                   reg[7] = 1; /* r7 true for success */
+                 }
+               else
+                 reg[7] = 0;
+             }
+             break;
+

            case CCL_IterateMultipleMap:
              {
                Lisp_Object map, content, attrib, value;
            case CCL_IterateMultipleMap:
              {
                Lisp_Object map, content, attrib, value;


@@ -1430,20 +1524,19 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                for (;i < j;i++)
                  {
 
                for (;i < j;i++)
                  {
 

-                   size = XVECTOR (Vcode_conversion_map_vector)->size;
+                   size = ASIZE (Vcode_conversion_map_vector);

                    point = XINT (ccl_prog[ic++]);
                    if (point >= size) continue;
                    point = XINT (ccl_prog[ic++]);
                    if (point >= size) continue;

-                   map =
-                     XVECTOR (Vcode_conversion_map_vector)->contents[point];
+                   map = AREF (Vcode_conversion_map_vector, point);

 
                    /* Check map varidity.  */
                    if (!CONSP (map)) continue;
                    map = XCDR (map);
                    if (!VECTORP (map)) continue;
 
                    /* Check map varidity.  */
                    if (!CONSP (map)) continue;
                    map = XCDR (map);
                    if (!VECTORP (map)) continue;

-                   size = XVECTOR (map)->size;
+                   size = ASIZE (map);

                    if (size <= 1) continue;
 
                    if (size <= 1) continue;
 

-                   content = XVECTOR (map)->contents[0];
+                   content = AREF (map, 0);

 
                    /* check map type,
                       [STARTPOINT VAL1 VAL2 ...] or
 
                    /* check map type,
                       [STARTPOINT VAL1 VAL2 ...] or


@@ -1453,18 +1546,18 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                        point = XUINT (content);
                        point = op - point + 1;
                        if (!((point >= 1) && (point < size))) continue;
                        point = XUINT (content);
                        point = op - point + 1;
                        if (!((point >= 1) && (point < size))) continue;

-                       content = XVECTOR (map)->contents[point];
+                       content = AREF (map, point);

                      }
                    else if (EQ (content, Qt))
                      {
                        if (size != 4) continue;
                      }
                    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];
+                       if ((op >= XUINT (AREF (map, 2)))
+                           && (op < XUINT (AREF (map, 3))))
+                         content = AREF (map, 1);

                        else
                          continue;
                      }
                        else
                          continue;
                      }

-                   else 
+                   else

                      continue;
 
                    if (NILP (content))
                      continue;
 
                    if (NILP (content))


@@ -1500,7 +1593,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                ic = fin_ic;
              }
              break;
                ic = fin_ic;
              }
              break;

-             
+

            case CCL_MapMultiple:
              {
                Lisp_Object map, content, attrib, value;
            case CCL_MapMultiple:
              {
                Lisp_Object map, content, attrib, value;


@@ -1586,8 +1679,8 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                        break;
                      }
                  }
                        break;
                      }
                  }

-               map_vector_size = XVECTOR (Vcode_conversion_map_vector)->size;
-               
+               map_vector_size = ASIZE (Vcode_conversion_map_vector);
+

                do {
                  for (;map_set_rest_length > 0;i++, ic++, map_set_rest_length--)
                    {
                do {
                  for (;map_set_rest_length > 0;i++, ic++, map_set_rest_length--)
                    {


@@ -1607,17 +1700,16 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                        }
 
                      if (point >= map_vector_size) continue;
                        }
 
                      if (point >= map_vector_size) continue;

-                     map = (XVECTOR (Vcode_conversion_map_vector)
-                            ->contents[point]);
+                     map = AREF (Vcode_conversion_map_vector, point);

 
                      /* Check map varidity.  */
                      if (!CONSP (map)) continue;
                      map = XCDR (map);
                      if (!VECTORP (map)) continue;
 
                      /* Check map varidity.  */
                      if (!CONSP (map)) continue;
                      map = XCDR (map);
                      if (!VECTORP (map)) continue;

-                     size = XVECTOR (map)->size;
+                     size = ASIZE (map);

                      if (size <= 1) continue;
 
                      if (size <= 1) continue;
 

-                     content = XVECTOR (map)->contents[0];
+                     content = AREF (map, 0);

 
                      /* check map type,
                         [STARTPOINT VAL1 VAL2 ...] or
 
                      /* check map type,
                         [STARTPOINT VAL1 VAL2 ...] or


@@ -1627,18 +1719,18 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                          point = XUINT (content);
                          point = op - point + 1;
                          if (!((point >= 1) && (point < size))) continue;
                          point = XUINT (content);
                          point = op - point + 1;
                          if (!((point >= 1) && (point < size))) continue;

-                         content = XVECTOR (map)->contents[point];
+                         content = AREF (map, point);

                        }
                      else if (EQ (content, Qt))
                        {
                          if (size != 4) continue;
                        }
                      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];
+                         if ((op >= XUINT (AREF (map, 2))) &&
+                             (op < XUINT (AREF (map, 3))))
+                           content = AREF (map, 1);

                          else
                            continue;
                        }
                          else
                            continue;
                        }

-                     else 
+                     else

                        continue;
 
                      if (NILP (content))
                        continue;
 
                      if (NILP (content))


@@ -1707,12 +1799,12 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                int size, point;
                j = XINT (ccl_prog[ic++]); /* map_id */
                op = reg[rrr];
                int size, point;
                j = XINT (ccl_prog[ic++]); /* map_id */
                op = reg[rrr];

-               if (j >= XVECTOR (Vcode_conversion_map_vector)->size)
+               if (j >= ASIZE (Vcode_conversion_map_vector))

                  {
                    reg[RRR] = -1;
                    break;
                  }
                  {
                    reg[RRR] = -1;
                    break;
                  }

-               map = XVECTOR (Vcode_conversion_map_vector)->contents[j];
+               map = AREF (Vcode_conversion_map_vector, j);

                if (!CONSP (map))
                  {
                    reg[RRR] = -1;
                if (!CONSP (map))
                  {
                    reg[RRR] = -1;


@@ -1724,8 +1816,8 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                    reg[RRR] = -1;
                    break;
                  }
                    reg[RRR] = -1;
                    break;
                  }

-               size = XVECTOR (map)->size;
-               point = XUINT (XVECTOR (map)->contents[0]);
+               size = ASIZE (map);
+               point = XUINT (AREF (map, 0));

                point = op - point + 1;
                reg[RRR] = 0;
                if ((size <= 1) ||
                point = op - point + 1;
                reg[RRR] = 0;
                if ((size <= 1) ||


@@ -1734,7 +1826,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                else
                  {
                    reg[RRR] = 0;
                else
                  {
                    reg[RRR] = 0;

-                   content = XVECTOR (map)->contents[point];
+                   content = AREF (map, point);

                    if (NILP (content))
                      reg[RRR] = -1;
                    else if (NUMBERP (content))
                    if (NILP (content))
                      reg[RRR] = -1;
                    else if (NUMBERP (content))


@@ -1756,7 +1848,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
                  }
              }
              break;
                  }
              }
              break;

-             
+

            default:
              CCL_INVALID_CMD;
            }
            default:
              CCL_INVALID_CMD;
            }


@@ -1820,7 +1912,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
          break;
 
        default:
          break;
 
        default:

-         sprintf(msg, "\nCCL: Unknown error type (%d).", ccl->status);
+         sprintf(msg, "\nCCL: Unknown error type (%d)", ccl->status);

        }
 
       msglen = strlen (msg);
        }
 
       msglen = strlen (msg);


@@ -1829,7 +1921,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
          bcopy (msg, dst, msglen);
          dst += msglen;
        }
          bcopy (msg, dst, msglen);
          dst += msglen;
        }

-      
+

       if (ccl->status == CCL_STAT_INVALID_CMD)
        {
 #if 0 /* If the remaining bytes contain 0x80..0x9F, copying them
       if (ccl->status == CCL_STAT_INVALID_CMD)
        {
 #if 0 /* If the remaining bytes contain 0x80..0x9F, copying them


@@ -1853,7 +1945,7 @@ ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
   ccl->ic = ic;
   ccl->stack_idx = stack_idx;
   ccl->prog = ccl_prog;
   ccl->ic = ic;
   ccl->stack_idx = stack_idx;
   ccl->prog = ccl_prog;

-  ccl->eight_bit_control = (extra_bytes > 0);
+  ccl->eight_bit_control = (extra_bytes > 1);

   if (consumed)
     *consumed = src - source;
   return (dst ? dst - destination : 0);
   if (consumed)
     *consumed = src - source;
   return (dst ? dst - destination : 0);


@@ -1875,11 +1967,11 @@ resolve_symbol_ccl_program (ccl)
   Lisp_Object result, contents, val;
 
   result = ccl;
   Lisp_Object result, contents, val;
 
   result = ccl;

-  veclen = XVECTOR (result)->size;
+  veclen = ASIZE (result);

 
   for (i = 0; i < veclen; i++)
     {
 
   for (i = 0; i < veclen; i++)
     {

-      contents = XVECTOR (result)->contents[i];
+      contents = AREF (result, i);

       if (INTEGERP (contents))
        continue;
       else if (CONSP (contents)
       if (INTEGERP (contents))
        continue;
       else if (CONSP (contents)


@@ -1895,7 +1987,7 @@ resolve_symbol_ccl_program (ccl)
 
          val = Fget (XCAR (contents), XCDR (contents));
          if (NATNUMP (val))
 
          val = Fget (XCAR (contents), XCDR (contents));
          if (NATNUMP (val))

-           XVECTOR (result)->contents[i] = val;
+           AREF (result, i) = val;

          else
            unresolved = 1;
          continue;
          else
            unresolved = 1;
          continue;


@@ -1910,17 +2002,17 @@ resolve_symbol_ccl_program (ccl)
 
          val = Fget (contents, Qtranslation_table_id);
          if (NATNUMP (val))
 
          val = Fget (contents, Qtranslation_table_id);
          if (NATNUMP (val))

-           XVECTOR (result)->contents[i] = val;
+           AREF (result, i) = val;

          else
            {
              val = Fget (contents, Qcode_conversion_map_id);
              if (NATNUMP (val))
          else
            {
              val = Fget (contents, Qcode_conversion_map_id);
              if (NATNUMP (val))

-               XVECTOR (result)->contents[i] = val;
+               AREF (result, i) = val;

              else
                {
                  val = Fget (contents, Qccl_program_idx);
                  if (NATNUMP (val))
              else
                {
                  val = Fget (contents, Qccl_program_idx);
                  if (NATNUMP (val))

-                   XVECTOR (result)->contents[i] = val;
+                   AREF (result, i) = val;

                  else
                    unresolved = 1;
                }
                  else
                    unresolved = 1;
                }


@@ -1940,14 +2032,16 @@ resolve_symbol_ccl_program (ccl)
    symbols, return Qnil.  */
 
 static Lisp_Object
    symbols, return Qnil.  */
 
 static Lisp_Object

-ccl_get_compiled_code (ccl_prog)
+ccl_get_compiled_code (ccl_prog, idx)

      Lisp_Object ccl_prog;
      Lisp_Object ccl_prog;

+     int *idx;

 {
   Lisp_Object val, slot;
 
   if (VECTORP (ccl_prog))
     {
       val = resolve_symbol_ccl_program (ccl_prog);
 {
   Lisp_Object val, slot;
 
   if (VECTORP (ccl_prog))
     {
       val = resolve_symbol_ccl_program (ccl_prog);

+      *idx = -1;

       return (VECTORP (val) ? val : Qnil);
     }
   if (!SYMBOLP (ccl_prog))
       return (VECTORP (val) ? val : Qnil);
     }
   if (!SYMBOLP (ccl_prog))


@@ -1955,22 +2049,23 @@ ccl_get_compiled_code (ccl_prog)
 
   val = Fget (ccl_prog, Qccl_program_idx);
   if (! NATNUMP (val)
 
   val = Fget (ccl_prog, Qccl_program_idx);
   if (! NATNUMP (val)

-      || XINT (val) >= XVECTOR (Vccl_program_table)->size)
+      || XINT (val) >= ASIZE (Vccl_program_table))

     return Qnil;
     return Qnil;

-  slot = XVECTOR (Vccl_program_table)->contents[XINT (val)];
+  slot = AREF (Vccl_program_table, XINT (val));

   if (! VECTORP (slot)
   if (! VECTORP (slot)

-      || XVECTOR (slot)->size != 3
-      || ! VECTORP (XVECTOR (slot)->contents[1]))
+      || ASIZE (slot) != 4
+      || ! VECTORP (AREF (slot, 1)))

     return Qnil;
     return Qnil;

-  if (NILP (XVECTOR (slot)->contents[2]))
+  *idx = XINT (val);
+  if (NILP (AREF (slot, 2)))

     {
     {

-      val = resolve_symbol_ccl_program (XVECTOR (slot)->contents[1]);
+      val = resolve_symbol_ccl_program (AREF (slot, 1));

       if (! VECTORP (val))
        return Qnil;
       if (! VECTORP (val))
        return Qnil;

-      XVECTOR (slot)->contents[1] = val;
-      XVECTOR (slot)->contents[2] = Qt;
+      AREF (slot, 1) = val;
+      AREF (slot, 2) = Qt;

     }
     }

-  return XVECTOR (slot)->contents[1];
+  return AREF (slot, 1);

 }
 
 /* Setup fields of the structure pointed by CCL appropriately for the
 }
 
 /* Setup fields of the structure pointed by CCL appropriately for the


@@ -1990,7 +2085,7 @@ setup_ccl_program (ccl, ccl_prog)
     {
       struct Lisp_Vector *vp;
 
     {
       struct Lisp_Vector *vp;
 

-      ccl_prog = ccl_get_compiled_code (ccl_prog);
+      ccl_prog = ccl_get_compiled_code (ccl_prog, &ccl->idx);

       if (! VECTORP (ccl_prog))
        return -1;
       vp = XVECTOR (ccl_prog);
       if (! VECTORP (ccl_prog))
        return -1;
       vp = XVECTOR (ccl_prog);


@@ -1998,6 +2093,13 @@ setup_ccl_program (ccl, ccl_prog)
       ccl->prog = vp->contents;
       ccl->eof_ic = XINT (vp->contents[CCL_HEADER_EOF]);
       ccl->buf_magnification = XINT (vp->contents[CCL_HEADER_BUF_MAG]);
       ccl->prog = vp->contents;
       ccl->eof_ic = XINT (vp->contents[CCL_HEADER_EOF]);
       ccl->buf_magnification = XINT (vp->contents[CCL_HEADER_BUF_MAG]);

+      if (ccl->idx >= 0)
+       {
+         Lisp_Object slot;
+
+         slot = AREF (Vccl_program_table, ccl->idx);
+         ASET (slot, 3, Qnil);
+       }

     }
   ccl->ic = CCL_HEADER_MAIN;
   for (i = 0; i < 8; i++)
     }
   ccl->ic = CCL_HEADER_MAIN;
   for (i = 0; i < 8; i++)


@@ -2008,10 +2110,35 @@ setup_ccl_program (ccl, ccl_prog)
   ccl->stack_idx = 0;
   ccl->eol_type = CODING_EOL_LF;
   ccl->suppress_error = 0;
   ccl->stack_idx = 0;
   ccl->eol_type = CODING_EOL_LF;
   ccl->suppress_error = 0;

+  ccl->eight_bit_control = 0;
+  return 0;
+}
+
+
+/* Check if CCL is updated or not.  If not, re-setup members of CCL.  */
+
+int
+check_ccl_update (ccl)
+     struct ccl_program *ccl;
+{
+  Lisp_Object slot, ccl_prog;
+
+  if (ccl->idx < 0)
+    return 0;
+  slot = AREF (Vccl_program_table, ccl->idx);
+  if (NILP (AREF (slot, 3)))
+    return 0;
+  ccl_prog = ccl_get_compiled_code (AREF (slot, 0), &ccl->idx);
+  if (! VECTORP (ccl_prog))
+    return -1;
+  ccl->size = ASIZE (ccl_prog);
+  ccl->prog = XVECTOR (ccl_prog)->contents;
+  ccl->eof_ic = XINT (AREF (ccl_prog, CCL_HEADER_EOF));
+  ccl->buf_magnification = XINT (AREF (ccl_prog, CCL_HEADER_BUF_MAG));
+  ASET (slot, 3, Qnil);

   return 0;
 }
 
   return 0;
 }
 

-#ifdef emacs

 
 DEFUN ("ccl-program-p", Fccl_program_p, Sccl_program_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a CCL program name or a compiled CCL program code.
 
 DEFUN ("ccl-program-p", Fccl_program_p, Sccl_program_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a CCL program name or a compiled CCL program code.


@@ -2031,7 +2158,7 @@ See the documentation of  `define-ccl-program' for the detail of CCL program.  *
 
   val = Fget (object, Qccl_program_idx);
   return ((! NATNUMP (val)
 
   val = Fget (object, Qccl_program_idx);
   return ((! NATNUMP (val)

-          || XINT (val) >= XVECTOR (Vccl_program_table)->size)
+          || XINT (val) >= ASIZE (Vccl_program_table))

          ? Qnil : Qt);
 }
 
          ? Qnil : Qt);
 }
 


@@ -2061,12 +2188,12 @@ programs.  */)
     error ("Invalid CCL program");
 
   CHECK_VECTOR (reg);
     error ("Invalid CCL program");
 
   CHECK_VECTOR (reg);

-  if (XVECTOR (reg)->size != 8)
+  if (ASIZE (reg) != 8)

     error ("Length of vector REGISTERS is not 8");
 
   for (i = 0; i < 8; i++)
     error ("Length of vector REGISTERS is not 8");
 
   for (i = 0; i < 8; i++)

-    ccl.reg[i] = (INTEGERP (XVECTOR (reg)->contents[i])
-                 ? XINT (XVECTOR (reg)->contents[i])
+    ccl.reg[i] = (INTEGERP (AREF (reg, i))
+                 ? XINT (AREF (reg, i))

                  : 0);
 
   ccl_driver (&ccl, (unsigned char *)0, (unsigned char *)0, 0, 0, (int *)0);
                  : 0);
 
   ccl_driver (&ccl, (unsigned char *)0, (unsigned char *)0, 0, 0, (int *)0);


@@ -2075,7 +2202,7 @@ programs.  */)
     error ("Error in CCL program at %dth code", ccl.ic);
 
   for (i = 0; i < 8; i++)
     error ("Error in CCL program at %dth code", ccl.ic);
 
   for (i = 0; i < 8; i++)

-    XSETINT (XVECTOR (reg)->contents[i], ccl.reg[i]);
+    XSETINT (AREF (reg, i), ccl.reg[i]);

   return Qnil;
 }
 
   return Qnil;
 }
 


@@ -2083,7 +2210,7 @@ DEFUN ("ccl-execute-on-string", Fccl_execute_on_string, Sccl_execute_on_string,
        3, 5, 0,
        doc: /* Execute CCL-PROGRAM with initial STATUS on STRING.
 
        3, 5, 0,
        doc: /* Execute CCL-PROGRAM with initial STATUS on STRING.
 

-CCL-PROGRAM is a symbol registered by register-ccl-program,
+CCL-PROGRAM is a symbol registered by `register-ccl-program',

 or a compiled code generated by `ccl-compile' (for backward compatibility,
 in this case, the execution is slower).
 
 or a compiled code generated by `ccl-compile' (for backward compatibility,
 in this case, the execution is slower).
 


@@ -2104,7 +2231,8 @@ It returns the contents of write buffer as a string,
 If the optional 5th arg UNIBYTE-P is non-nil, the returned string
 is a unibyte string.  By default it is a multibyte string.
 
 If the optional 5th arg UNIBYTE-P is non-nil, the returned string
 is a unibyte string.  By default it is a multibyte string.
 

-See the documentation of `define-ccl-program' for the detail of CCL program.  */)
+See the documentation of `define-ccl-program' for the detail of CCL program.
+usage: (ccl-execute-on-string CCL-PROGRAM STATUS STRING &optional CONTINUE UNIBYTE-P)  */)

      (ccl_prog, status, str, contin, unibyte_p)
      Lisp_Object ccl_prog, status, str, contin, unibyte_p;
 {
      (ccl_prog, status, str, contin, unibyte_p)
      Lisp_Object ccl_prog, status, str, contin, unibyte_p;
 {


@@ -2119,7 +2247,7 @@ See the documentation of `define-ccl-program' for the detail of CCL program.  */
     error ("Invalid CCL program");
 
   CHECK_VECTOR (status);
     error ("Invalid CCL program");
 
   CHECK_VECTOR (status);

-  if (XVECTOR (status)->size != 9)
+  if (ASIZE (status) != 9)

     error ("Length of vector STATUS is not 9");
   CHECK_STRING (str);
 
     error ("Length of vector STATUS is not 9");
   CHECK_STRING (str);
 


@@ -2127,26 +2255,26 @@ See the documentation of `define-ccl-program' for the detail of CCL program.  */
 
   for (i = 0; i < 8; i++)
     {
 
   for (i = 0; i < 8; i++)
     {

-      if (NILP (XVECTOR (status)->contents[i]))
-       XSETINT (XVECTOR (status)->contents[i], 0);
-      if (INTEGERP (XVECTOR (status)->contents[i]))
-       ccl.reg[i] = XINT (XVECTOR (status)->contents[i]);
+      if (NILP (AREF (status, i)))
+       XSETINT (AREF (status, i), 0);
+      if (INTEGERP (AREF (status, i)))
+       ccl.reg[i] = XINT (AREF (status, i));

     }
     }

-  if (INTEGERP (XVECTOR (status)->contents[i]))
+  if (INTEGERP (AREF (status, i)))

     {
     {

-      i = XFASTINT (XVECTOR (status)->contents[8]);
+      i = XFASTINT (AREF (status, 8));

       if (ccl.ic < i && i < ccl.size)
        ccl.ic = i;
     }
       if (ccl.ic < i && i < ccl.size)
        ccl.ic = i;
     }

-  outbufsize = STRING_BYTES (XSTRING (str)) * ccl.buf_magnification + 256;
+  outbufsize = SBYTES (str) * ccl.buf_magnification + 256;

   outbuf = (char *) xmalloc (outbufsize);
   ccl.last_block = NILP (contin);
   ccl.multibyte = STRING_MULTIBYTE (str);
   outbuf = (char *) xmalloc (outbufsize);
   ccl.last_block = NILP (contin);
   ccl.multibyte = STRING_MULTIBYTE (str);

-  produced = ccl_driver (&ccl, XSTRING (str)->data, outbuf,
-                        STRING_BYTES (XSTRING (str)), outbufsize, (int *) 0);
+  produced = ccl_driver (&ccl, SDATA (str), outbuf,
+                        SBYTES (str), outbufsize, (int *) 0);

   for (i = 0; i < 8; i++)
   for (i = 0; i < 8; i++)

-    XSET (XVECTOR (status)->contents[i], Lisp_Int, ccl.reg[i]);
-  XSETINT (XVECTOR (status)->contents[8], ccl.ic);
+    ASET (status, i, make_number (ccl.reg[i]));
+  ASET (status, 8, make_number (ccl.ic));

   UNGCPRO;
 
   if (NILP (unibyte_p))
   UNGCPRO;
 
   if (NILP (unibyte_p))


@@ -2171,14 +2299,14 @@ See the documentation of `define-ccl-program' for the detail of CCL program.  */
 
 DEFUN ("register-ccl-program", Fregister_ccl_program, Sregister_ccl_program,
        2, 2, 0,
 
 DEFUN ("register-ccl-program", Fregister_ccl_program, Sregister_ccl_program,
        2, 2, 0,

-       doc: /* Register CCL program CCL_PROG as NAME in `ccl-program-table'.
-CCL_PROG should be a compiled CCL program (vector), or nil.
+       doc: /* Register CCL program CCL-PROG as NAME in `ccl-program-table'.
+CCL-PROG should be a compiled CCL program (vector), or nil.

 If it is nil, just reserve NAME as a CCL program name.
 Return index number of the registered CCL program.  */)
      (name, ccl_prog)
      Lisp_Object name, ccl_prog;
 {
 If it is nil, just reserve NAME as a CCL program name.
 Return index number of the registered CCL program.  */)
      (name, ccl_prog)
      Lisp_Object name, ccl_prog;
 {

-  int len = XVECTOR (Vccl_program_table)->size;
+  int len = ASIZE (Vccl_program_table);

   int idx;
   Lisp_Object resolved;
 
   int idx;
   Lisp_Object resolved;
 


@@ -2203,16 +2331,17 @@ Return index number of the registered CCL program.  */)
     {
       Lisp_Object slot;
 
     {
       Lisp_Object slot;
 

-      slot = XVECTOR (Vccl_program_table)->contents[idx];
+      slot = AREF (Vccl_program_table, idx);

       if (!VECTORP (slot))
        /* This is the first unsed slot.  Register NAME here.  */
        break;
 
       if (!VECTORP (slot))
        /* This is the first unsed slot.  Register NAME here.  */
        break;
 

-      if (EQ (name, XVECTOR (slot)->contents[0]))
+      if (EQ (name, AREF (slot, 0)))

        {
          /* Update this slot.  */
        {
          /* Update this slot.  */

-         XVECTOR (slot)->contents[1] = ccl_prog;
-         XVECTOR (slot)->contents[2] = resolved;
+         ASET (slot, 1, ccl_prog);
+         ASET (slot, 2, resolved);
+         ASET (slot, 3, Qt);

          return make_number (idx);
        }
     }
          return make_number (idx);
        }
     }


@@ -2225,19 +2354,19 @@ Return index number of the registered CCL program.  */)
 
       new_table = Fmake_vector (make_number (len * 2), Qnil);
       for (j = 0; j < len; j++)
 
       new_table = Fmake_vector (make_number (len * 2), Qnil);
       for (j = 0; j < len; j++)

-       XVECTOR (new_table)->contents[j]
-         = XVECTOR (Vccl_program_table)->contents[j];
+       ASET (new_table, j, AREF (Vccl_program_table, j));

       Vccl_program_table = new_table;
     }
 
   {
     Lisp_Object elt;
 
       Vccl_program_table = new_table;
     }
 
   {
     Lisp_Object elt;
 

-    elt = Fmake_vector (make_number (3), Qnil);
-    XVECTOR (elt)->contents[0] = name;
-    XVECTOR (elt)->contents[1] = ccl_prog;
-    XVECTOR (elt)->contents[2] = resolved;
-    XVECTOR (Vccl_program_table)->contents[idx] = elt;
+    elt = Fmake_vector (make_number (4), Qnil);
+    ASET (elt, 0, name);
+    ASET (elt, 1, ccl_prog);
+    ASET (elt, 2, resolved);
+    ASET (elt, 3, Qt);
+    ASET (Vccl_program_table, idx, elt);

   }
 
   Fput (name, Qccl_program_idx, make_number (idx));
   }
 
   Fput (name, Qccl_program_idx, make_number (idx));


@@ -2261,16 +2390,16 @@ Return index number of the registered map.  */)
      (symbol, map)
      Lisp_Object symbol, map;
 {
      (symbol, map)
      Lisp_Object symbol, map;
 {

-  int len = XVECTOR (Vcode_conversion_map_vector)->size;
+  int len = ASIZE (Vcode_conversion_map_vector);

   int i;
   Lisp_Object index;
 
   CHECK_SYMBOL (symbol);
   CHECK_VECTOR (map);
   int i;
   Lisp_Object index;
 
   CHECK_SYMBOL (symbol);
   CHECK_VECTOR (map);

-  
+

   for (i = 0; i < len; i++)
     {
   for (i = 0; i < len; i++)
     {

-      Lisp_Object slot = XVECTOR (Vcode_conversion_map_vector)->contents[i];
+      Lisp_Object slot = AREF (Vcode_conversion_map_vector, i);

 
       if (!CONSP (slot))
        break;
 
       if (!CONSP (slot))
        break;


@@ -2291,15 +2420,15 @@ Return index number of the registered map.  */)
       int j;
 
       for (j = 0; j < len; j++)
       int j;
 
       for (j = 0; j < len; j++)

-       XVECTOR (new_vector)->contents[j]
-         = XVECTOR (Vcode_conversion_map_vector)->contents[j];
+       AREF (new_vector, j)
+         = AREF (Vcode_conversion_map_vector, j);

       Vcode_conversion_map_vector = new_vector;
     }
 
   index = make_number (i);
   Fput (symbol, Qcode_conversion_map, map);
   Fput (symbol, Qcode_conversion_map_id, index);
       Vcode_conversion_map_vector = new_vector;
     }
 
   index = make_number (i);
   Fput (symbol, Qcode_conversion_map, map);
   Fput (symbol, Qcode_conversion_map_id, index);

-  XVECTOR (Vcode_conversion_map_vector)->contents[i] = Fcons (symbol, map);
+  AREF (Vcode_conversion_map_vector, i) = Fcons (symbol, map);

   return index;
 }
 
   return index;
 }
 


@@ -2339,6 +2468,13 @@ The code point in the font is set in CCL registers R1 and R2
  If the font is single-byte font, the register R2 is not used.  */);
   Vfont_ccl_encoder_alist = Qnil;
 
  If the font is single-byte font, the register R2 is not used.  */);
   Vfont_ccl_encoder_alist = Qnil;
 

+  DEFVAR_LISP ("translation-hash-table-vector", &Vtranslation_hash_table_vector,
+    doc: /* Vector containing all translation hash tables ever defined.
+Comprises pairs (SYMBOL . TABLE) where SYMBOL and TABLE were set up by calls
+to `define-translation-hash-table'.  The vector is indexed by the table id
+used by CCL.  */);
+    Vtranslation_hash_table_vector = Qnil;
+

   defsubr (&Sccl_program_p);
   defsubr (&Sccl_execute);
   defsubr (&Sccl_execute_on_string);
   defsubr (&Sccl_program_p);
   defsubr (&Sccl_execute);
   defsubr (&Sccl_execute_on_string);


@@ -2346,4 +2482,5 @@ The code point in the font is set in CCL registers R1 and R2
   defsubr (&Sregister_code_conversion_map);
 }
 
   defsubr (&Sregister_code_conversion_map);
 }
 

-#endif  /* emacs */
+/* arch-tag: bb9a37be-68ce-4576-8d3d-15d750e4a860
+   (do not change this comment) */