Mercurial > hg > xemacs-beta

comparison src/file-coding.c @ 4959:bd169a24a554

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merge
author Ben Wing <ben@xemacs.org>
date Thu, 28 Jan 2010 04:27:30 -0600
parents 304aebb79cd3
children 0d4c9d0f6a8d
comparison
equal deleted inserted replaced
4893:99f2102552d7 4959:bd169a24a554
299 if (print_readably) 299 if (print_readably)
300 printing_unreadable_lcrecord (obj, 0); 300 printing_unreadable_lcrecord (obj, 0);
301 301
302 write_fmt_string_lisp (printcharfun, "#<coding-system %s ", 1, c->name); 302 write_fmt_string_lisp (printcharfun, "#<coding-system %s ", 1, c->name);
303 print_coding_system_properties (obj, printcharfun); 303 print_coding_system_properties (obj, printcharfun);
304 write_c_string (printcharfun, ">"); 304 write_ascstring (printcharfun, ">");
305 } 305 }
306 306
307 /* Print an abbreviated version of a coding system (but still containing 307 /* Print an abbreviated version of a coding system (but still containing
308 all the information), for use within a coding system print method. */ 308 all the information), for use within a coding system print method. */
309 309
311 print_coding_system_in_print_method (Lisp_Object cs, Lisp_Object printcharfun, 311 print_coding_system_in_print_method (Lisp_Object cs, Lisp_Object printcharfun,
312 int UNUSED (escapeflag)) 312 int UNUSED (escapeflag))
313 { 313 {
314 write_fmt_string_lisp (printcharfun, "%s[", 1, XCODING_SYSTEM_NAME (cs)); 314 write_fmt_string_lisp (printcharfun, "%s[", 1, XCODING_SYSTEM_NAME (cs));
315 print_coding_system_properties (cs, printcharfun); 315 print_coding_system_properties (cs, printcharfun);
316 write_c_string (printcharfun, "]"); 316 write_ascstring (printcharfun, "]");
317 } 317 }
318 318
319 #ifndef NEW_GC 319 #ifndef NEW_GC
320 static void 320 static void
321 finalize_coding_system (void *header, int for_disksave) 321 finalize_coding_system (void *header, int for_disksave)
519 { 519 {
520 assert (previous_failed_reason == query_coding_unencodable); 520 assert (previous_failed_reason == query_coding_unencodable);
521 521
522 if (flags & QUERY_METHOD_ERRORP) 522 if (flags & QUERY_METHOD_ERRORP)
523 { 523 {
524 DECLARE_EISTRING (error_details); 524 signal_error_2
525 525 (Qtext_conversion_error,
526 eicpy_ascii (error_details, "Cannot encode "); 526 "Cannot encode using coding system",
527 eicat_lstr (error_details, 527 make_string_from_buffer (buf, fail_range_start,
528 make_string_from_buffer (buf, fail_range_start, 528 pos - fail_range_start),
529 pos - 529 XCODING_SYSTEM_NAME (codesys));
530 fail_range_start));
531 eicat_ascii (error_details, " using coding system");
532
533 signal_error (Qtext_conversion_error,
534 (const CIbyte *)(eidata (error_details)),
535 XCODING_SYSTEM_NAME (codesys));
536 } 530 }
537 531
538 if (NILP (result)) 532 if (NILP (result))
539 { 533 {
540 result = Fmake_range_table (Qstart_closed_end_open); 534 result = Fmake_range_table (Qstart_closed_end_open);
677 eidel (desired_base, length - (sizeof ("-dos") - 1), -1, 671 eidel (desired_base, length - (sizeof ("-dos") - 1), -1,
678 4, 4); 672 4, 4);
679 } 673 }
680 } 674 }
681 675
682 coding_system_or_name = intern_int (eidata (desired_base)); 676 coding_system_or_name = intern_istring (eidata (desired_base));
683 677
684 /* Remove this coding system and its subsidiary coding 678 /* Remove this coding system and its subsidiary coding
685 systems from the hash, to avoid calling this code recursively. */ 679 systems from the hash, to avoid calling this code recursively. */
686 Fremhash (coding_system_or_name, Vcoding_system_hash_table); 680 Fremhash (coding_system_or_name, Vcoding_system_hash_table);
687 Fremhash (add_suffix_to_symbol(coding_system_or_name, "-unix"), 681 Fremhash (add_suffix_to_symbol(coding_system_or_name, "-unix"),
695 eicat_lstr (warning_info, XSYMBOL_NAME (coding_system_or_name)); 689 eicat_lstr (warning_info, XSYMBOL_NAME (coding_system_or_name));
696 690
697 /* Keep around the form so it doesn't disappear from under 691 /* Keep around the form so it doesn't disappear from under
698 #'eval's feet. */ 692 #'eval's feet. */
699 GCPRO1 (lookup); 693 GCPRO1 (lookup);
700 call1_trapping_problems ((const CIbyte *)eidata (warning_info), 694 call1_trapping_problems ((const CIbyte *) eidata (warning_info),
701 Qeval, lookup, 0); 695 Qeval, lookup, 0);
702 UNGCPRO; 696 UNGCPRO;
703 697
704 lookup = 698 lookup =
705 Fgethash (coding_system_or_name, Vcoding_system_hash_table, Qnil); 699 Fgethash (coding_system_or_name, Vcoding_system_hash_table, Qnil);
1105 const Ascbyte *extension = coding_subsidiary_list[i].extension; 1099 const Ascbyte *extension = coding_subsidiary_list[i].extension;
1106 const Ascbyte *mnemonic_ext = coding_subsidiary_list[i].mnemonic_ext; 1100 const Ascbyte *mnemonic_ext = coding_subsidiary_list[i].mnemonic_ext;
1107 enum eol_type eol = coding_subsidiary_list[i].eol; 1101 enum eol_type eol = coding_subsidiary_list[i].eol;
1108 1102
1109 qxestrcpy_ascii (codesys_name + len, extension); 1103 qxestrcpy_ascii (codesys_name + len, extension);
1110 codesys_name_sym = intern_int (codesys_name); 1104 codesys_name_sym = intern_istring (codesys_name);
1111 if (mlen != -1) 1105 if (mlen != -1)
1112 qxestrcpy_ascii (codesys_mnemonic + mlen, mnemonic_ext); 1106 qxestrcpy_ascii (codesys_mnemonic + mlen, mnemonic_ext);
1113 1107
1114 sub_codesys = Fcopy_coding_system (codesys, codesys_name_sym); 1108 sub_codesys = Fcopy_coding_system (codesys, codesys_name_sym);
1115 if (mlen != -1) 1109 if (mlen != -1)
1116 XCODING_SYSTEM_MNEMONIC (sub_codesys) = 1110 XCODING_SYSTEM_MNEMONIC (sub_codesys) =
1117 build_intstring (codesys_mnemonic); 1111 build_istring (codesys_mnemonic);
1118 1112
1119 if (eol != EOL_LF) 1113 if (eol != EOL_LF)
1120 { 1114 {
1121 Lisp_Object chain = list2 (get_coding_system_for_text_file 1115 Lisp_Object chain = list2 (get_coding_system_for_text_file
1122 (codesys, 0), 1116 (codesys, 0),
1125 Lisp_Object canon = 1119 Lisp_Object canon =
1126 make_internal_coding_system 1120 make_internal_coding_system
1127 (sub_codesys, "internal-subsidiary-eol-wrapper", 1121 (sub_codesys, "internal-subsidiary-eol-wrapper",
1128 Qchain, Qunbound, 1122 Qchain, Qunbound,
1129 mlen != -1 ? 1123 mlen != -1 ?
1130 list6 (Qmnemonic, build_intstring (codesys_mnemonic), 1124 list6 (Qmnemonic, build_istring (codesys_mnemonic),
1131 Qchain, chain, 1125 Qchain, chain,
1132 Qcanonicalize_after_coding, sub_codesys) : 1126 Qcanonicalize_after_coding, sub_codesys) :
1133 list4 (Qchain, chain, 1127 list4 (Qchain, chain,
1134 Qcanonicalize_after_coding, sub_codesys)); 1128 Qcanonicalize_after_coding, sub_codesys));
1135 XCODING_SYSTEM_CANONICAL (sub_codesys) = canon; 1129 XCODING_SYSTEM_CANONICAL (sub_codesys) = canon;
1211 prefix, 1205 prefix,
1212 NILP (name_or_existing) ? (Ibyte *) "nil" : 1206 NILP (name_or_existing) ? (Ibyte *) "nil" :
1213 XSTRING_DATA (Fsymbol_name (XCODING_SYSTEM_NAME 1207 XSTRING_DATA (Fsymbol_name (XCODING_SYSTEM_NAME
1214 (name_or_existing))), 1208 (name_or_existing))),
1215 ++coding_system_tick); 1209 ++coding_system_tick);
1216 name_or_existing = intern_int (newname); 1210 name_or_existing = intern_istring (newname);
1217 xfree (newname, Ibyte *); 1211 xfree (newname, Ibyte *);
1218 1212
1219 if (UNBOUNDP (description)) 1213 if (UNBOUNDP (description))
1220 { 1214 {
1221 newname = 1215 newname =
1222 emacs_sprintf_malloc 1216 emacs_sprintf_malloc
1223 (NULL, "For Internal Use (%s)", 1217 (NULL, "For Internal Use (%s)",
1224 XSTRING_DATA (Fsymbol_name (name_or_existing))); 1218 XSTRING_DATA (Fsymbol_name (name_or_existing)));
1225 description = build_intstring (newname); 1219 description = build_istring (newname);
1226 xfree (newname, Ibyte *); 1220 xfree (newname, Ibyte *);
1227 } 1221 }
1228 1222
1229 newname = emacs_sprintf_malloc (NULL, "Int%d", coding_system_tick); 1223 newname = emacs_sprintf_malloc (NULL, "Int%d", coding_system_tick);
1230 defmnem = build_intstring (newname); 1224 defmnem = build_istring (newname);
1231 xfree (newname, Ibyte *); 1225 xfree (newname, Ibyte *);
1232 } 1226 }
1233 else 1227 else
1234 CHECK_SYMBOL (name_or_existing); 1228 CHECK_SYMBOL (name_or_existing);
1235 1229
1246 csobj = wrap_coding_system (cs); 1240 csobj = wrap_coding_system (cs);
1247 1241
1248 cs->internal_p = !!prefix; 1242 cs->internal_p = !!prefix;
1249 1243
1250 if (NILP (description)) 1244 if (NILP (description))
1251 description = build_string (""); 1245 description = build_ascstring ("");
1252 else 1246 else
1253 CHECK_STRING (description); 1247 CHECK_STRING (description);
1254 CODING_SYSTEM_DESCRIPTION (cs) = description; 1248 CODING_SYSTEM_DESCRIPTION (cs) = description;
1255 1249
1256 if (!NILP (defmnem)) 1250 if (!NILP (defmnem))
1374 Ibyte *newname = 1368 Ibyte *newname =
1375 emacs_sprintf_malloc 1369 emacs_sprintf_malloc
1376 (NULL, "internal-eol-copy-%s-%d", 1370 (NULL, "internal-eol-copy-%s-%d",
1377 XSTRING_DATA (Fsymbol_name (name_or_existing)), 1371 XSTRING_DATA (Fsymbol_name (name_or_existing)),
1378 ++coding_system_tick); 1372 ++coding_system_tick);
1379 Lisp_Object newnamesym = intern_int (newname); 1373 Lisp_Object newnamesym = intern_istring (newname);
1380 Lisp_Object copied = Fcopy_coding_system (csobj, newnamesym); 1374 Lisp_Object copied = Fcopy_coding_system (csobj, newnamesym);
1381 xfree (newname, Ibyte *); 1375 xfree (newname, Ibyte *);
1382 1376
1383 XCODING_SYSTEM_CANONICAL (csobj) = 1377 XCODING_SYSTEM_CANONICAL (csobj) =
1384 make_internal_coding_system 1378 make_internal_coding_system
2610 static void 2604 static void
2611 chain_print (Lisp_Object cs, Lisp_Object printcharfun, int escapeflag) 2605 chain_print (Lisp_Object cs, Lisp_Object printcharfun, int escapeflag)
2612 { 2606 {
2613 int i; 2607 int i;
2614 2608
2615 write_c_string (printcharfun, "("); 2609 write_ascstring (printcharfun, "(");
2616 for (i = 0; i < XCODING_SYSTEM_CHAIN_COUNT (cs); i++) 2610 for (i = 0; i < XCODING_SYSTEM_CHAIN_COUNT (cs); i++)
2617 { 2611 {
2618 write_c_string (printcharfun, i == 0 ? "" : "->"); 2612 write_ascstring (printcharfun, i == 0 ? "" : "->");
2619 print_coding_system_in_print_method (XCODING_SYSTEM_CHAIN_CHAIN (cs)[i], 2613 print_coding_system_in_print_method (XCODING_SYSTEM_CHAIN_CHAIN (cs)[i],
2620 printcharfun, escapeflag); 2614 printcharfun, escapeflag);
2621 } 2615 }
2622 { 2616 {
2623 Lisp_Object cac = XCODING_SYSTEM_CHAIN_CANONICALIZE_AFTER_CODING (cs); 2617 Lisp_Object cac = XCODING_SYSTEM_CHAIN_CANONICALIZE_AFTER_CODING (cs);
2624 if (!NILP (cac)) 2618 if (!NILP (cac))
2625 { 2619 {
2626 if (i > 0) 2620 if (i > 0)
2627 write_c_string (printcharfun, " "); 2621 write_ascstring (printcharfun, " ");
2628 write_c_string (printcharfun, "canonicalize-after-coding="); 2622 write_ascstring (printcharfun, "canonicalize-after-coding=");
2629 print_coding_system_in_print_method (cac, printcharfun, escapeflag); 2623 print_coding_system_in_print_method (cac, printcharfun, escapeflag);
2630 } 2624 }
2631 } 2625 }
2632 2626
2633 write_c_string (printcharfun, ")"); 2627 write_ascstring (printcharfun, ")");
2634 } 2628 }
2635 2629
2636 static void 2630 static void
2637 chain_rewind_coding_stream_1 (struct chain_coding_stream *data) 2631 chain_rewind_coding_stream_1 (struct chain_coding_stream *data)
2638 { 2632 {
3268 { 3262 {
3269 struct undecided_coding_system *data = 3263 struct undecided_coding_system *data =
3270 XCODING_SYSTEM_TYPE_DATA (cs, undecided); 3264 XCODING_SYSTEM_TYPE_DATA (cs, undecided);
3271 int need_space = 0; 3265 int need_space = 0;
3272 3266
3273 write_c_string (printcharfun, "("); 3267 write_ascstring (printcharfun, "(");
3274 if (data->do_eol) 3268 if (data->do_eol)
3275 { 3269 {
3276 write_c_string (printcharfun, "do-eol"); 3270 write_ascstring (printcharfun, "do-eol");
3277 need_space = 1; 3271 need_space = 1;
3278 } 3272 }
3279 if (data->do_coding) 3273 if (data->do_coding)
3280 { 3274 {
3281 if (need_space) 3275 if (need_space)
3282 write_c_string (printcharfun, " "); 3276 write_ascstring (printcharfun, " ");
3283 write_c_string (printcharfun, "do-coding"); 3277 write_ascstring (printcharfun, "do-coding");
3284 need_space = 1; 3278 need_space = 1;
3285 } 3279 }
3286 if (!NILP (data->cs)) 3280 if (!NILP (data->cs))
3287 { 3281 {
3288 if (need_space) 3282 if (need_space)
3289 write_c_string (printcharfun, " "); 3283 write_ascstring (printcharfun, " ");
3290 write_c_string (printcharfun, "coding-system="); 3284 write_ascstring (printcharfun, "coding-system=");
3291 print_coding_system_in_print_method (data->cs, printcharfun, escapeflag); 3285 print_coding_system_in_print_method (data->cs, printcharfun, escapeflag);
3292 } 3286 }
3293 write_c_string (printcharfun, ")"); 3287 write_ascstring (printcharfun, ")");
3294 } 3288 }
3295 3289
3296 static void 3290 static void
3297 undecided_mark_coding_stream (struct coding_stream *str) 3291 undecided_mark_coding_stream (struct coding_stream *str)
3298 { 3292 {
3717 "0123456789" 3711 "0123456789"
3718 "!$%&*+-.^_{|}~"); 3712 "!$%&*+-.^_{|}~");
3719 if (n > 0) 3713 if (n > 0)
3720 { 3714 {
3721 name[n] = '\0'; 3715 name[n] = '\0';
3722 /* This call to intern_int() is OK because we already verified that 3716 /* This call to intern_istring() is OK because we already verified that
3723 there are only ASCII characters in the string */ 3717 there are only ASCII characters in the string */
3724 return find_coding_system_for_text_file (intern_int ((Ibyte *) name), 0); 3718 return find_coding_system_for_text_file (intern_istring ((Ibyte *) name), 0);
3725 } 3719 }
3726 3720
3727 return Qnil; 3721 return Qnil;
3728 } 3722 }
3729 3723
4310 static void 4304 static void
4311 gzip_print (Lisp_Object cs, Lisp_Object printcharfun, int escapeflag) 4305 gzip_print (Lisp_Object cs, Lisp_Object printcharfun, int escapeflag)
4312 { 4306 {
4313 struct gzip_coding_system *data = XCODING_SYSTEM_TYPE_DATA (cs, gzip); 4307 struct gzip_coding_system *data = XCODING_SYSTEM_TYPE_DATA (cs, gzip);
4314 4308
4315 write_c_string (printcharfun, "("); 4309 write_ascstring (printcharfun, "(");
4316 if (data->level == -1) 4310 if (data->level == -1)
4317 write_c_string (printcharfun, "default"); 4311 write_ascstring (printcharfun, "default");
4318 else 4312 else
4319 print_internal (make_int (data->level), printcharfun, 0); 4313 print_internal (make_int (data->level), printcharfun, 0);
4320 write_c_string (printcharfun, ")"); 4314 write_ascstring (printcharfun, ")");
4321 } 4315 }
4322 4316
4323 static int 4317 static int
4324 gzip_putprop (Lisp_Object codesys, Lisp_Object key, Lisp_Object value) 4318 gzip_putprop (Lisp_Object codesys, Lisp_Object key, Lisp_Object value)
4325 { 4319 {
4748 vars_of_file_coding (void) 4742 vars_of_file_coding (void)
4749 { 4743 {
4750 /* We always have file-coding support */ 4744 /* We always have file-coding support */
4751 Fprovide (intern ("file-coding")); 4745 Fprovide (intern ("file-coding"));
4752 4746
4753 QScoding_system_cookie = build_string (";;;###coding system: "); 4747 QScoding_system_cookie = build_ascstring (";;;###coding system: ");
4754 staticpro (&QScoding_system_cookie); 4748 staticpro (&QScoding_system_cookie);
4755 4749
4756 #ifdef HAVE_DEFAULT_EOL_DETECTION 4750 #ifdef HAVE_DEFAULT_EOL_DETECTION
4757 /* #### Find a more appropriate place for this comment. 4751 /* #### Find a more appropriate place for this comment.
4758 WARNING: The existing categories are intimately tied to the function 4752 WARNING: The existing categories are intimately tied to the function
4836 void 4830 void
4837 complex_vars_of_file_coding (void) 4831 complex_vars_of_file_coding (void)
4838 { 4832 {
4839 Fmake_coding_system_internal 4833 Fmake_coding_system_internal
4840 (Qconvert_eol_cr, Qconvert_eol, 4834 (Qconvert_eol_cr, Qconvert_eol,
4841 build_msg_string ("Convert CR to LF"), 4835 build_defer_string ("Convert CR to LF"),
4842 nconc2 (list6 (Qdocumentation, 4836 nconc2 (list6 (Qdocumentation,
4843 build_msg_string ( 4837 build_defer_string (
4844 "Converts CR (used to mark the end of a line on Macintosh systems) to LF\n" 4838 "Converts CR (used to mark the end of a line on Macintosh systems) to LF\n"
4845 "(used internally and under Unix to mark the end of a line)."), 4839 "(used internally and under Unix to mark the end of a line)."),
4846 Qmnemonic, build_string ("CR->LF"), 4840 Qmnemonic, build_ascstring ("CR->LF"),
4847 Qsubtype, Qcr), 4841 Qsubtype, Qcr),
4848 /* VERY IMPORTANT! Tell make-coding-system not to generate 4842 /* VERY IMPORTANT! Tell make-coding-system not to generate
4849 subsidiaries -- it needs the coding systems we're creating 4843 subsidiaries -- it needs the coding systems we're creating
4850 to do so! */ 4844 to do so! */
4851 list4 (Qeol_type, Qlf, 4845 list4 (Qeol_type, Qlf,
4852 Qsafe_charsets, Qt))); 4846 Qsafe_charsets, Qt)));
4853 4847
4854 Fmake_coding_system_internal 4848 Fmake_coding_system_internal
4855 (Qconvert_eol_lf, Qconvert_eol, 4849 (Qconvert_eol_lf, Qconvert_eol,
4856 build_msg_string ("Convert LF to LF (do nothing)"), 4850 build_defer_string ("Convert LF to LF (do nothing)"),
4857 nconc2 (list6 (Qdocumentation, 4851 nconc2 (list6 (Qdocumentation,
4858 build_msg_string ( 4852 build_defer_string (
4859 "Do nothing."), 4853 "Do nothing."),
4860 Qmnemonic, build_string ("LF->LF"), 4854 Qmnemonic, build_ascstring ("LF->LF"),
4861 Qsubtype, Qlf), 4855 Qsubtype, Qlf),
4862 /* VERY IMPORTANT! Tell make-coding-system not to generate 4856 /* VERY IMPORTANT! Tell make-coding-system not to generate
4863 subsidiaries -- it needs the coding systems we're creating 4857 subsidiaries -- it needs the coding systems we're creating
4864 to do so! */ 4858 to do so! */
4865 list4 (Qeol_type, Qlf, 4859 list4 (Qeol_type, Qlf,
4866 Qsafe_charsets, Qt))); 4860 Qsafe_charsets, Qt)));
4867 4861
4868 Fmake_coding_system_internal 4862 Fmake_coding_system_internal
4869 (Qconvert_eol_crlf, Qconvert_eol, 4863 (Qconvert_eol_crlf, Qconvert_eol,
4870 build_msg_string ("Convert CRLF to LF"), 4864 build_defer_string ("Convert CRLF to LF"),
4871 nconc2 (list6 (Qdocumentation, 4865 nconc2 (list6 (Qdocumentation,
4872 build_msg_string ( 4866 build_defer_string (
4873 "Converts CR+LF (used to mark the end of a line on Macintosh systems) to LF\n" 4867 "Converts CR+LF (used to mark the end of a line on Macintosh systems) to LF\n"
4874 "(used internally and under Unix to mark the end of a line)."), 4868 "(used internally and under Unix to mark the end of a line)."),
4875 Qmnemonic, build_string ("CRLF->LF"), 4869 Qmnemonic, build_ascstring ("CRLF->LF"),
4876 Qsubtype, Qcrlf), 4870 Qsubtype, Qcrlf),
4877 4871
4878 /* VERY IMPORTANT! Tell make-coding-system not to generate 4872 /* VERY IMPORTANT! Tell make-coding-system not to generate
4879 subsidiaries -- it needs the coding systems we're creating 4873 subsidiaries -- it needs the coding systems we're creating
4880 to do so! */ 4874 to do so! */
4881 list4 (Qeol_type, Qlf, 4875 list4 (Qeol_type, Qlf,
4882 Qsafe_charsets, Qt))); 4876 Qsafe_charsets, Qt)));
4883 4877
4884 Fmake_coding_system_internal 4878 Fmake_coding_system_internal
4885 (Qconvert_eol_autodetect, Qconvert_eol, 4879 (Qconvert_eol_autodetect, Qconvert_eol,
4886 build_msg_string ("Autodetect EOL type"), 4880 build_defer_string ("Autodetect EOL type"),
4887 nconc2 (list6 (Qdocumentation, 4881 nconc2 (list6 (Qdocumentation,
4888 build_msg_string ( 4882 build_defer_string (
4889 "Autodetect the end-of-line type."), 4883 "Autodetect the end-of-line type."),
4890 Qmnemonic, build_string ("Auto-EOL"), 4884 Qmnemonic, build_ascstring ("Auto-EOL"),
4891 Qsubtype, Qnil), 4885 Qsubtype, Qnil),
4892 /* VERY IMPORTANT! Tell make-coding-system not to generate 4886 /* VERY IMPORTANT! Tell make-coding-system not to generate
4893 subsidiaries -- it needs the coding systems we're creating 4887 subsidiaries -- it needs the coding systems we're creating
4894 to do so! */ 4888 to do so! */
4895 list4 (Qeol_type, Qlf, 4889 list4 (Qeol_type, Qlf,
4896 Qsafe_charsets, Qt))); 4890 Qsafe_charsets, Qt)));
4897 4891
4898 Fmake_coding_system_internal 4892 Fmake_coding_system_internal
4899 (Qundecided, Qundecided, 4893 (Qundecided, Qundecided,
4900 build_msg_string ("Undecided (auto-detect)"), 4894 build_defer_string ("Undecided (auto-detect)"),
4901 nconc2 (list4 (Qdocumentation, 4895 nconc2 (list4 (Qdocumentation,
4902 build_msg_string 4896 build_defer_string
4903 ("Automatically detects the correct encoding."), 4897 ("Automatically detects the correct encoding."),
4904 Qmnemonic, build_string ("Auto")), 4898 Qmnemonic, build_ascstring ("Auto")),
4905 list6 (Qdo_eol, Qt, Qdo_coding, Qt, 4899 list6 (Qdo_eol, Qt, Qdo_coding, Qt,
4906 /* We do EOL detection ourselves so we don't need to be 4900 /* We do EOL detection ourselves so we don't need to be
4907 wrapped in an EOL detector. (It doesn't actually hurt, 4901 wrapped in an EOL detector. (It doesn't actually hurt,
4908 though, I don't think.) */ 4902 though, I don't think.) */
4909 Qeol_type, Qlf))); 4903 Qeol_type, Qlf)));
4910 4904
4911 Fmake_coding_system_internal 4905 Fmake_coding_system_internal
4912 (intern ("undecided-dos"), Qundecided, 4906 (intern ("undecided-dos"), Qundecided,
4913 build_msg_string ("Undecided (auto-detect) (CRLF)"), 4907 build_defer_string ("Undecided (auto-detect) (CRLF)"),
4914 nconc2 (list4 (Qdocumentation, 4908 nconc2 (list4 (Qdocumentation,
4915 build_msg_string 4909 build_defer_string
4916 ("Automatically detects the correct encoding; EOL type of CRLF forced."), 4910 ("Automatically detects the correct encoding; EOL type of CRLF forced."),
4917 Qmnemonic, build_string ("Auto")), 4911 Qmnemonic, build_ascstring ("Auto")),
4918 list4 (Qdo_coding, Qt, 4912 list4 (Qdo_coding, Qt,
4919 Qeol_type, Qcrlf))); 4913 Qeol_type, Qcrlf)));
4920 4914
4921 Fmake_coding_system_internal 4915 Fmake_coding_system_internal
4922 (intern ("undecided-unix"), Qundecided, 4916 (intern ("undecided-unix"), Qundecided,
4923 build_msg_string ("Undecided (auto-detect) (LF)"), 4917 build_defer_string ("Undecided (auto-detect) (LF)"),
4924 nconc2 (list4 (Qdocumentation, 4918 nconc2 (list4 (Qdocumentation,
4925 build_msg_string 4919 build_defer_string
4926 ("Automatically detects the correct encoding; EOL type of LF forced."), 4920 ("Automatically detects the correct encoding; EOL type of LF forced."),
4927 Qmnemonic, build_string ("Auto")), 4921 Qmnemonic, build_ascstring ("Auto")),
4928 list4 (Qdo_coding, Qt, 4922 list4 (Qdo_coding, Qt,
4929 Qeol_type, Qlf))); 4923 Qeol_type, Qlf)));
4930 4924
4931 Fmake_coding_system_internal 4925 Fmake_coding_system_internal
4932 (intern ("undecided-mac"), Qundecided, 4926 (intern ("undecided-mac"), Qundecided,
4933 build_msg_string ("Undecided (auto-detect) (CR)"), 4927 build_defer_string ("Undecided (auto-detect) (CR)"),
4934 nconc2 (list4 (Qdocumentation, 4928 nconc2 (list4 (Qdocumentation,
4935 build_msg_string 4929 build_defer_string
4936 ("Automatically detects the correct encoding; EOL type of CR forced."), 4930 ("Automatically detects the correct encoding; EOL type of CR forced."),
4937 Qmnemonic, build_string ("Auto")), 4931 Qmnemonic, build_ascstring ("Auto")),
4938 list4 (Qdo_coding, Qt, 4932 list4 (Qdo_coding, Qt,
4939 Qeol_type, Qcr))); 4933 Qeol_type, Qcr)));
4940 4934
4941 /* Need to create this here or we're really screwed. */ 4935 /* Need to create this here or we're really screwed. */
4942 Fmake_coding_system_internal 4936 Fmake_coding_system_internal
4943 (Qraw_text, Qno_conversion, 4937 (Qraw_text, Qno_conversion,
4944 build_msg_string ("Raw Text"), 4938 build_defer_string ("Raw Text"),
4945 nconc2 (list4 (Qdocumentation, 4939 nconc2 (list4 (Qdocumentation,
4946 build_msg_string ("Raw text converts only line-break " 4940 build_defer_string ("Raw text converts only line-break "
4947 "codes, and acts otherwise like " 4941 "codes, and acts otherwise like "
4948 "`binary'."), 4942 "`binary'."),
4949 Qmnemonic, build_string ("Raw")), 4943 Qmnemonic, build_ascstring ("Raw")),
4950 #ifdef MULE 4944 #ifdef MULE
4951 list2 (Qsafe_charsets, list3 (Vcharset_ascii, Vcharset_control_1, 4945 list2 (Qsafe_charsets, list3 (Vcharset_ascii, Vcharset_control_1,
4952 Vcharset_latin_iso8859_1)))); 4946 Vcharset_latin_iso8859_1))));
4953 4947
4954 #else 4948 #else
4955 Qnil)); 4949 Qnil));
4956 #endif 4950 #endif
4957 4951
4958 Fmake_coding_system_internal 4952 Fmake_coding_system_internal
4959 (Qbinary, Qno_conversion, 4953 (Qbinary, Qno_conversion,
4960 build_msg_string ("Binary"), 4954 build_defer_string ("Binary"),
4961 nconc2 (list6 (Qdocumentation, 4955 nconc2 (list6 (Qdocumentation,
4962 build_msg_string ( 4956 build_defer_string (
4963 "This coding system is as close as it comes to doing no conversion.\n" 4957 "This coding system is as close as it comes to doing no conversion.\n"
4964 "On input, each byte is converted directly into the character\n" 4958 "On input, each byte is converted directly into the character\n"
4965 "with the corresponding code -- i.e. from the `ascii', `control-1',\n" 4959 "with the corresponding code -- i.e. from the `ascii', `control-1',\n"
4966 "or `latin-1' character sets. On output, these characters are\n" 4960 "or `latin-1' character sets. On output, these characters are\n"
4967 "converted back to the corresponding bytes, and other characters\n" 4961 "converted back to the corresponding bytes, and other characters\n"
4968 "are converted to the default character, i.e. `~'."), 4962 "are converted to the default character, i.e. `~'."),
4969 Qeol_type, Qlf, 4963 Qeol_type, Qlf,
4970 Qmnemonic, build_string ("Binary")), 4964 Qmnemonic, build_ascstring ("Binary")),
4971 #ifdef MULE 4965 #ifdef MULE
4972 list2 (Qsafe_charsets, list3 (Vcharset_ascii, Vcharset_control_1, 4966 list2 (Qsafe_charsets, list3 (Vcharset_ascii, Vcharset_control_1,
4973 Vcharset_latin_iso8859_1)))); 4967 Vcharset_latin_iso8859_1))));
4974 4968
4975 #else 4969 #else