the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-#ifdef emacs
#include <config.h>
-#endif
#include <stdio.h>
-#ifdef emacs
-
#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;
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).
3:MAP-ID1
4:MAP-ID2
...
- */
+ */
/* Map the code in reg[rrr] by MAPs starting from the Nth (N =
reg[RRR]) 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
{ \
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_prog_stack_struct[stack_idx].eof_ic = eof_ic; \
stack_idx++; \
ccl_prog = called_ccl.prog; \
ic = CCL_HEADER_MAIN; \
+ eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]); \
goto ccl_repeat; \
} \
while (0)
/* Terminate CCL program because of invalid command. Should not occur
in the normal case. */
+#ifndef CCL_DEBUG
+
#define CCL_INVALID_CMD \
do \
{ \
} \
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) \
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++; \
} \
else if (ccl->last_block) \
{ \
- ic = ccl->eof_ic; \
+ REG = -1; \
+ ic = eof_ic; \
goto ccl_repeat; \
} \
else \
#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_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. */
+ 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
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. */
{
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 = ic;
+ ccl_prog_stack_struct[stack_idx].eof_ic = eof_ic;
stack_idx++;
ccl_prog = XVECTOR (AREF (slot, 1))->contents;
ic = CCL_HEADER_MAIN;
+ eof_ic = XFASTINT (ccl_prog[CCL_HEADER_EOF]);
}
break;
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)
src++;
goto ccl_read_multibyte_character_suspend;
}
-
+
if (!ccl->multibyte)
{
int bytes;
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)
src--;
if (ccl->last_block)
{
- ic = ccl->eof_ic;
+ ic = eof_ic;
+ eof_hit = 1;
goto ccl_repeat;
}
else
SPLIT_CHAR (op, reg[RRR], i, j);
if (j != -1)
i = (i << 7) | j;
-
+
reg[rrr] = i;
break;
SPLIT_CHAR (op, reg[RRR], i, j);
if (j != -1)
i = (i << 7) | j;
-
+
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)
{
- op = HASH_VALUE (h, op);
- if (!CHAR_VALID_P (op, 0))
+ Lisp_Object opl;
+ opl = HASH_VALUE (h, op);
+ if (!CHAR_VALID_P (XINT (opl), 0))
CCL_INVALID_CMD;
- SPLIT_CHAR (XINT (op), reg[RRR], i, j);
+ SPLIT_CHAR (XINT (opl), reg[RRR], i, j);
if (j != -1)
i = (i << 7) | j;
reg[rrr] = i;
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)
{
- op = HASH_VALUE (h, op);
- if (!INTEGERP (op))
+ Lisp_Object opl;
+ opl = HASH_VALUE (h, op);
+ if (!INTEGERP (opl))
CCL_INVALID_CMD;
- reg[RRR] = XINT (op);
+ reg[RRR] = XINT (opl);
reg[7] = 1; /* r7 true for success */
}
else
else
continue;
}
- else
+ else
continue;
if (NILP (content))
ic = fin_ic;
}
break;
-
+
case CCL_MapMultiple:
{
Lisp_Object map, content, attrib, value;
}
}
map_vector_size = ASIZE (Vcode_conversion_map_vector);
-
+
do {
for (;map_set_rest_length > 0;i++, ic++, map_set_rest_length--)
{
else
continue;
}
- else
+ else
continue;
if (NILP (content))
}
}
break;
-
+
default:
CCL_INVALID_CMD;
}
break;
default:
- sprintf(msg, "\nCCL: Unknown error type (%d).", ccl->status);
+ sprintf(msg, "\nCCL: Unknown error type (%d)", ccl->status);
}
msglen = strlen (msg);
bcopy (msg, dst, msglen);
dst += msglen;
}
-
+
if (ccl->status == CCL_STAT_INVALID_CMD)
{
#if 0 /* If the remaining bytes contain 0x80..0x9F, copying them
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);
ccl->stack_idx = 0;
ccl->eol_type = CODING_EOL_LF;
ccl->suppress_error = 0;
+ ccl->eight_bit_control = 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.
See the documentation of `define-ccl-program' for the detail of CCL program. */)
produced = ccl_driver (&ccl, SDATA (str), outbuf,
SBYTES (str), outbufsize, (int *) 0);
for (i = 0; i < 8; i++)
- XSET (AREF (status, i), Lisp_Int, ccl.reg[i]);
- XSETINT (AREF (status, 8), ccl.ic);
+ ASET (status, i, make_number (ccl.reg[i]));
+ ASET (status, 8, make_number (ccl.ic));
UNGCPRO;
if (NILP (unibyte_p))
CHECK_SYMBOL (symbol);
CHECK_VECTOR (map);
-
+
for (i = 0; i < len; i++)
{
Lisp_Object slot = AREF (Vcode_conversion_map_vector, i);
defsubr (&Sregister_code_conversion_map);
}
-#endif /* emacs */
+/* arch-tag: bb9a37be-68ce-4576-8d3d-15d750e4a860
+ (do not change this comment) */