comparison src/coding.c @ 110983:b87d8337c695

Fix typos in comments

110982:2b3bece0553a

  int found = 0;
  ...;

  while (1)
    {
      /* Get one byte from the source.  If the souce is exausted, jump
	 to no_more_source:.  */
      ONE_MORE_BYTE (c);

      if (! __C_conforms_to_XXX___ (c))
	break;

  /* The byte sequence is invalid for XXX.  */
  detect_info->rejected |= CATEGORY_MASK_XXX;
  return 0;

 no_more_source:
  /* The source exausted successfully.  */
  detect_info->found |= found;
  return 1;
}
#endif

/* If set, designation sequence should be placed at beginning of line
   on output.  */
#define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400

/* If set, do not encode unsafe charactes on output.  */
#define CODING_ISO_FLAG_SAFE		0x0800

/* If set, extra latin codes (128..159) are accepted as a valid code
   on input.  */
#define CODING_ISO_FLAG_LATIN_EXTRA	0x1000

/* List of symbols `coding-category-xxx' ordered by priority.  This
   variable is exposed to Emacs Lisp.  */
static Lisp_Object Vcoding_category_list;

/* Table of coding categories (Lisp symbols).  This variable is for
   internal use oly.  */
static Lisp_Object Vcoding_category_table;

/* Table of coding-categories ordered by priority.  */
static enum coding_category coding_priorities[coding_category_max];

    produced_chars++;		\
    *dst++ = (c);		\
  } while (0)


/* Like EMIT_ONE_ASCII_BYTE byt store two bytes; C1 and C2.  */

#define EMIT_TWO_ASCII_BYTES(c1, c2)	\
  do {					\
    produced_chars += 2;		\
    *dst++ = (c1), *dst++ = (c2);	\

   old-style emacs-mule encoding, or 0 for the other kind of
   composition.

   METHOD is one of enum composition_method.

   Optionnal COMPOSITION-COMPONENTS are characters and composition
   rules.

   In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
   follows.

	BYTES is 0xA0 plus a byte length of this composition data,

	CHARS is 0xA0 plus a number of characters composed by this
	data,

	COMPONENTs are characters of multibye form or composition
	rules encoded by two-byte of ASCII codes.

   In addition, for backward compatibility, the following formats are
   also recognized as composition data on decoding.

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce two annocations (charset and composition) in one
     loop and one more charset annocation at the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 3);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;
  Lisp_Object attrs, charset_list;

	{
	  int nchars, nbytes;
	  /* emacs_mule_char can load a charset map from a file, which
	     allocates a large structure and might cause buffer text
	     to be relocated as result.  Thus, we need to remember the
	     original pointer to buffer text, and fixup all related
	     pointers after the call.  */
	  const unsigned char *orig = coding->source;
	  EMACS_INT offset;

	  c = emacs_mule_char (coding, src_base, &nbytes, &nchars, &id,

	  consumed_chars = consumed_chars_base + nchars;
	  if (cmp_status->state >= COMPOSING_COMPONENT_CHAR)
	    cmp_status->ncomps -= nchars;
	}

      /* Now if C >= 0, we found a normally encoded characer, if C <
	 0, we found an old-style composition component character or
	 rule.  */

      if (cmp_status->state == COMPOSING_NO)
	{

  ASET (attrs, coding_attr_safe_charsets, safe_charsets);
}


/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
   Check if a text is encoded in one of ISO-2022 based codig systems.
   If it is, return 1, else return 0.  */

static int
detect_coding_iso_2022 (coding, detect_info)
     struct coding_system *coding;

      }
  cmp_status->state = COMPOSING_NO;
  return new_chars;
}

/* If characers are under composition, finish the composition.  */
#define MAYBE_FINISH_COMPOSITION()				\
  do {								\
    if (cmp_status->state != COMPOSING_NO)			\
      char_offset += finish_composition (charbuf, cmp_status);	\
  } while (0)

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce two annocations (charset and composition) in one
     loop and one more charset annocation at the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 3);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;
  /* Charsets invoked to graphic plane 0 and 1 respectively.  */

	    case '[':		/* specification of direction */
	      if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DIRECTION))
		goto invalid_code;
	      /* For the moment, nested direction is not supported.
		 So, `coding->mode & CODING_MODE_DIRECTION' zero means
		 left-to-right, and nozero means right-to-left.  */
	      ONE_MORE_BYTE (c1);
	      switch (c1)
		{
		case ']':	/* end of the current direction */
		  coding->mode &= ~CODING_MODE_DIRECTION;

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce one charset annocation in one loop and one more at
     the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce one charset annocation in one loop and one more at
     the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce one charset annocation in one loop and one more at
     the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;

	symbol) `japanese-iso-8bit' by default.

   o coding-category-iso-7-else

   	The category for a coding system which has the same code range
	as ISO2022 of 7-bit environemnt but uses locking shift or
	single shift functions.  Assigned the coding-system (Lisp
	symbol) `iso-2022-7bit-lock' by default.

   o coding-category-iso-8-else

   	The category for a coding system which has the same code range
	as ISO2022 of 8-bit environemnt but uses locking shift or
	single shift functions.  Assigned the coding-system (Lisp
	symbol) `iso-2022-8bit-ss2' by default.

   o coding-category-big5

/* 1 iff Vcode_conversion_reused_workbuf is already in use.  */
static int reused_workbuf_in_use;


/* Return a working buffer of code convesion.  MULTIBYTE specifies the
   multibyteness of returning buffer.  */

static Lisp_Object
make_conversion_work_buffer (multibyte)
     int multibyte;

}


/* Detect how the bytes at SRC of length SRC_BYTES are encoded.  If
   HIGHEST is nonzero, return the coding system of the highest
   priority among the detected coding systems.  Otherwize return a
   list of detected coding systems sorted by their priorities.  If
   MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
   multibyte form but contains only ASCII and eight-bit chars.
   Otherwise, the bytes are raw bytes.

  struct coding_system *terminal_coding = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
  CHECK_SYMBOL (coding_system);
  setup_coding_system (Fcheck_coding_system (coding_system), terminal_coding);
  /* We had better not send unsafe characters to terminal.  */
  terminal_coding->mode |= CODING_MODE_SAFE_ENCODING;
  /* Characer composition should be disabled.  */
  terminal_coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
  terminal_coding->src_multibyte = 1;
  terminal_coding->dst_multibyte = 0;
  return Qnil;
}

     Lisp_Object coding_system;
{
  CHECK_SYMBOL (coding_system);
  setup_coding_system (Fcheck_coding_system (coding_system),
		       &safe_terminal_coding);
  /* Characer composition should be disabled.  */
  safe_terminal_coding.common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
  safe_terminal_coding.src_multibyte = 1;
  safe_terminal_coding.dst_multibyte = 0;
  return Qnil;
}

  if (NILP (coding_system))
    coding_system = Qno_conversion;
  else
    Fcheck_coding_system (coding_system);
  setup_coding_system (coding_system, TERMINAL_KEYBOARD_CODING (t));
  /* Characer composition should be disabled.  */
  TERMINAL_KEYBOARD_CODING (t)->common_flags
    &= ~CODING_ANNOTATE_COMPOSITION_MASK;
  return Qnil;
}

	 If Nth element is a number NUM, N is the first byte of a
	 charset whose ID is NUM.

	 If Nth element is a list of charset IDs, N is the first byte
	 of one of them.  The list is sorted by dimensions of the
	 charsets.  A charset of smaller dimension comes firtst. */
      val = Fmake_vector (make_number (256), Qnil);

      for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
	{
	  struct charset *charset = CHARSET_FROM_ID (XFASTINT (XCAR (tail)));

110983:b87d8337c695

  int found = 0;
  ...;

  while (1)
    {
      /* Get one byte from the source.  If the source is exhausted, jump
	 to no_more_source:.  */
      ONE_MORE_BYTE (c);

      if (! __C_conforms_to_XXX___ (c))
	break;

  /* The byte sequence is invalid for XXX.  */
  detect_info->rejected |= CATEGORY_MASK_XXX;
  return 0;

 no_more_source:
  /* The source exhausted successfully.  */
  detect_info->found |= found;
  return 1;
}
#endif

/* If set, designation sequence should be placed at beginning of line
   on output.  */
#define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400

/* If set, do not encode unsafe characters on output.  */
#define CODING_ISO_FLAG_SAFE		0x0800

/* If set, extra latin codes (128..159) are accepted as a valid code
   on input.  */
#define CODING_ISO_FLAG_LATIN_EXTRA	0x1000

/* List of symbols `coding-category-xxx' ordered by priority.  This
   variable is exposed to Emacs Lisp.  */
static Lisp_Object Vcoding_category_list;

/* Table of coding categories (Lisp symbols).  This variable is for
   internal use only.  */
static Lisp_Object Vcoding_category_table;

/* Table of coding-categories ordered by priority.  */
static enum coding_category coding_priorities[coding_category_max];

    produced_chars++;		\
    *dst++ = (c);		\
  } while (0)


/* Like EMIT_ONE_ASCII_BYTE but store two bytes; C1 and C2.  */

#define EMIT_TWO_ASCII_BYTES(c1, c2)	\
  do {					\
    produced_chars += 2;		\
    *dst++ = (c1), *dst++ = (c2);	\

   old-style emacs-mule encoding, or 0 for the other kind of
   composition.

   METHOD is one of enum composition_method.

   Optional COMPOSITION-COMPONENTS are characters and composition
   rules.

   In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
   follows.

	BYTES is 0xA0 plus a byte length of this composition data,

	CHARS is 0xA0 plus a number of characters composed by this
	data,

	COMPONENTs are characters of multibyte form or composition
	rules encoded by two-byte of ASCII codes.

   In addition, for backward compatibility, the following formats are
   also recognized as composition data on decoding.

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce two annotations (charset and composition) in one
     loop and one more charset annotation at the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 3);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;
  Lisp_Object attrs, charset_list;

	{
	  int nchars, nbytes;
	  /* emacs_mule_char can load a charset map from a file, which
	     allocates a large structure and might cause buffer text
	     to be relocated as result.  Thus, we need to remember the
	     original pointer to buffer text, and fix up all related
	     pointers after the call.  */
	  const unsigned char *orig = coding->source;
	  EMACS_INT offset;

	  c = emacs_mule_char (coding, src_base, &nbytes, &nchars, &id,

	  consumed_chars = consumed_chars_base + nchars;
	  if (cmp_status->state >= COMPOSING_COMPONENT_CHAR)
	    cmp_status->ncomps -= nchars;
	}

      /* Now if C >= 0, we found a normally encoded character, if C <
	 0, we found an old-style composition component character or
	 rule.  */

      if (cmp_status->state == COMPOSING_NO)
	{

  ASET (attrs, coding_attr_safe_charsets, safe_charsets);
}


/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
   Check if a text is encoded in one of ISO-2022 based coding systems.
   If it is, return 1, else return 0.  */

static int
detect_coding_iso_2022 (coding, detect_info)
     struct coding_system *coding;

      }
  cmp_status->state = COMPOSING_NO;
  return new_chars;
}

/* If characters are under composition, finish the composition.  */
#define MAYBE_FINISH_COMPOSITION()				\
  do {								\
    if (cmp_status->state != COMPOSING_NO)			\
      char_offset += finish_composition (charbuf, cmp_status);	\
  } while (0)

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce two annotations (charset and composition) in one
     loop and one more charset annotation at the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 3);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;
  /* Charsets invoked to graphic plane 0 and 1 respectively.  */

	    case '[':		/* specification of direction */
	      if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DIRECTION))
		goto invalid_code;
	      /* For the moment, nested direction is not supported.
		 So, `coding->mode & CODING_MODE_DIRECTION' zero means
		 left-to-right, and nonzero means right-to-left.  */
	      ONE_MORE_BYTE (c1);
	      switch (c1)
		{
		case ']':	/* end of the current direction */
		  coding->mode &= ~CODING_MODE_DIRECTION;

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce one charset annotation in one loop and one more at
     the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce one charset annotation in one loop and one more at
     the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;

{
  const unsigned char *src = coding->source + coding->consumed;
  const unsigned char *src_end = coding->source + coding->src_bytes;
  const unsigned char *src_base;
  int *charbuf = coding->charbuf + coding->charbuf_used;
  /* We may produce one charset annotation in one loop and one more at
     the end.  */
  int *charbuf_end
    = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2);
  int consumed_chars = 0, consumed_chars_base;
  int multibytep = coding->src_multibyte;

	symbol) `japanese-iso-8bit' by default.

   o coding-category-iso-7-else

   	The category for a coding system which has the same code range
	as ISO2022 of 7-bit environment but uses locking shift or
	single shift functions.  Assigned the coding-system (Lisp
	symbol) `iso-2022-7bit-lock' by default.

   o coding-category-iso-8-else

   	The category for a coding system which has the same code range
	as ISO2022 of 8-bit environment but uses locking shift or
	single shift functions.  Assigned the coding-system (Lisp
	symbol) `iso-2022-8bit-ss2' by default.

   o coding-category-big5

/* 1 iff Vcode_conversion_reused_workbuf is already in use.  */
static int reused_workbuf_in_use;


/* Return a working buffer of code conversion.  MULTIBYTE specifies the
   multibyteness of returning buffer.  */

static Lisp_Object
make_conversion_work_buffer (multibyte)
     int multibyte;

}


/* Detect how the bytes at SRC of length SRC_BYTES are encoded.  If
   HIGHEST is nonzero, return the coding system of the highest
   priority among the detected coding systems.  Otherwise return a
   list of detected coding systems sorted by their priorities.  If
   MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
   multibyte form but contains only ASCII and eight-bit chars.
   Otherwise, the bytes are raw bytes.

  struct coding_system *terminal_coding = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
  CHECK_SYMBOL (coding_system);
  setup_coding_system (Fcheck_coding_system (coding_system), terminal_coding);
  /* We had better not send unsafe characters to terminal.  */
  terminal_coding->mode |= CODING_MODE_SAFE_ENCODING;
  /* Character composition should be disabled.  */
  terminal_coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
  terminal_coding->src_multibyte = 1;
  terminal_coding->dst_multibyte = 0;
  return Qnil;
}

     Lisp_Object coding_system;
{
  CHECK_SYMBOL (coding_system);
  setup_coding_system (Fcheck_coding_system (coding_system),
		       &safe_terminal_coding);
  /* Character composition should be disabled.  */
  safe_terminal_coding.common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
  safe_terminal_coding.src_multibyte = 1;
  safe_terminal_coding.dst_multibyte = 0;
  return Qnil;
}

  if (NILP (coding_system))
    coding_system = Qno_conversion;
  else
    Fcheck_coding_system (coding_system);
  setup_coding_system (coding_system, TERMINAL_KEYBOARD_CODING (t));
  /* Character composition should be disabled.  */
  TERMINAL_KEYBOARD_CODING (t)->common_flags
    &= ~CODING_ANNOTATE_COMPOSITION_MASK;
  return Qnil;
}

	 If Nth element is a number NUM, N is the first byte of a
	 charset whose ID is NUM.

	 If Nth element is a list of charset IDs, N is the first byte
	 of one of them.  The list is sorted by dimensions of the
	 charsets.  A charset of smaller dimension comes first. */
      val = Fmake_vector (make_number (256), Qnil);

      for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
	{
	  struct charset *charset = CHARSET_FROM_ID (XFASTINT (XCAR (tail)));