Mercurial > hg > xemacs-beta

comparison src/mule-charset.c @ 563:183866b06e0b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2001-05-24 07:50:48 by ben] Makefile.in.in, abbrev.c, alloc.c, buffer.c, bytecode.c, callint.c, callproc.c, casetab.c, chartab.c, cmdloop.c, cmds.c, console-msw.c, console-msw.h, console-stream.c, console-tty.c, console-x.c, console.c, data.c, database.c, debug.c, device-gtk.c, device-msw.c, device-tty.c, device-x.c, device.c, dialog-gtk.c, dialog-msw.c, dialog-x.c, dialog.c, dired-msw.c, dired.c, doc.c, doprnt.c, dragdrop.c, editfns.c, eldap.c, eldap.h, elhash.c, emacs-widget-accessors.c, emacs.c, emodules.c, esd.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, events.c, extents.c, faces.c, file-coding.c, fileio.c, filelock.c, floatfns.c, fns.c, font-lock.c, frame-gtk.c, frame-x.c, frame.c, general-slots.h, glade.c, glyphs-gtk.c, glyphs-msw.c, glyphs-widget.c, glyphs-x.c, glyphs.c, glyphs.h, gpmevent.c, gui-gtk.c, gui-x.c, gui.c, gutter.c, hpplay.c, indent.c, input-method-xlib.c, insdel.c, intl.c, keymap.c, libsst.c, libsst.h, linuxplay.c, lisp.h, lread.c, lstream.c, lstream.h, macros.c, marker.c, md5.c, menubar-gtk.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, miscplay.c, miscplay.h, mule-ccl.c, mule-charset.c, mule-wnnfns.c, mule.c, nas.c, ntplay.c, ntproc.c, objects-gtk.c, objects-msw.c, objects-x.c, objects.c, postgresql.c, print.c, process-nt.c, process-unix.c, process.c, ralloc.c, rangetab.c, redisplay.c, scrollbar.c, search.c, select-gtk.c, select-x.c, select.c, sgiplay.c, sheap.c, sound.c, specifier.c, sunplay.c, symbols.c, symeval.h, symsinit.h, syntax.c, sysdep.c, toolbar-msw.c, toolbar.c, tooltalk.c, ui-byhand.c, ui-gtk.c, undo.c, unexaix.c, unexapollo.c, unexconvex.c, unexec.c, widget.c, win32.c, window.c: -- defsymbol -> DEFSYMBOL. -- add an error type to all errors. -- eliminate the error functions in eval.c that let you just use Qerror as the type. -- redo the error API to be more consistent, sensibly named, and easier to use. -- redo the error hierarchy somewhat. create new errors: structure-formation-error, gui-error, invalid-constant, stack-overflow, out-of-memory, process-error, network-error, sound-error, printing-unreadable-object, base64-conversion- error; coding-system-error renamed to text-conversion error; some others. -- fix Mule problems in error strings in emodules.c, tooltalk.c. -- fix error handling in mswin open-network-stream. -- Mule-ize all sound files and clean up the headers. -- nativesound.h -> sound.h and used for all sound files. -- move some shared stuff into glyphs-shared.c: first attempt at eliminating some of the massive GTK code duplication. xemacs.mak: add glyphs-shared.c. xemacs-faq.texi: document how to debug X errors subr.el: fix doc string to reflect reality
author ben
date Thu, 24 May 2001 07:51:33 +0000
parents 1c3b60121364
children e9162e1ea200
comparison
equal deleted inserted replaced
562:c775bd016b32 563:183866b06e0b
402 { 402 {
403 Lisp_Charset *cs = XCHARSET (obj); 403 Lisp_Charset *cs = XCHARSET (obj);
404 char buf[200]; 404 char buf[200];
405 405
406 if (print_readably) 406 if (print_readably)
407 error ("printing unreadable object #<charset %s 0x%x>", 407 printing_unreadable_object ("#<charset %s 0x%x>",
408 string_data (XSYMBOL (CHARSET_NAME (cs))->name), 408 string_data (XSYMBOL (CHARSET_NAME (cs))->
409 cs->header.uid); 409 name),
410 cs->header.uid);
410 411
411 write_c_string ("#<charset ", printcharfun); 412 write_c_string ("#<charset ", printcharfun);
412 print_internal (CHARSET_NAME (cs), printcharfun, 0); 413 print_internal (CHARSET_NAME (cs), printcharfun, 0);
413 write_c_string (" ", printcharfun); 414 write_c_string (" ", printcharfun);
414 print_internal (CHARSET_SHORT_NAME (cs), printcharfun, 1); 415 print_internal (CHARSET_SHORT_NAME (cs), printcharfun, 1);
520 else 521 else
521 lb = chlook->next_allocated_2_byte_leading_byte++; 522 lb = chlook->next_allocated_2_byte_leading_byte++;
522 } 523 }
523 524
524 if (!lb) 525 if (!lb)
525 signal_simple_error 526 invalid_operation
526 ("No more character sets free for this dimension", 527 ("No more character sets free for this dimension",
527 make_int (dimension)); 528 make_int (dimension));
528 529
529 return lb; 530 return lb;
530 } 531 }
565 (name)) 566 (name))
566 { 567 {
567 Lisp_Object charset = Ffind_charset (name); 568 Lisp_Object charset = Ffind_charset (name);
568 569
569 if (NILP (charset)) 570 if (NILP (charset))
570 signal_simple_error ("No such charset", name); 571 invalid_argument ("No such charset", name);
571 return charset; 572 return charset;
572 } 573 }
573 574
574 /* We store the charsets in hash tables with the names as the key and the 575 /* We store the charsets in hash tables with the names as the key and the
575 actual charset object as the value. Occasionally we need to use them 576 actual charset object as the value. Occasionally we need to use them
680 if (!NILP (doc_string)) 681 if (!NILP (doc_string))
681 CHECK_STRING (doc_string); 682 CHECK_STRING (doc_string);
682 683
683 charset = Ffind_charset (name); 684 charset = Ffind_charset (name);
684 if (!NILP (charset)) 685 if (!NILP (charset))
685 signal_simple_error ("Cannot redefine existing charset", name); 686 invalid_operation ("Cannot redefine existing charset", name);
686 687
687 { 688 {
688 EXTERNAL_PROPERTY_LIST_LOOP_3 (keyword, value, props) 689 EXTERNAL_PROPERTY_LIST_LOOP_3 (keyword, value, props)
689 { 690 {
690 if (EQ (keyword, Qshort_name)) 691 if (EQ (keyword, Qshort_name))
702 else if (EQ (keyword, Qdimension)) 703 else if (EQ (keyword, Qdimension))
703 { 704 {
704 CHECK_INT (value); 705 CHECK_INT (value);
705 dimension = XINT (value); 706 dimension = XINT (value);
706 if (dimension < 1 || dimension > 2) 707 if (dimension < 1 || dimension > 2)
707 signal_simple_error ("Invalid value for 'dimension", value); 708 invalid_constant ("Invalid value for 'dimension", value);
708 } 709 }
709 710
710 else if (EQ (keyword, Qchars)) 711 else if (EQ (keyword, Qchars))
711 { 712 {
712 CHECK_INT (value); 713 CHECK_INT (value);
713 chars = XINT (value); 714 chars = XINT (value);
714 if (chars != 94 && chars != 96) 715 if (chars != 94 && chars != 96)
715 signal_simple_error ("Invalid value for 'chars", value); 716 invalid_constant ("Invalid value for 'chars", value);
716 } 717 }
717 718
718 else if (EQ (keyword, Qcolumns)) 719 else if (EQ (keyword, Qcolumns))
719 { 720 {
720 CHECK_INT (value); 721 CHECK_INT (value);
721 columns = XINT (value); 722 columns = XINT (value);
722 if (columns != 1 && columns != 2) 723 if (columns != 1 && columns != 2)
723 signal_simple_error ("Invalid value for 'columns", value); 724 invalid_constant ("Invalid value for 'columns", value);
724 } 725 }
725 726
726 else if (EQ (keyword, Qgraphic)) 727 else if (EQ (keyword, Qgraphic))
727 { 728 {
728 CHECK_INT (value); 729 CHECK_INT (value);
729 graphic = XINT (value); 730 graphic = XINT (value);
730 if (graphic < 0 || graphic > 1) 731 if (graphic < 0 || graphic > 1)
731 signal_simple_error ("Invalid value for 'graphic", value); 732 invalid_constant ("Invalid value for 'graphic", value);
732 } 733 }
733 734
734 else if (EQ (keyword, Qregistry)) 735 else if (EQ (keyword, Qregistry))
735 { 736 {
736 CHECK_STRING (value); 737 CHECK_STRING (value);
742 if (EQ (value, Ql2r)) 743 if (EQ (value, Ql2r))
743 direction = CHARSET_LEFT_TO_RIGHT; 744 direction = CHARSET_LEFT_TO_RIGHT;
744 else if (EQ (value, Qr2l)) 745 else if (EQ (value, Qr2l))
745 direction = CHARSET_RIGHT_TO_LEFT; 746 direction = CHARSET_RIGHT_TO_LEFT;
746 else 747 else
747 signal_simple_error ("Invalid value for 'direction", value); 748 invalid_constant ("Invalid value for 'direction", value);
748 } 749 }
749 750
750 else if (EQ (keyword, Qfinal)) 751 else if (EQ (keyword, Qfinal))
751 { 752 {
752 CHECK_CHAR_COERCE_INT (value); 753 CHECK_CHAR_COERCE_INT (value);
753 final = XCHAR (value); 754 final = XCHAR (value);
754 if (final < '0' || final > '~') 755 if (final < '0' || final > '~')
755 signal_simple_error ("Invalid value for 'final", value); 756 invalid_constant ("Invalid value for 'final", value);
756 } 757 }
757 758
758 else if (EQ (keyword, Qccl_program)) 759 else if (EQ (keyword, Qccl_program))
759 { 760 {
760 struct ccl_program test_ccl; 761 struct ccl_program test_ccl;
761 762
762 if (setup_ccl_program (&test_ccl, value) < 0) 763 if (setup_ccl_program (&test_ccl, value) < 0)
763 signal_simple_error ("Invalid value for 'ccl-program", value); 764 invalid_argument ("Invalid value for 'ccl-program", value);
764 ccl_program = value; 765 ccl_program = value;
765 } 766 }
766 767
767 else 768 else
768 signal_simple_error ("Unrecognized property", keyword); 769 invalid_constant ("Unrecognized property", keyword);
769 } 770 }
770 } 771 }
771 772
772 if (!final) 773 if (!final)
773 error ("'final must be specified"); 774 invalid_argument ("'final must be specified", Qunbound);
774 if (dimension == 2 && final > 0x5F) 775 if (dimension == 2 && final > 0x5F)
775 signal_simple_error 776 invalid_constant
776 ("Final must be in the range 0x30 - 0x5F for dimension == 2", 777 ("Final must be in the range 0x30 - 0x5F for dimension == 2",
777 make_char (final)); 778 make_char (final));
778 779
779 if (dimension == 1) 780 if (dimension == 1)
780 type = (chars == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96; 781 type = (chars == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96;
822 Lisp_Object registry, doc_string, short_name, long_name; 823 Lisp_Object registry, doc_string, short_name, long_name;
823 Lisp_Charset *cs; 824 Lisp_Charset *cs;
824 825
825 charset = Fget_charset (charset); 826 charset = Fget_charset (charset);
826 if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset))) 827 if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset)))
827 signal_simple_error ("Charset already has reverse-direction charset", 828 invalid_operation ("Charset already has reverse-direction charset",
828 charset); 829 charset);
829 830
830 CHECK_SYMBOL (new_name); 831 CHECK_SYMBOL (new_name);
831 if (!NILP (Ffind_charset (new_name))) 832 if (!NILP (Ffind_charset (new_name)))
832 signal_simple_error ("Cannot redefine existing charset", new_name); 833 invalid_operation ("Cannot redefine existing charset", new_name);
833 834
834 cs = XCHARSET (charset); 835 cs = XCHARSET (charset);
835 836
836 type = CHARSET_TYPE (cs); 837 type = CHARSET_TYPE (cs);
837 columns = CHARSET_COLUMNS (cs); 838 columns = CHARSET_COLUMNS (cs);
886 Lisp_Object obj = Qnil; 887 Lisp_Object obj = Qnil;
887 888
888 CHECK_INT (dimension); 889 CHECK_INT (dimension);
889 dm = XINT (dimension); 890 dm = XINT (dimension);
890 if (dm < 1 || dm > 2) 891 if (dm < 1 || dm > 2)
891 signal_simple_error ("Invalid value for DIMENSION", dimension); 892 invalid_constant ("Invalid value for DIMENSION", dimension);
892 893
893 CHECK_INT (chars); 894 CHECK_INT (chars);
894 ch = XINT (chars); 895 ch = XINT (chars);
895 if (ch != 94 && ch != 96) 896 if (ch != 94 && ch != 96)
896 signal_simple_error ("Invalid value for CHARS", chars); 897 invalid_constant ("Invalid value for CHARS", chars);
897 898
898 CHECK_CHAR_COERCE_INT (final); 899 CHECK_CHAR_COERCE_INT (final);
899 fi = XCHAR (final); 900 fi = XCHAR (final);
900 if (fi < '0' || fi > '~') 901 if (fi < '0' || fi > '~')
901 signal_simple_error ("Invalid value for FINAL", final); 902 invalid_constant ("Invalid value for FINAL", final);
902 903
903 if (EQ (direction, Ql2r)) 904 if (EQ (direction, Ql2r))
904 di = CHARSET_LEFT_TO_RIGHT; 905 di = CHARSET_LEFT_TO_RIGHT;
905 else if (EQ (direction, Qr2l)) 906 else if (EQ (direction, Qr2l))
906 di = CHARSET_RIGHT_TO_LEFT; 907 di = CHARSET_RIGHT_TO_LEFT;
907 else if (!NILP (direction)) 908 else if (!NILP (direction))
908 signal_simple_error ("Invalid value for DIRECTION", direction); 909 invalid_constant ("Invalid value for DIRECTION", direction);
909 910
910 if (dm == 2 && fi > 0x5F) 911 if (dm == 2 && fi > 0x5F)
911 signal_simple_error 912 invalid_constant
912 ("Final must be in the range 0x30 - 0x5F for dimension == 2", final); 913 ("Final must be in the range 0x30 - 0x5F for dimension == 2", final);
913 914
914 if (dm == 1) 915 if (dm == 1)
915 type = (ch == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96; 916 type = (ch == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96;
916 else 917 else
992 { 993 {
993 Lisp_Object obj = CHARSET_REVERSE_DIRECTION_CHARSET (cs); 994 Lisp_Object obj = CHARSET_REVERSE_DIRECTION_CHARSET (cs);
994 /* #### Is this translation OK? If so, error checking sufficient? */ 995 /* #### Is this translation OK? If so, error checking sufficient? */
995 return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj; 996 return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj;
996 } 997 }
997 signal_simple_error ("Unrecognized charset property name", prop); 998 invalid_constant ("Unrecognized charset property name", prop);
998 return Qnil; /* not reached */ 999 return Qnil; /* not reached */
999 } 1000 }
1000 1001
1001 DEFUN ("charset-id", Fcharset_id, 1, 1, 0, /* 1002 DEFUN ("charset-id", Fcharset_id, 1, 1, 0, /*
1002 Return charset identification number of CHARSET. 1003 Return charset identification number of CHARSET.
1016 { 1017 {
1017 struct ccl_program test_ccl; 1018 struct ccl_program test_ccl;
1018 1019
1019 charset = Fget_charset (charset); 1020 charset = Fget_charset (charset);
1020 if (setup_ccl_program (&test_ccl, ccl_program) < 0) 1021 if (setup_ccl_program (&test_ccl, ccl_program) < 0)
1021 signal_simple_error ("Invalid ccl-program", ccl_program); 1022 invalid_argument ("Invalid ccl-program", ccl_program);
1022 XCHARSET_CCL_PROGRAM (charset) = ccl_program; 1023 XCHARSET_CCL_PROGRAM (charset) = ccl_program;
1023 face_property_was_changed (Vdefault_face, Qfont, Qglobal); 1024 face_property_was_changed (Vdefault_face, Qfont, Qglobal);
1024 return Qnil; 1025 return Qnil;
1025 } 1026 }
1026 1027
1087 args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim)); 1088 args_out_of_range_3 (arg1, make_int (lowlim), make_int (highlim));
1088 1089
1089 if (CHARSET_DIMENSION (cs) == 1) 1090 if (CHARSET_DIMENSION (cs) == 1)
1090 { 1091 {
1091 if (!NILP (arg2)) 1092 if (!NILP (arg2))
1092 signal_simple_error 1093 invalid_argument
1093 ("Charset is of dimension one; second octet must be nil", arg2); 1094 ("Charset is of dimension one; second octet must be nil", arg2);
1094 return make_char (MAKE_CHAR (charset, a1, 0)); 1095 return make_char (MAKE_CHAR (charset, a1, 0));
1095 } 1096 }
1096 1097
1097 CHECK_INT (arg2); 1098 CHECK_INT (arg2);
1129 if (NILP (n) || EQ (n, Qzero)) 1130 if (NILP (n) || EQ (n, Qzero))
1130 return make_int (octet0); 1131 return make_int (octet0);
1131 else if (EQ (n, make_int (1))) 1132 else if (EQ (n, make_int (1)))
1132 return make_int (octet1); 1133 return make_int (octet1);
1133 else 1134 else
1134 signal_simple_error ("Octet number must be 0 or 1", n); 1135 invalid_constant ("Octet number must be 0 or 1", n);
1135 } 1136 }
1136 1137
1137 DEFUN ("split-char", Fsplit_char, 1, 1, 0, /* 1138 DEFUN ("split-char", Fsplit_char, 1, 1, 0, /*
1138 Return list of charset and one or two position-codes of CHARACTER. 1139 Return list of charset and one or two position-codes of CHARACTER.
1139 */ 1140 */
1179 Emchar emch; 1180 Emchar emch;
1180 1181
1181 if (UNBOUNDP (ch)) 1182 if (UNBOUNDP (ch))
1182 { 1183 {
1183 if (composite_char_row_next >= 128) 1184 if (composite_char_row_next >= 128)
1184 signal_simple_error ("No more composite chars available", lispstr); 1185 invalid_operation ("No more composite chars available", lispstr);
1185 emch = MAKE_CHAR (Vcharset_composite, composite_char_row_next, 1186 emch = MAKE_CHAR (Vcharset_composite, composite_char_row_next,
1186 composite_char_col_next); 1187 composite_char_col_next);
1187 Fputhash (make_char (emch), lispstr, 1188 Fputhash (make_char (emch), lispstr,
1188 Vcomposite_char_char2string_hash_table); 1189 Vcomposite_char_char2string_hash_table);
1189 Fputhash (lispstr, make_char (emch), 1190 Fputhash (lispstr, make_char (emch),
1230 Emchar emch; 1231 Emchar emch;
1231 1232
1232 CHECK_CHAR (ch); 1233 CHECK_CHAR (ch);
1233 emch = XCHAR (ch); 1234 emch = XCHAR (ch);
1234 if (CHAR_LEADING_BYTE (emch) != LEADING_BYTE_COMPOSITE) 1235 if (CHAR_LEADING_BYTE (emch) != LEADING_BYTE_COMPOSITE)
1235 signal_simple_error ("Must be composite char", ch); 1236 invalid_argument ("Must be composite char", ch);
1236 return composite_char_string (emch); 1237 return composite_char_string (emch);
1237 } 1238 }
1238 #endif /* ENABLE_COMPOSITE_CHARS */ 1239 #endif /* ENABLE_COMPOSITE_CHARS */
1239 1240
1240 1241
1273 #ifdef ENABLE_COMPOSITE_CHARS 1274 #ifdef ENABLE_COMPOSITE_CHARS
1274 DEFSUBR (Fmake_composite_char); 1275 DEFSUBR (Fmake_composite_char);
1275 DEFSUBR (Fcomposite_char_string); 1276 DEFSUBR (Fcomposite_char_string);
1276 #endif 1277 #endif
1277 1278
1278 defsymbol (&Qcharsetp, "charsetp"); 1279 DEFSYMBOL (Qcharsetp);
1279 defsymbol (&Qregistry, "registry"); 1280 DEFSYMBOL (Qregistry);
1280 defsymbol (&Qfinal, "final"); 1281 DEFSYMBOL (Qfinal);
1281 defsymbol (&Qgraphic, "graphic"); 1282 DEFSYMBOL (Qgraphic);
1282 defsymbol (&Qdirection, "direction"); 1283 DEFSYMBOL (Qdirection);
1283 defsymbol (&Qreverse_direction_charset, "reverse-direction-charset"); 1284 DEFSYMBOL (Qreverse_direction_charset);
1284 defsymbol (&Qshort_name, "short-name"); 1285 DEFSYMBOL (Qshort_name);
1285 defsymbol (&Qlong_name, "long-name"); 1286 DEFSYMBOL (Qlong_name);
1286 1287
1287 defsymbol (&Ql2r, "l2r"); 1288 DEFSYMBOL (Ql2r);
1288 defsymbol (&Qr2l, "r2l"); 1289 DEFSYMBOL (Qr2l);
1289 1290
1290 /* Charsets, compatible with FSF 20.3 1291 /* Charsets, compatible with FSF 20.3
1291 Naming convention is Script-Charset[-Edition] */ 1292 Naming convention is Script-Charset[-Edition] */
1292 defsymbol (&Qascii, "ascii"); 1293 DEFSYMBOL (Qascii);
1293 defsymbol (&Qcontrol_1, "control-1"); 1294 DEFSYMBOL (Qcontrol_1);
1294 defsymbol (&Qlatin_iso8859_1, "latin-iso8859-1"); 1295 DEFSYMBOL (Qlatin_iso8859_1);
1295 defsymbol (&Qlatin_iso8859_2, "latin-iso8859-2"); 1296 DEFSYMBOL (Qlatin_iso8859_2);
1296 defsymbol (&Qlatin_iso8859_3, "latin-iso8859-3"); 1297 DEFSYMBOL (Qlatin_iso8859_3);
1297 defsymbol (&Qlatin_iso8859_4, "latin-iso8859-4"); 1298 DEFSYMBOL (Qlatin_iso8859_4);
1298 defsymbol (&Qthai_tis620, "thai-tis620"); 1299 DEFSYMBOL (Qthai_tis620);
1299 defsymbol (&Qgreek_iso8859_7, "greek-iso8859-7"); 1300 DEFSYMBOL (Qgreek_iso8859_7);
1300 defsymbol (&Qarabic_iso8859_6, "arabic-iso8859-6"); 1301 DEFSYMBOL (Qarabic_iso8859_6);
1301 defsymbol (&Qhebrew_iso8859_8, "hebrew-iso8859-8"); 1302 DEFSYMBOL (Qhebrew_iso8859_8);
1302 defsymbol (&Qkatakana_jisx0201, "katakana-jisx0201"); 1303 DEFSYMBOL (Qkatakana_jisx0201);
1303 defsymbol (&Qlatin_jisx0201, "latin-jisx0201"); 1304 DEFSYMBOL (Qlatin_jisx0201);
1304 defsymbol (&Qcyrillic_iso8859_5, "cyrillic-iso8859-5"); 1305 DEFSYMBOL (Qcyrillic_iso8859_5);
1305 defsymbol (&Qlatin_iso8859_9, "latin-iso8859-9"); 1306 DEFSYMBOL (Qlatin_iso8859_9);
1306 defsymbol (&Qjapanese_jisx0208_1978, "japanese-jisx0208-1978"); 1307 DEFSYMBOL (Qjapanese_jisx0208_1978);
1307 defsymbol (&Qchinese_gb2312, "chinese-gb2312"); 1308 DEFSYMBOL (Qchinese_gb2312);
1308 defsymbol (&Qjapanese_jisx0208, "japanese-jisx0208"); 1309 DEFSYMBOL (Qjapanese_jisx0208);
1309 defsymbol (&Qkorean_ksc5601, "korean-ksc5601"); 1310 DEFSYMBOL (Qkorean_ksc5601);
1310 defsymbol (&Qjapanese_jisx0212, "japanese-jisx0212"); 1311 DEFSYMBOL (Qjapanese_jisx0212);
1311 defsymbol (&Qchinese_cns11643_1, "chinese-cns11643-1"); 1312 DEFSYMBOL (Qchinese_cns11643_1);
1312 defsymbol (&Qchinese_cns11643_2, "chinese-cns11643-2"); 1313 DEFSYMBOL (Qchinese_cns11643_2);
1313 defsymbol (&Qchinese_big5_1, "chinese-big5-1"); 1314 DEFSYMBOL (Qchinese_big5_1);
1314 defsymbol (&Qchinese_big5_2, "chinese-big5-2"); 1315 DEFSYMBOL (Qchinese_big5_2);
1315 1316
1316 defsymbol (&Qcomposite, "composite"); 1317 DEFSYMBOL (Qcomposite);
1317 } 1318 }
1318 1319
1319 void 1320 void
1320 vars_of_mule_charset (void) 1321 vars_of_mule_charset (void)
1321 { 1322 {