/* 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.
This file is part of GNU Emacs.
static int stack_idx_of_map_multiple;
#define PUSH_MAPPING_STACK(restlen, orig) \
- do { \
+do \
+ { \
mapping_stack_pointer->rest_length = (restlen); \
mapping_stack_pointer->orig_val = (orig); \
mapping_stack_pointer++; \
- } while (0)
+ } \
+while (0)
#define POP_MAPPING_STACK(restlen, orig) \
- do { \
+do \
+ { \
mapping_stack_pointer--; \
(restlen) = mapping_stack_pointer->rest_length; \
(orig) = mapping_stack_pointer->orig_val; \
- } while (0)
+ } \
+while (0)
#define CCL_CALL_FOR_MAP_INSTRUCTION(symbol, ret_ic) \
-if (1) \
+do \
{ \
struct ccl_program called_ccl; \
if (stack_idx >= 256 \
ic = CCL_HEADER_MAIN; \
goto ccl_repeat; \
} \
-else
+while (0)
#define CCL_MapSingle 0x12 /* Map by single code conversion map
1:ExtendedCOMMNDXXXRRRrrrXXXXX
/* Terminate CCL program successfully. */
#define CCL_SUCCESS \
-if (1) \
+do \
{ \
ccl->status = CCL_STAT_SUCCESS; \
goto ccl_finish; \
} \
-else
+while(0)
/* Suspend CCL program because of reading from empty input buffer or
writing to full output buffer. When this program is resumed, the
same I/O command is executed. */
#define CCL_SUSPEND(stat) \
-if (1) \
+do \
{ \
ic--; \
ccl->status = stat; \
goto ccl_finish; \
} \
-else
+while (0)
/* Terminate CCL program because of invalid command. Should not occur
in the normal case. */
#define CCL_INVALID_CMD \
-if (1) \
+do \
{ \
ccl->status = CCL_STAT_INVALID_CMD; \
goto ccl_error_handler; \
} \
-else
+while(0)
/* 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. */
CCL_SUSPEND (CCL_STAT_SUSPEND_BY_DST); \
} while (0)
+/* Encode one character CH to multibyte form and write to the current
+ output buffer. The output bytes always forms a valid multibyte
+ sequence. */
+#define CCL_WRITE_MULTIBYTE_CHAR(ch) \
+ do { \
+ int bytes = CHAR_BYTES (ch); \
+ if (!dst) \
+ CCL_INVALID_CMD; \
+ else if (dst + bytes + extra_bytes < (dst_bytes ? dst_end : src)) \
+ { \
+ if (CHAR_VALID_P ((ch), 0)) \
+ dst += CHAR_STRING ((ch), dst); \
+ else \
+ CCL_INVALID_CMD; \
+ } \
+ else \
+ CCL_SUSPEND (CCL_STAT_SUSPEND_BY_DST); \
+ } while (0)
+
/* Write a string at ccl_prog[IC] of length LEN to the current output
buffer. */
#define CCL_WRITE_STRING(len) \
{
register int *reg = ccl->reg;
register int ic = ccl->ic;
- register int code, field1, field2;
+ register int code = 0, field1, field2;
register Lisp_Object *ccl_prog = ccl->prog;
unsigned char *src = source, *src_end = src + src_bytes;
unsigned char *dst = destination, *dst_end = dst + dst_bytes;
int jump_address;
- int i, j, op;
+ int i = 0, j, op;
int stack_idx = ccl->stack_idx;
/* Instruction counter of the current CCL code. */
- int this_ic;
+ int this_ic = 0;
/* CCL_WRITE_CHAR will produce 8-bit code of range 0x80..0x9F. But,
each of them will be converted to multibyte form of 2-byte
sequence. For that conversion, we remember how many more bytes
if (ic >= ccl->eof_ic)
ic = CCL_HEADER_MAIN;
- if (ccl->buf_magnification ==0) /* We can't produce any bytes. */
+ if (ccl->buf_magnification == 0) /* We can't produce any bytes. */
dst = NULL;
/* Set mapping stack pointer. */
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_stack_struct[stack_idx].ccl_prog = ccl_prog;
ccl_prog_stack_struct[stack_idx].ic = ic;
stack_idx++;
- ccl_prog = XVECTOR (XVECTOR (slot)->contents[1])->contents;
+ ccl_prog = XVECTOR (AREF (slot, 1))->contents;
ic = CCL_HEADER_MAIN;
}
break;
goto ccl_read_multibyte_character_suspend;
}
+ if (!ccl->multibyte)
+ {
+ int bytes;
+ if (!UNIBYTE_STR_AS_MULTIBYTE_P (src, src_end - src, bytes))
+ {
+ reg[RRR] = CHARSET_8_BIT_CONTROL;
+ reg[rrr] = *src++;
+ break;
+ }
+ }
i = *src++;
if (i == '\n' && ccl->eol_type != CODING_EOL_LF)
{
break;
ccl_read_multibyte_character_suspend:
+ if (src <= src_end && !ccl->multibyte && ccl->last_block)
+ {
+ reg[RRR] = CHARSET_8_BIT_CONTROL;
+ reg[rrr] = i;
+ break;
+ }
src--;
if (ccl->last_block)
{
else
i = ((i - 0xE0) << 14) | reg[rrr];
- CCL_WRITE_CHAR (i);
+ CCL_WRITE_MULTIBYTE_CHAR (i);
break;
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;
- 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;
- size = XVECTOR (map)->size;
+ size = ASIZE (map);
if (size <= 1) continue;
- content = XVECTOR (map)->contents[0];
+ content = AREF (map, 0);
/* check map type,
[STARTPOINT VAL1 VAL2 ...] or
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;
- 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;
}
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--)
}
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;
- size = XVECTOR (map)->size;
+ size = ASIZE (map);
if (size <= 1) continue;
- content = XVECTOR (map)->contents[0];
+ content = AREF (map, 0);
/* check map type,
[STARTPOINT VAL1 VAL2 ...] or
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;
- 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;
}
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;
}
- map = XVECTOR (Vcode_conversion_map_vector)->contents[j];
+ map = AREF (Vcode_conversion_map_vector, j);
if (!CONSP (map))
{
reg[RRR] = -1;
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) ||
else
{
reg[RRR] = 0;
- content = XVECTOR (map)->contents[point];
+ content = AREF (map, point);
if (NILP (content))
reg[RRR] = -1;
else if (NUMBERP (content))
bcopy (msg, dst, msglen);
dst += msglen;
}
+
if (ccl->status == CCL_STAT_INVALID_CMD)
{
+#if 0 /* If the remaining bytes contain 0x80..0x9F, copying them
+ results in an invalid multibyte sequence. */
+
/* Copy the remaining source data. */
int i = src_end - src;
if (dst_bytes && (dst_end - dst) < i)
bcopy (src, dst, i);
src += i;
dst += i;
+#else
+ /* Signal that we've consumed everything. */
+ src = src_end;
+#endif
}
}
ccl->ic = ic;
ccl->stack_idx = stack_idx;
ccl->prog = ccl_prog;
- if (consumed) *consumed = src - source;
+ ccl->eight_bit_control = (extra_bytes > 0);
+ if (consumed)
+ *consumed = src - source;
return (dst ? dst - destination : 0);
}
Lisp_Object result, contents, val;
result = ccl;
- veclen = XVECTOR (result)->size;
+ veclen = ASIZE (result);
for (i = 0; i < veclen; i++)
{
- contents = XVECTOR (result)->contents[i];
+ contents = AREF (result, i);
if (INTEGERP (contents))
continue;
else if (CONSP (contents)
val = Fget (XCAR (contents), XCDR (contents));
if (NATNUMP (val))
- XVECTOR (result)->contents[i] = val;
+ AREF (result, i) = val;
else
unresolved = 1;
continue;
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))
- XVECTOR (result)->contents[i] = val;
+ AREF (result, i) = val;
else
{
val = Fget (contents, Qccl_program_idx);
if (NATNUMP (val))
- XVECTOR (result)->contents[i] = val;
+ AREF (result, i) = val;
else
unresolved = 1;
}
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;
- slot = XVECTOR (Vccl_program_table)->contents[XINT (val)];
+ slot = AREF (Vccl_program_table, XINT (val));
if (! VECTORP (slot)
- || XVECTOR (slot)->size != 3
- || ! VECTORP (XVECTOR (slot)->contents[1]))
+ || ASIZE (slot) != 3
+ || ! VECTORP (AREF (slot, 1)))
return Qnil;
- if (NILP (XVECTOR (slot)->contents[2]))
+ 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;
- 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
#ifdef emacs
DEFUN ("ccl-program-p", Fccl_program_p, Sccl_program_p, 1, 1, 0,
- "Return t if OBJECT is a CCL program name or a compiled CCL program code.\n\
-See the documentation of `define-ccl-program' for the detail of CCL program.")
- (object)
+ doc: /* Return t if OBJECT is a CCL program name or a compiled CCL program code.
+See the documentation of `define-ccl-program' for the detail of CCL program. */)
+ (object)
Lisp_Object object;
{
Lisp_Object 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);
}
DEFUN ("ccl-execute", Fccl_execute, Sccl_execute, 2, 2, 0,
- "Execute CCL-PROGRAM with registers initialized by REGISTERS.\n\
-\n\
-CCL-PROGRAM is a CCL program name (symbol)\n\
-or a compiled code generated by `ccl-compile' (for backward compatibility,\n\
-in this case, the overhead of the execution is bigger than the former case).\n\
-No I/O commands should appear in CCL-PROGRAM.\n\
-\n\
-REGISTERS is a vector of [R0 R1 ... R7] where RN is an initial value\n\
- of Nth register.\n\
-\n\
-As side effect, each element of REGISTERS holds the value of\n\
- corresponding register after the execution.\n\
-\n\
-See the documentation of `define-ccl-program' for the detail of CCL program.")
- (ccl_prog, reg)
+ doc: /* Execute CCL-PROGRAM with registers initialized by REGISTERS.
+
+CCL-PROGRAM is a CCL program name (symbol)
+or compiled code generated by `ccl-compile' (for backward compatibility.
+In the latter case, the execution overhead is bigger than in the former).
+No I/O commands should appear in CCL-PROGRAM.
+
+REGISTERS is a vector of [R0 R1 ... R7] where RN is an initial value
+for the Nth register.
+
+As side effect, each element of REGISTERS holds the value of
+the corresponding register after the execution.
+
+See the documentation of `define-ccl-program' for a definition of CCL
+programs. */)
+ (ccl_prog, reg)
Lisp_Object ccl_prog, reg;
{
struct ccl_program ccl;
if (setup_ccl_program (&ccl, ccl_prog) < 0)
error ("Invalid CCL program");
- CHECK_VECTOR (reg, 1);
- if (XVECTOR (reg)->size != 8)
+ CHECK_VECTOR (reg);
+ if (ASIZE (reg) != 8)
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);
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;
}
DEFUN ("ccl-execute-on-string", Fccl_execute_on_string, Sccl_execute_on_string,
3, 5, 0,
- "Execute CCL-PROGRAM with initial STATUS on STRING.\n\
-\n\
-CCL-PROGRAM is a symbol registered by register-ccl-program,\n\
-or a compiled code generated by `ccl-compile' (for backward compatibility,\n\
-in this case, the execution is slower).\n\
-\n\
-Read buffer is set to STRING, and write buffer is allocated automatically.\n\
-\n\
-STATUS is a vector of [R0 R1 ... R7 IC], where\n\
- R0..R7 are initial values of corresponding registers,\n\
- IC is the instruction counter specifying from where to start the program.\n\
-If R0..R7 are nil, they are initialized to 0.\n\
-If IC is nil, it is initialized to head of the CCL program.\n\
-\n\
-If optional 4th arg CONTINUE is non-nil, keep IC on read operation\n\
-when read buffer is exausted, else, IC is always set to the end of\n\
-CCL-PROGRAM on exit.\n\
-\n\
-It returns the contents of write buffer as a string,\n\
- and as side effect, STATUS is updated.\n\
-If the optional 5th arg UNIBYTE-P is non-nil, the returned string\n\
-is a unibyte string. By default it is a multibyte string.\n\
-\n\
-See the documentation of `define-ccl-program' for the detail of CCL program.")
- (ccl_prog, status, str, contin, unibyte_p)
+ doc: /* Execute CCL-PROGRAM with initial STATUS on STRING.
+
+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).
+
+Read buffer is set to STRING, and write buffer is allocated automatically.
+
+STATUS is a vector of [R0 R1 ... R7 IC], where
+ R0..R7 are initial values of corresponding registers,
+ IC is the instruction counter specifying from where to start the program.
+If R0..R7 are nil, they are initialized to 0.
+If IC is nil, it is initialized to head of the CCL program.
+
+If optional 4th arg CONTINUE is non-nil, keep IC on read operation
+when read buffer is exausted, else, IC is always set to the end of
+CCL-PROGRAM on exit.
+
+It returns the contents of write buffer as a string,
+ and as side effect, STATUS is updated.
+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. */)
+ (ccl_prog, status, str, contin, unibyte_p)
Lisp_Object ccl_prog, status, str, contin, unibyte_p;
{
Lisp_Object val;
if (setup_ccl_program (&ccl, ccl_prog) < 0)
error ("Invalid CCL program");
- CHECK_VECTOR (status, 1);
- if (XVECTOR (status)->size != 9)
+ CHECK_VECTOR (status);
+ if (ASIZE (status) != 9)
error ("Length of vector STATUS is not 9");
- CHECK_STRING (str, 2);
+ CHECK_STRING (str);
GCPRO2 (status, str);
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;
}
produced = ccl_driver (&ccl, XSTRING (str)->data, outbuf,
STRING_BYTES (XSTRING (str)), outbufsize, (int *) 0);
for (i = 0; i < 8; i++)
- XSET (XVECTOR (status)->contents[i], Lisp_Int, ccl.reg[i]);
- XSETINT (XVECTOR (status)->contents[8], ccl.ic);
+ XSET (AREF (status, i), Lisp_Int, ccl.reg[i]);
+ XSETINT (AREF (status, 8), ccl.ic);
UNGCPRO;
if (NILP (unibyte_p))
DEFUN ("register-ccl-program", Fregister_ccl_program, Sregister_ccl_program,
2, 2, 0,
- "Register CCL program CCL_PROG as NAME in `ccl-program-table'.\n\
-CCL_PROG should be a compiled CCL program (vector), or nil.\n\
-If it is nil, just reserve NAME as a CCL program name.\n\
-Return index number of the registered CCL program.")
- (name, ccl_prog)
+ 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;
{
- int len = XVECTOR (Vccl_program_table)->size;
+ int len = ASIZE (Vccl_program_table);
int idx;
Lisp_Object resolved;
- CHECK_SYMBOL (name, 0);
+ CHECK_SYMBOL (name);
resolved = Qnil;
if (!NILP (ccl_prog))
{
- CHECK_VECTOR (ccl_prog, 1);
+ CHECK_VECTOR (ccl_prog);
resolved = resolve_symbol_ccl_program (ccl_prog);
if (NILP (resolved))
error ("Error in CCL program");
{
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 (EQ (name, XVECTOR (slot)->contents[0]))
+ if (EQ (name, AREF (slot, 0)))
{
/* Update this slot. */
- XVECTOR (slot)->contents[1] = ccl_prog;
- XVECTOR (slot)->contents[2] = resolved;
+ AREF (slot, 1) = ccl_prog;
+ AREF (slot, 2) = resolved;
return make_number (idx);
}
}
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];
+ AREF (new_table, j)
+ = AREF (Vccl_program_table, j);
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;
+ AREF (elt, 0) = name;
+ AREF (elt, 1) = ccl_prog;
+ AREF (elt, 2) = resolved;
+ AREF (Vccl_program_table, idx) = elt;
}
Fput (name, Qccl_program_idx, make_number (idx));
/* Register code conversion map.
A code conversion map consists of numbers, Qt, Qnil, and Qlambda.
- The first element is start code point.
- The rest elements are mapped numbers.
+ The first element is the start code point.
+ The other elements are mapped numbers.
Symbol t means to map to an original number before mapping.
Symbol nil means that the corresponding element is empty.
- Symbol lambda menas to terminate mapping here.
+ Symbol lambda means to terminate mapping here.
*/
DEFUN ("register-code-conversion-map", Fregister_code_conversion_map,
Sregister_code_conversion_map,
2, 2, 0,
- "Register SYMBOL as code conversion map MAP.\n\
-Return index number of the registered map.")
- (symbol, map)
+ doc: /* Register SYMBOL as code conversion map MAP.
+Return index number of the registered 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, 0);
- CHECK_VECTOR (map, 1);
+ CHECK_SYMBOL (symbol);
+ CHECK_VECTOR (map);
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 (EQ (symbol, XCAR (slot)))
{
index = make_number (i);
- XCDR (slot) = map;
+ XSETCDR (slot, map);
Fput (symbol, Qcode_conversion_map, map);
Fput (symbol, Qcode_conversion_map_id, index);
return index;
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);
- XVECTOR (Vcode_conversion_map_vector)->contents[i] = Fcons (symbol, map);
+ AREF (Vcode_conversion_map_vector, i) = Fcons (symbol, map);
return index;
}
staticpro (&Qcode_conversion_map_id);
DEFVAR_LISP ("code-conversion-map-vector", &Vcode_conversion_map_vector,
- "Vector of code conversion maps.");
+ doc: /* Vector of code conversion maps. */);
Vcode_conversion_map_vector = Fmake_vector (make_number (16), Qnil);
DEFVAR_LISP ("font-ccl-encoder-alist", &Vfont_ccl_encoder_alist,
- "Alist of fontname patterns vs corresponding CCL program.\n\
-Each element looks like (REGEXP . CCL-CODE),\n\
- where CCL-CODE is a compiled CCL program.\n\
-When a font whose name matches REGEXP is used for displaying a character,\n\
- CCL-CODE is executed to calculate the code point in the font\n\
- from the charset number and position code(s) of the character which are set\n\
- in CCL registers R0, R1, and R2 before the execution.\n\
-The code point in the font is set in CCL registers R1 and R2\n\
- when the execution terminated.\n\
-If the font is single-byte font, the register R2 is not used.");
+ doc: /* Alist of fontname patterns vs corresponding CCL program.
+Each element looks like (REGEXP . CCL-CODE),
+ where CCL-CODE is a compiled CCL program.
+When a font whose name matches REGEXP is used for displaying a character,
+ CCL-CODE is executed to calculate the code point in the font
+ from the charset number and position code(s) of the character which are set
+ in CCL registers R0, R1, and R2 before the execution.
+The code point in the font is set in CCL registers R1 and R2
+ when the execution terminated.
+ If the font is single-byte font, the register R2 is not used. */);
Vfont_ccl_encoder_alist = Qnil;
defsubr (&Sccl_program_p);
HCoop / bpt / emacs.git / blobdiff