emacs: src/coding.c comparison

comparison src/coding.c @ 42104:d69c2368e549

(DECODE_COMPOSITION_END): Fixed a typo in the last patch (COMPOSING_P, not COMPOSING).

author	Sam Steingold <sds@gnu.org>
date	Mon, 17 Dec 2001 15:21:06 +0000
parents	e5356ff675e3
children	09cc243e2d14

comparison

equal deleted inserted replaced

-:e5356ff675e3
+:d69c2368e549
 Compound Text, various EUCs (Extended Unix Code), and coding
 systems used in Internet communication such as ISO-2022-JP are
 all variants of ISO2022.  Details are described in section 3.
 2. SJIS (or Shift-JIS or MS-Kanji-Code)
 A coding system to encode character sets: ASCII, JISX0201, and
 JISX0208.  Widely used for PC's in Japan.  Details are described in
 section 4.
 3. BIG5
 Lisp_Object
 coding_safe_chars (coding)
 struct coding_system *coding;
 {
 Lisp_Object coding_spec, plist, safe_chars;
 coding_spec = Fget (coding->symbol, Qcoding_system);
 plist = XVECTOR (coding_spec)->contents[3];
 safe_chars = Fplist_get (XVECTOR (coding_spec)->contents[3], Qsafe_chars);
 return (CHAR_TABLE_P (safe_chars) ? safe_chars : Qt);
 }
 if (buf == bufp || dst + (bufp - buf) <= (dst_bytes ? dst_end : src))
 {
 CODING_ADD_COMPOSITION_START (coding, coding->produced_char, method);
 for (i = 0; i < ncomponent; i++)
 	CODING_ADD_COMPOSITION_COMPONENT (coding, component[i]);
 CODING_ADD_COMPOSITION_END (coding, coding->produced_char + nchars);
 if (buf < bufp)
 	{
 	  unsigned char *p = buf;
 	  EMIT_BYTES (p, bufp);
 	  *destination += bufp - buf;
 {									\
 	coding->cmp_data = coding->cmp_data->next;			\
 	coding->cmp_data_start = 0;					\
 }									\
 } while (0)
 static void encode_eol P_ ((struct coding_system *, unsigned char *,
 			    unsigned char *, int, int));
 static void
 	      /* Locking shift out.  */
 	      mask &= ~CODING_CATEGORY_MASK_ISO_7BIT;
 	      mask_found |= CODING_CATEGORY_MASK_ISO_SHIFT;
 	    }
 	  break;
 	case ISO_CODE_SI:
 	  if (inhibit_iso_escape_detection)
 	    break;
 	  single_shifting = 0;
 	  if (shift_out == 1)
 /* Handle composition end sequence ESC 1.  */
 #define DECODE_COMPOSITION_END(c1)					\
 do {									\
-if (! COMPOSING (coding))						\
+if (! COMPOSING_P (coding))						\
 {									\
 	*dst++ = ISO_CODE_ESC;						\
 	*dst++ = c1;							\
 	coding->produced_char += 2;					\
 }									\
 while (found < 4)
 {
 ONE_MORE_CHAR (c);
 if (c == '\n')
 	break;
 charset = CHAR_CHARSET (c);
 reg = CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset);
 if (reg != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION && r[reg] < 0)
 	{
 	  found++;
 		*dst++ = ISO_CODE_CR, *dst++ = ISO_CODE_LF;
 	      else
 		*dst++ = ISO_CODE_CR;
 	      CODING_SPEC_ISO_BOL (coding) = 1;
 	    }
 	  else
 	    {
 	      if (coding->flags & CODING_FLAG_ISO_RESET_AT_CNTL)
 		ENCODE_RESET_PLANE_AND_REGISTER;
 	      *dst++ = c;
 	    }
 {
 int c, charset, c1, c2;
 src_base = src;
 ONE_MORE_CHAR (c);
 /* Now encode the character C.  */
 if (SINGLE_BYTE_CHAR_P (c))
 	{
 	  switch (c)
 	    {
 	not designated initially but should be designated to graphic
 	register N just before encoding a character in that charset.
 	If the value is nil, graphic register N is never used on
 	encoding.
 sub-element[N] where N is 4 through 11: to be set in `coding->flags'
 	Each value takes t or nil.  See the section ISO2022 of
 	`coding.h' for more information.
 If `coding->type' is `coding_type_big5', element[4] is t to denote
 else
 	goto label_invalid_coding_system;
 }
 else
 goto label_invalid_coding_system;
 /* If the coding system has non-nil `composition' property, enable
 composition handling.  */
 val = Fplist_get (plist, Qcomposition);
 if (!NILP (val))
 coding->composing = COMPOSITION_NO;
 		    tail = XCDR (tail);
 		  }
 	      }
 	    else
 	      CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
 	    CODING_SPEC_ISO_DESIGNATION (coding, i)
 	      = CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i);
 	  }
 	if (reg_bits && ! (coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT))
 		  | CODING_CATEGORY_MASK_EMACS_MULE
 		  | CODING_CATEGORY_MASK_UTF_16_BE
 		  | CODING_CATEGORY_MASK_UTF_16_LE);
 	  /* Or, if C is a special latin extra code,
 	     or is an ISO2022 specific control code of C1 (SS2 or SS3),
 	     or is an ISO2022 control-sequence-introducer (CSI),
 	     we should also consider the possibility of ISO2022 codings.  */
 	  if ((VECTORP (Vlatin_extra_code_table)
 	       && !NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
 	      || (c == ISO_CODE_SS2 || c == ISO_CODE_SS3)
 if (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, 0) != CHARSET_ASCII)
 	/* We can't skip any data.  */
 	break;
 if (coding->flags & CODING_FLAG_ISO_DESIGNATE_AT_BOL)
 	{
 	  unsigned char *bol = begp;
 	  while (begp < endp && *begp < 0x80)
 	    {
 	      begp++;
 	      if (begp[-1] == '\n')
 		bol = begp;
 	      && XVECTOR (eol_type)->size == 3
 	      && SYMBOLP (XVECTOR (eol_type)->contents[CODING_EOL_LF]))
 	    coding->symbol = XVECTOR (eol_type)->contents[CODING_EOL_LF];
 	  else
 	    coding->symbol = saved_coding_symbol;
 	  continue;
 	}
 if (len_byte <= 0)
 	{
 	  if (coding->type != coding_type_ccl
 	  /* The source text ends in invalid codes.  Let's just
 	     make them valid buffer contents, and finish conversion.  */
 	  if (multibyte_p)
 	    {
 	      unsigned char *start = dst;
 	      inserted += len_byte;
 	      while (len_byte--)
 		{
 		  int c = *src++;
 		  dst += CHAR_STRING (c, dst);
 	  GPT -= inserted_byte; GPT_BYTE -= inserted_byte;
 	}
 inserted_byte = str_to_multibyte (GPT_ADDR, GAP_SIZE, inserted_byte);
 }
 /* If we shrank the conversion area, adjust it now.  */
 if (total_skip > 0)
 {
 if (tail_skip > 0)
 	safe_bcopy (GAP_END_ADDR, GPT_ADDR + inserted_byte, tail_skip);
 inserted += total_skip; inserted_byte += total_skip;
 		  *--p1 = *--p0;
 		  if (*p0 == '\n') *--p1 = '\r';
 		}
 	      produced += num_eol;
 	      produced_char += num_eol;
 	    }
 	  /* Suppress eol-format conversion in the further conversion.  */
 	  coding->eol_type = CODING_EOL_LF;
 	  /* Set the coding system symbol to that for Unix-like EOL.  */
 	  eol_type = Fget (saved_coding_symbol, Qeol_type);
 	  if (VECTORP (eol))
 	    XSETCAR (tmp, XVECTOR (eol)->contents[eol_type]);
 	}
 }
 return (highest ? XCAR (val) : val);
 }
 DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
 2, 3, 0,
 doc: /* Detect coding system of the text in the region between START and END.
 Return a list of possible coding systems ordered by priority.
 	 Check if it contains eight-bit-graphic.  */
 p = p1;
 for (p = p1; p < p1end && ASCII_BYTE_P (*p); p++);
 if (p == p1end)
 	{
 	  for (p = p2; p < p2end && ASCII_BYTE_P (*p); p++);
 	  if (p == p2end)
 	    return Qt;
 	}
 }
 void
 init_coding_once ()
 {
 int i;
 /* Emacs' internal format specific initialize routine.  */
 for (i = 0; i <= 0x20; i++)
 emacs_code_class[i] = EMACS_control_code;
 emacs_code_class[0x0A] = EMACS_linefeed_code;
 emacs_code_class[0x0D] = EMACS_carriage_return_code;
 for (i = 0x21 ; i < 0x7F; i++)

Mercurial > emacs

comparison src/coding.c @ 42104:d69c2368e549