xemacs-beta: src/mule-coding.c comparison

comparison src/mule-coding.c @ 179:9ad43877534d r20-3b16

Import from CVS: tag r20-3b16

author	cvs
date	Mon, 13 Aug 2007 09:52:19 +0200
parents	8eaf7971accc
children	bfd6434d15b3

comparison

equal deleted inserted replaced

-:e703507b8a00
+:9ad43877534d
 	  break;
 	}
 }
 }
-static int
+static enum eol_type
 symbol_to_eol_type (Lisp_Object symbol)
 {
 CHECK_SYMBOL (symbol);
-if (NILP (symbol))           return EOL_AUTODETECT;
+if (NILP (symbol))      return EOL_AUTODETECT;
-else if (EQ (symbol, Qlf))   return EOL_LF;
+if (EQ (symbol, Qlf))   return EOL_LF;
-else if (EQ (symbol, Qcrlf)) return EOL_CRLF;
+if (EQ (symbol, Qcrlf)) return EOL_CRLF;
-else if (EQ (symbol, Qcr))   return EOL_CR;
+if (EQ (symbol, Qcr))   return EOL_CR;
-else
 signal_simple_error ("Unrecognized eol type", symbol);
+return EOL_AUTODETECT; /* not reached */
-return 0; /* not reached */
 }
 static Lisp_Object
-eol_type_to_symbol (int eol_type)
+eol_type_to_symbol (enum eol_type type)
 {
-switch (eol_type)
+switch (type)
 {
 case EOL_LF:         return Qlf;
 case EOL_CRLF:       return Qcrlf;
 case EOL_CR:         return Qcr;
 case EOL_AUTODETECT: return Qnil;
-default:             abort ();
+default:             abort (); return Qnil; /* not reached */
 }
-return Qnil; /* not reached */
 }
 static void
 setup_eol_coding_systems (struct Lisp_Coding_System *codesys)
 {
 coding_system = Fget_coding_system (coding_system);
 return XCODING_SYSTEM_NAME (coding_system);
 }
 static struct Lisp_Coding_System *
-allocate_coding_system (int type, Lisp_Object name)
+allocate_coding_system (enum coding_system_type type, Lisp_Object name)
 {
 struct Lisp_Coding_System *codesys;
 codesys = (struct Lisp_Coding_System *)
 alloc_lcrecord (sizeof (struct Lisp_Coding_System), lrecord_coding_system);
 }
 return new_coding_system;
 }
 static Lisp_Object
-subsidiary_coding_system (Lisp_Object coding_system, int eol_type)
+subsidiary_coding_system (Lisp_Object coding_system, enum eol_type type)
 {
 struct Lisp_Coding_System *cs = XCODING_SYSTEM (coding_system);
 Lisp_Object new_coding_system;
 if (CODING_SYSTEM_EOL_TYPE (cs) != EOL_AUTODETECT)
 return coding_system;
-if (eol_type == EOL_AUTODETECT)
-return coding_system;
+switch (type)
+{
-switch (eol_type)
+case EOL_AUTODETECT: return coding_system;
-{
 case EOL_LF:   new_coding_system = CODING_SYSTEM_EOL_LF   (cs); break;
 case EOL_CR:   new_coding_system = CODING_SYSTEM_EOL_CR   (cs); break;
 case EOL_CRLF: new_coding_system = CODING_SYSTEM_EOL_CRLF (cs); break;
 default:       abort ();
 }
 /*                     Detecting the encoding of data                   */
 /************************************************************************/
 struct detection_state
 {
-int eol_type;
+enum eol_type eol_type;
 int seen_non_ascii;
 int mask;
 struct
 {
 /* Perhaps the only thing useful you learn from intensive Microsoft
 technical interviews */
 return (mask & (mask - 1)) == 0;
 }
-static int
+static enum eol_type
 detect_eol_type (struct detection_state *st, CONST unsigned char *src,
 		 unsigned int n)
 {
 int c;
 This function does not automatically fetch subsidiary coding systems;
 that should be unnecessary with the explicit eol-type argument. */
 static void
 determine_real_coding_system (Lstream *stream, Lisp_Object *codesys_in_out,
-			      int *eol_type_in_out)
+			      enum eol_type *eol_type_in_out)
 {
 struct detection_state decst;
 if (*eol_type_in_out == EOL_AUTODETECT)
 *eol_type_in_out = XCODING_SYSTEM_EOL_TYPE (*codesys_in_out);
 if (detect_coding_type (&decst, random_buffer, nread, 0))
 	break;
 }
 if (decst.mask == ~0)
-{
+val = subsidiary_coding_system (Fget_coding_system (Qautomatic_conversion),
-val = subsidiary_coding_system (Fget_coding_system
+				    decst.eol_type);
-				      (Qautomatic_conversion),
-				      decst.eol_type);
-}
 else
 {
 int i;
 val = Qnil;
 /* EOL_TYPE specifies the type of end-of-line conversion that
 currently applies.  We need to keep this separate from the
 EOL type stored in CODESYS because the latter might indicate
 automatic EOL-type detection while the former will always
 indicate a particular EOL type. */
-int eol_type;
+enum eol_type eol_type;
 /* Additional ISO2022 information.  We define the structure above
 because it's also needed by the detection routines. */
 struct iso2022_decoder iso2022;
 	  goto not_done;
 	default:
 	  if (0x28 <= c && c <= 0x2F)
 	    {
-	      iso->esc = c - 0x28 + ISO_ESC_2_8;
+	      iso->esc = (enum iso_esc_flag) (c - 0x28 + ISO_ESC_2_8);
 	      goto not_done;
 	    }
 	  /* This function is called with CODESYS equal to nil when
 	     doing coding-system detection. */
 /**** designation ****/
 case ISO_ESC_2_4:
 if (0x28 <= c && c <= 0x2F)
 	{
-	  iso->esc = c - 0x28 + ISO_ESC_2_4_8;
+	  iso->esc = (enum iso_esc_flag) (c - 0x28 + ISO_ESC_2_4_8);
 	  goto not_done;
 	}
 if (0x40 <= c && c <= 0x42)
 	{
 	  cs = CHARSET_BY_ATTRIBUTES (CHARSET_TYPE_94X94, c,
 	}
 return 0;
 default:
 {
-	int type;
+	int type =-1;
 	if (c < '0' || c > '~')
 	  return 0; /* bad final byte */
 	if (iso->esc >= ISO_ESC_2_8 &&
 		 iso->esc <= ISO_ESC_2_4_15)
 	  {
 	    type = ((iso->esc >= ISO_ESC_2_4_12) ?
 		    CHARSET_TYPE_96X96 : CHARSET_TYPE_94X94);
 	    reg = (iso->esc - ISO_ESC_2_4_8) & 3;
+	  }
+	else
+	  {
+	    /* Can this ever be reached? -slb */
+	    abort();
 	  }
 	cs = CHARSET_BY_ATTRIBUTES (type, c,
 				    *flags & CODING_STATE_R2L ?
 				    CHARSET_RIGHT_TO_LEFT :

Mercurial > hg > xemacs-beta

comparison src/mule-coding.c @ 179:9ad43877534d r20-3b16