src/coding.h

   1 /* Header for coding system handler.
   2    Copyright (C) 1995, 1997 Electrotechnical Laboratory, JAPAN.
   3    Licensed to the Free Software Foundation.
   4    Copyright (C) 2001, 2002
   5      National Institute of Advanced Industrial Science and Technology (AIST)
   6      Registration Number H13PRO009
   7
   8 This file is part of GNU Emacs.
   9
  10 GNU Emacs is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2, or (at your option)
  13 any later version.
  14
  15 GNU Emacs is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GNU Emacs; see the file COPYING.  If not, write to
  22 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 Boston, MA 02111-1307, USA.  */
  24
  25 #ifndef EMACS_CODING_H
  26 #define EMACS_CODING_H
  27
  28 /* Index to arguments of Fdefine_coding_system_internal.  */
  29
  30 enum define_coding_system_arg_index
  31   {
  32     coding_arg_name,
  33     coding_arg_mnemonic,
  34     coding_arg_coding_type,
  35     coding_arg_charset_list,
  36     coding_arg_ascii_compatible_p,
  37     coding_arg_decode_translation_table,
  38     coding_arg_encode_translation_table,
  39     coding_arg_post_read_conversion,
  40     coding_arg_pre_write_conversion,
  41     coding_arg_default_char,
  42     coding_arg_plist,
  43     coding_arg_eol_type,
  44     coding_arg_max
  45   };
  46
  47 enum define_coding_iso2022_arg_index
  48   {
  49     coding_arg_iso2022_initial = coding_arg_max,
  50     coding_arg_iso2022_reg_usage,
  51     coding_arg_iso2022_request,
  52     coding_arg_iso2022_flags,
  53     coding_arg_iso2022_max
  54   };
  55
  56 enum define_coding_utf16_arg_index
  57   {
  58     coding_arg_utf16_bom = coding_arg_max,
  59     coding_arg_utf16_endian,
  60     coding_arg_utf16_max
  61   };
  62
  63 enum define_coding_ccl_arg_index
  64   {
  65     coding_arg_ccl_decoder,
  66     coding_arg_ccl_encoder,
  67     coding_arg_ccl_valids,
  68     coding_arg_ccl_max
  69   };
  70
  71 extern Lisp_Object Vcoding_system_hash_table;
  72
  73 /* Enumeration of coding system type.  */
  74
  75 enum coding_system_type
  76   {
  77     coding_type_charset,
  78     coding_type_utf_8,
  79     coding_type_utf_16,
  80     coding_type_iso_2022,
  81     coding_type_emacs_mule,
  82     coding_type_sjis,
  83     coding_type_ccl,
  84     coding_type_raw_text,
  85     coding_type_undecided,
  86     coding_type_max
  87   };
  88
  89
  90 /* Enumeration of end-of-line format type.  */
  91
  92 enum end_of_line_type
  93   {
  94     eol_lf,             /* Line-feed only, same as Emacs' internal
  95                            format.  */
  96     eol_crlf,           /* Sequence of carriage-return and
  97                            line-feed.  */
  98     eol_cr,             /* Carriage-return only.  */
  99     eol_any,            /* Accept any of above.  Produce line-feed
 100                            only.  */
 101     eol_undecided,      /* This value is used to denote that the
 102                            eol-type is not yet undecided.  */
 103     eol_type_max
 104   };
 105
 106 /* Enumeration of index to an attribute vector of a coding system.  */
 107
 108 enum coding_attr_index
 109   {
 110     coding_attr_base_name,
 111     coding_attr_docstring,
 112     coding_attr_mnemonic,
 113     coding_attr_type,
 114     coding_attr_charset_list,
 115     coding_attr_ascii_compat,
 116     coding_attr_decode_tbl,
 117     coding_attr_encode_tbl,
 118     coding_attr_post_read,
 119     coding_attr_pre_write,
 120     coding_attr_default_char,
 121     coding_attr_plist,
 122
 123     coding_attr_category,
 124     coding_attr_safe_charsets,
 125
 126     /* The followings are extra attributes for each type.  */
 127     coding_attr_charset_valids,
 128
 129     coding_attr_ccl_decoder,
 130     coding_attr_ccl_encoder,
 131     coding_attr_ccl_valids,
 132
 133     coding_attr_iso_initial,
 134     coding_attr_iso_usage,
 135     coding_attr_iso_request,
 136     coding_attr_iso_flags,
 137
 138     coding_attr_utf_16_bom,
 139     coding_attr_utf_16_endian,
 140
 141     coding_attr_emacs_mule_full,
 142
 143     coding_attr_last_index
 144   };
 145
 146
 147 #define CODING_ATTR_BASE_NAME(attrs)    AREF (attrs, coding_attr_base_name)
 148 #define CODING_ATTR_TYPE(attrs)         AREF (attrs, coding_attr_type)
 149 #define CODING_ATTR_CHARSET_LIST(attrs) AREF (attrs, coding_attr_charset_list)
 150 #define CODING_ATTR_MNEMONIC(attrs)     AREF (attrs, coding_attr_mnemonic)
 151 #define CODING_ATTR_DOCSTRING(attrs)    AREF (attrs, coding_attr_docstring)
 152 #define CODING_ATTR_ASCII_COMPAT(attrs) AREF (attrs, coding_attr_ascii_compat)
 153 #define CODING_ATTR_DECODE_TBL(attrs)   AREF (attrs, coding_attr_decode_tbl)
 154 #define CODING_ATTR_ENCODE_TBL(attrs)   AREF (attrs, coding_attr_encode_tbl)
 155 #define CODING_ATTR_POST_READ(attrs)    AREF (attrs, coding_attr_post_read)
 156 #define CODING_ATTR_PRE_WRITE(attrs)    AREF (attrs, coding_attr_pre_write)
 157 #define CODING_ATTR_DEFAULT_CHAR(attrs) AREF (attrs, coding_attr_default_char)
 158 #define CODING_ATTR_DIRECTION(attrs)    AREF (attrs, coding_attr_direction)
 159 #define CODING_ATTR_FLUSHING(attrs)     AREF (attrs, coding_attr_flushing)
 160 #define CODING_ATTR_PLIST(attrs)        AREF (attrs, coding_attr_plist)
 161 #define CODING_ATTR_CATEGORY(attrs)     AREF (attrs, coding_attr_category)
 162 #define CODING_ATTR_SAFE_CHARSETS(attrs)AREF (attrs, coding_attr_safe_charsets)
 163
 164
 165 #define CODING_ID_ATTRS(id)     \
 166   (AREF (HASH_VALUE (XHASH_TABLE (Vcoding_system_hash_table), id), 0))
 167
 168 #define CODING_ID_ALIASES(id)   \
 169   (AREF (HASH_VALUE (XHASH_TABLE (Vcoding_system_hash_table), id), 1))
 170
 171 #define CODING_ID_EOL_TYPE(id)  \
 172   (AREF (HASH_VALUE (XHASH_TABLE (Vcoding_system_hash_table), id), 2))
 173
 174 #define CODING_ID_NAME(id) \
 175   (HASH_KEY (XHASH_TABLE (Vcoding_system_hash_table), id))
 176
 177 #define CODING_SYSTEM_SPEC(coding_system_symbol)        \
 178   (Fgethash (coding_system_symbol, Vcoding_system_hash_table, Qnil))
 179
 180 #define CODING_SYSTEM_ID(coding_system_symbol)                  \
 181   hash_lookup (XHASH_TABLE (Vcoding_system_hash_table),         \
 182                coding_system_symbol, NULL)
 183
 184 #define CODING_SYSTEM_P(coding_system_symbol)   \
 185   (! NILP (CODING_SYSTEM_SPEC (coding_system_symbol)))
 186
 187 #define  CHECK_CODING_SYSTEM(x)                         \
 188   do {                                                  \
 189     if (!CODING_SYSTEM_P (x))                           \
 190       x = wrong_type_argument (Qcoding_system_p, (x));  \
 191   } while (0)
 192
 193
 194 #define CHECK_CODING_SYSTEM_GET_SPEC(x, spec)           \
 195   do {                                                  \
 196     spec = CODING_SYSTEM_SPEC (x);                      \
 197     if (NILP (spec))                                    \
 198       x = wrong_type_argument (Qcoding_system_p, (x));  \
 199   } while (0)
 200
 201
 202 #define CHECK_CODING_SYSTEM_GET_ID(x, id)                       \
 203   do                                                            \
 204     {                                                           \
 205       id = CODING_SYSTEM_ID (x);                                \
 206       if (id < 0)                                               \
 207         x = wrong_type_argument (Qcoding_system_p, (x));        \
 208     } while (0)
 209
 210
 211 /*** GENERAL section ***/
 212
 213 /* Enumeration of result code of code conversion.  */
 214 enum coding_result_code
 215   {
 216     CODING_RESULT_SUCCESS,
 217     CODING_RESULT_INSUFFICIENT_SRC,
 218     CODING_RESULT_INSUFFICIENT_DST,
 219     CODING_RESULT_INCONSISTENT_EOL,
 220     CODING_RESULT_INSUFFICIENT_CMP,
 221     CODING_RESULT_INTERRUPT,
 222     CODING_RESULT_INSUFFICIENT_MEM
 223   };
 224
 225
 226 /* Macros used for the member `mode' of the struct coding_system.  */
 227
 228 /* If set, recover the original CR or LF of the already decoded text
 229    when the decoding routine encounters an inconsistent eol format.  */
 230 #define CODING_MODE_INHIBIT_INCONSISTENT_EOL    0x01
 231
 232 /* If set, the decoding/encoding routines treat the current data as
 233    the last block of the whole text to be converted, and do
 234    appropriate fisishing job.  */
 235 #define CODING_MODE_LAST_BLOCK                  0x02
 236
 237 /* If set, it means that the current source text is in a buffer which
 238    enables selective display.  */
 239 #define CODING_MODE_SELECTIVE_DISPLAY           0x04
 240
 241 /* This flag is used by the decoding/encoding routines on the fly.  If
 242    set, it means that right-to-left text is being processed.  */
 243 #define CODING_MODE_DIRECTION                   0x08
 244
 245 #define CODING_MODE_FIXED_DESTINATION           0x10
 246
 247 #define CODING_MODE_SAFE_ENCODING               0x20
 248
 249 /* Structure of the field `spec.iso_2022' in the structure
 250    `coding_system'.  */
 251 struct iso_2022_spec
 252 {
 253   /* Bit-wise-or of CODING_ISO_FLAG_XXX.  */
 254   unsigned flags;
 255
 256   /* The current graphic register invoked to each graphic plane.  */
 257   int current_invocation[2];
 258
 259   /* The current charset designated to each graphic register.  The
 260      value -1 means that not charset is designated, -2 means that
 261      there was an invalid designation previously.  */
 262   int current_designation[4];
 263
 264   /* Set to 1 temporarily only when graphic register 2 or 3 is invoked
 265      by single-shift while encoding.  */
 266   int single_shifting;
 267
 268   /* Set to 1 temporarily only when processing at beginning of line.  */
 269   int bol;
 270 };
 271
 272 struct ccl_spec;
 273
 274 enum utf_16_bom_type
 275   {
 276     utf_16_detect_bom,
 277     utf_16_without_bom,
 278     utf_16_with_bom
 279   };
 280
 281 enum utf_16_endian_type
 282   {
 283     utf_16_big_endian,
 284     utf_16_little_endian
 285   };
 286
 287 struct utf_16_spec
 288 {
 289   enum utf_16_bom_type bom;
 290   enum utf_16_endian_type endian;
 291   int surrogate;
 292 };
 293
 294 struct coding_system
 295 {
 296   /* ID number of the coding system.  This is an index to
 297      Vcoding_system_hash_table.  This value is set by
 298      setup_coding_system.  At the early stage of building time, this
 299      value is -1 in the array coding_categories to indicate that no
 300      coding-system of that category is yet defined.  */
 301   int id;
 302
 303   /* Flag bits of the coding system.  The meaning of each bit is common
 304      to all types of coding systems.  */
 305   int common_flags;
 306
 307   /* Mode bits of the coding system.  See the comments of the macros
 308      CODING_MODE_XXX.  */
 309   unsigned int mode;
 310
 311   /* Detailed information specific to each type of coding system.  */
 312   union
 313     {
 314       struct iso_2022_spec iso_2022;
 315       struct ccl_spec *ccl;     /* Defined in ccl.h.  */
 316       struct utf_16_spec utf_16;
 317       int emacs_mule_full_support;
 318     } spec;
 319
 320   int max_charset_id;
 321   char *safe_charsets;
 322
 323   /* The following two members specify how binary 8-bit code 128..255
 324      are represented in source and destination text respectively.  1
 325      means they are represented by 2-byte sequence, 0 means they are
 326      represented by 1-byte as is (see the comment in character.h).  */
 327   unsigned src_multibyte : 1;
 328   unsigned dst_multibyte : 1;
 329
 330   /* How may heading bytes we can skip for decoding.  This is set to
 331      -1 in setup_coding_system, and updated by detect_coding.  So,
 332      when this is equal to the byte length of the text being
 333      converted, we can skip the actual conversion process.  */
 334   int head_ascii;
 335
 336   /* The following members are set by encoding/decoding routine.  */
 337   EMACS_INT produced, produced_char, consumed, consumed_char;
 338
 339   /* Number of error source data found in a decoding routine.  */
 340   int errors;
 341
 342   /* Store the positions of error source data. */
 343   EMACS_INT *error_positions;
 344
 345   /* Finish status of code conversion.  */
 346   enum coding_result_code result;
 347
 348   /* The following members are all Lisp symbols.  We don't have to
 349      protect them from GC because the current garbage collection
 350      doesn't relocate Lisp symbols.  But, when it is changed, we must
 351      find a way to protect them.  */
 352
 353   EMACS_INT src_pos, src_pos_byte, src_chars, src_bytes;
 354   Lisp_Object src_object;
 355   unsigned char *source;
 356
 357   EMACS_INT dst_pos, dst_pos_byte, dst_bytes;
 358   Lisp_Object dst_object;
 359   unsigned char *destination;
 360
 361   int chars_at_source;
 362
 363   /* If an element is non-negative, it is a character code.
 364
 365      If it is in the range -128..-1, it is a 8-bit character code
 366      minus 256.
 367
 368      If it is less than -128, it specifies the start of an annotation
 369      chunk.  The length of the chunk is -128 minus the value of the
 370      element.  The following elements are OFFSET, ANNOTATION-TYPE, and
 371      a sequence of actual data for the annotation.  OFFSET is a
 372      character position offset from dst_pos or src_pos,
 373      ANNOTATION-TYPE specfies the meaning of the annotation and how to
 374      handle the following data..  */
 375   int *charbuf;
 376   int charbuf_size, charbuf_used;
 377
 378   /* Set to 1 if charbuf contains an annotation.  */
 379   int annotated;
 380
 381   unsigned char carryover[64];
 382   int carryover_bytes;
 383
 384   int default_char;
 385
 386   int (*detector) P_ ((struct coding_system *, int *));
 387   void (*decoder) P_ ((struct coding_system *));
 388   int (*encoder) P_ ((struct coding_system *));
 389 };
 390
 391 /* Meanings of bits in the member `common_flags' of the structure
 392    coding_system.  The lowest 8 bits are reserved for various kind of
 393    annotations (currently two of them are used).  */
 394 #define CODING_ANNOTATION_MASK                  0x00FF
 395 #define CODING_ANNOTATE_COMPOSITION_MASK        0x0001
 396 #define CODING_ANNOTATE_DIRECTION_MASK          0x0002
 397 #define CODING_FOR_UNIBYTE_MASK                 0x0100
 398 #define CODING_REQUIRE_FLUSHING_MASK            0x0200
 399 #define CODING_REQUIRE_DECODING_MASK            0x0400
 400 #define CODING_REQUIRE_ENCODING_MASK            0x0800
 401 #define CODING_REQUIRE_DETECTION_MASK           0x1000
 402 #define CODING_RESET_AT_BOL_MASK                0x2000
 403
 404 /* Return 1 if the coding context CODING requires annotaion
 405    handling.  */
 406 #define CODING_REQUIRE_ANNOTATION(coding) \
 407   ((coding)->common_flags & CODING_ANNOTATION_MASK)
 408
 409 /* Return 1 if the coding context CODING prefers decoding into unibyte.  */
 410 #define CODING_FOR_UNIBYTE(coding) \
 411   ((coding)->common_flags & CODING_FOR_UNIBYTE_MASK)
 412
 413 /* Return 1 if the coding context CODING requires specific code to be
 414    attached at the tail of converted text.  */
 415 #define CODING_REQUIRE_FLUSHING(coding) \
 416   ((coding)->common_flags & CODING_REQUIRE_FLUSHING_MASK)
 417
 418 /* Return 1 if the coding context CODING requires code conversion on
 419    decoding.  */
 420 #define CODING_REQUIRE_DECODING(coding) \
 421   ((coding)->dst_multibyte              \
 422    || (coding)->common_flags & CODING_REQUIRE_DECODING_MASK)
 423
 424
 425 /* Return 1 if the coding context CODING requires code conversion on
 426    encoding.  */
 427 #define CODING_REQUIRE_ENCODING(coding)                         \
 428   ((coding)->src_multibyte                                      \
 429    || (coding)->common_flags & CODING_REQUIRE_ENCODING_MASK     \
 430    || (coding)->mode & CODING_MODE_SELECTIVE_DISPLAY)
 431
 432
 433 /* Return 1 if the coding context CODING requires some kind of code
 434    detection.  */
 435 #define CODING_REQUIRE_DETECTION(coding) \
 436   ((coding)->common_flags & CODING_REQUIRE_DETECTION_MASK)
 437
 438 /* Return 1 if the coding context CODING requires code conversion on
 439    decoding or some kind of code detection.  */
 440 #define CODING_MAY_REQUIRE_DECODING(coding)     \
 441   (CODING_REQUIRE_DECODING (coding)             \
 442    || CODING_REQUIRE_DETECTION (coding))
 443
 444 /* Macros to decode or encode a character of JISX0208 in SJIS.  S1 and
 445    S2 are the 1st and 2nd position-codes of JISX0208 in SJIS coding
 446    system.  C1 and C2 are the 1st and 2nd position codes of Emacs'
 447    internal format.  */
 448
 449 #define SJIS_TO_JIS(code)                               \
 450   do {                                                  \
 451     int s1, s2, j1, j2;                                 \
 452                                                         \
 453     s1 = (code) >> 8, s2 = (code) & 0xFF;               \
 454                                                         \
 455     if (s2 >= 0x9F)                                     \
 456       (j1 = s1 * 2 - (s1 >= 0xE0 ? 0x160 : 0xE0),       \
 457        j2 = s2 - 0x7E);                                 \
 458     else                                                \
 459       (j1 = s1 * 2 - ((s1 >= 0xE0) ? 0x161 : 0xE1),     \
 460        j2 = s2 - ((s2 >= 0x7F) ? 0x20 : 0x1F));         \
 461     (code) = (j1 << 8) | j2;                            \
 462   } while (0)
 463
 464
 465 #define JIS_TO_SJIS(code)                               \
 466   do {                                                  \
 467     int s1, s2, j1, j2;                                 \
 468                                                         \
 469     j1 = (code) >> 8, j2 = (code) & 0xFF;               \
 470     if (j1 & 1)                                         \
 471       (s1 = j1 / 2 + ((j1 < 0x5F) ? 0x71 : 0xB1),       \
 472        s2 = j2 + ((j2 >= 0x60) ? 0x20 : 0x1F));         \
 473     else                                                \
 474       (s1 = j1 / 2 + ((j1 < 0x5F) ? 0x70 : 0xB0),       \
 475        s2 = j2 + 0x7E);                                 \
 476     (code) = (s1 << 8) | s2;                            \
 477   } while (0)
 478
 479
 480 /* Encode the file name NAME using the specified coding system
 481    for file names, if any.  */
 482 #define ENCODE_FILE(name)                                                  \
 483   (! NILP (Vfile_name_coding_system)                                       \
 484    && XFASTINT (Vfile_name_coding_system) != 0                             \
 485    ? code_convert_string_norecord (name, Vfile_name_coding_system, 1)      \
 486    : (! NILP (Vdefault_file_name_coding_system)                            \
 487       && XFASTINT (Vdefault_file_name_coding_system) != 0                  \
 488       ? code_convert_string_norecord (name, Vdefault_file_name_coding_system, 1) \
 489       : name))
 490
 491
 492 /* Decode the file name NAME using the specified coding system
 493    for file names, if any.  */
 494 #define DECODE_FILE(name)                                                  \
 495   (! NILP (Vfile_name_coding_system)                                       \
 496    && XFASTINT (Vfile_name_coding_system) != 0                             \
 497    ? code_convert_string_norecord (name, Vfile_name_coding_system, 0)      \
 498    : (! NILP (Vdefault_file_name_coding_system)                            \
 499       && XFASTINT (Vdefault_file_name_coding_system) != 0                  \
 500       ? code_convert_string_norecord (name, Vdefault_file_name_coding_system, 0) \
 501       : name))
 502
 503
 504 #ifdef WINDOWSNT
 505 /* Encode the string STR using the specified coding system
 506    for w32 system functions, if any.  */
 507 #define ENCODE_SYSTEM(str)                                              \
 508   (! NILP (Vlocale_coding_system)                                       \
 509    && XFASTINT (Vlocale_coding_system) != 0                             \
 510    ? code_convert_string_norecord (str, Vlocale_coding_system, 1)       \
 511    : str)
 512
 513 /* Decode the string STR using the specified coding system
 514    for w32 system functions, if any.  */
 515 #define DECODE_SYSTEM(name)                                             \
 516   (! NILP (Vlocale_coding_system)                                       \
 517    && XFASTINT (Vlocale_coding_system) != 0                             \
 518    ? code_convert_string_norecord (str, Vlocale_coding_system, 0)       \
 519    : str)
 520
 521 #else /* WINDOWSNT */
 522
 523 #define ENCODE_SYSTEM(str) string_make_unibyte(str)
 524 #define DECODE_SYSTEM(name) name
 525
 526 #endif /* !WINDOWSNT */
 527
 528 /* Extern declarations.  */
 529 extern Lisp_Object make_conversion_work_buffer P_ ((int));
 530 extern Lisp_Object code_conversion_restore P_ ((Lisp_Object));
 531 extern int decoding_buffer_size P_ ((struct coding_system *, int));
 532 extern int encoding_buffer_size P_ ((struct coding_system *, int));
 533 extern void setup_coding_system P_ ((Lisp_Object, struct coding_system *));
 534 extern void detect_coding P_ ((struct coding_system *));
 535 extern Lisp_Object code_convert_region P_ ((EMACS_INT, EMACS_INT,
 536                                             Lisp_Object, Lisp_Object,
 537                                             int, int));
 538 extern Lisp_Object code_convert_string P_ ((Lisp_Object, Lisp_Object,
 539                                             Lisp_Object, int, int, int));
 540 extern Lisp_Object code_convert_string_norecord P_ ((Lisp_Object, Lisp_Object,
 541                                                      int));
 542 extern Lisp_Object raw_text_coding_system P_ ((Lisp_Object));
 543 extern Lisp_Object coding_inherit_eol_type P_ ((Lisp_Object, Lisp_Object));
 544
 545 extern int decode_coding_gap P_ ((struct coding_system *,
 546                                   EMACS_INT, EMACS_INT));
 547 extern int encode_coding_gap P_ ((struct coding_system *,
 548                                   EMACS_INT, EMACS_INT));
 549 extern void decode_coding_object P_ ((struct coding_system *,
 550                                       Lisp_Object, EMACS_INT, EMACS_INT,
 551                                       EMACS_INT, EMACS_INT, Lisp_Object));
 552 extern void encode_coding_object P_ ((struct coding_system *,
 553                                       Lisp_Object, EMACS_INT, EMACS_INT,
 554                                       EMACS_INT, EMACS_INT, Lisp_Object));
 555
 556 #define decode_coding_region(coding, from, to)          \
 557   decode_coding_object (coding, Fcurrent_buffer (),     \
 558                         from, CHAR_TO_BYTE (from),      \
 559                         to, CHAR_TO_BYTE (to), Fcurrent_buffer ())
 560
 561
 562 #define encode_coding_region(coding, from, to)          \
 563   encode_coding_object (coding, Fcurrent_buffer (),     \
 564                         from, CHAR_TO_BYTE (from),      \
 565                         to, CHAR_TO_BYTE (to), Fcurrent_buffer ())
 566
 567
 568 #define decode_coding_string(coding, string, nocopy)                    \
 569   decode_coding_object (coding, string, 0, 0, XSTRING (string)->size,   \
 570                         STRING_BYTES (XSTRING (string)), Qt)
 571
 572 #define encode_coding_string(coding, string, nocopy)                    \
 573   (encode_coding_object (coding, string, 0, 0, XSTRING (string)->size,  \
 574                          STRING_BYTES (XSTRING (string)), Qt),          \
 575    (coding)->dst_object)
 576
 577
 578 #define decode_coding_c_string(coding, src, bytes, dst_object)          \
 579   do {                                                                  \
 580     (coding)->source = (src);                                           \
 581     (coding)->src_chars = (coding)->src_bytes = (bytes);                \
 582     decode_coding_object ((coding), Qnil, 0, 0, (bytes), (bytes),       \
 583                           (dst_object));                                \
 584   } while (0)
 585
 586
 587 extern Lisp_Object preferred_coding_system P_ (());
 588
 589
 590 extern Lisp_Object Qcoding_system, Qeol_type, Qcoding_category_index;
 591 extern Lisp_Object Qcoding_system_p;
 592 extern Lisp_Object Qraw_text, Qemacs_mule, Qno_conversion, Qundecided;
 593 extern Lisp_Object Qiso_2022;
 594 extern Lisp_Object Qbuffer_file_coding_system;
 595
 596 extern Lisp_Object Qunix, Qdos, Qmac;
 597
 598 extern Lisp_Object Qtranslation_table;
 599 extern Lisp_Object Qtranslation_table_id;
 600
 601 /* Mnemonic strings to indicate each type of end-of-line.  */
 602 extern Lisp_Object eol_mnemonic_unix, eol_mnemonic_dos, eol_mnemonic_mac;
 603 /* Mnemonic string to indicate type of end-of-line is not yet decided.  */
 604 extern Lisp_Object eol_mnemonic_undecided;
 605
 606 #ifdef emacs
 607 extern Lisp_Object Qfile_coding_system;
 608 extern Lisp_Object Qcall_process, Qcall_process_region, Qprocess_argument;
 609 extern Lisp_Object Qstart_process, Qopen_network_stream;
 610 extern Lisp_Object Qwrite_region;
 611
 612 extern char *emacs_strerror P_ ((int));
 613
 614 /* Coding-system for reading files and receiving data from process.  */
 615 extern Lisp_Object Vcoding_system_for_read;
 616 /* Coding-system for writing files and sending data to process.  */
 617 extern Lisp_Object Vcoding_system_for_write;
 618 /* Coding-system actually used in the latest I/O.  */
 619 extern Lisp_Object Vlast_coding_system_used;
 620 /* Coding-system to use with system messages (e.g. strerror).  */
 621 extern Lisp_Object Vlocale_coding_system;
 622
 623 /* If non-zero, process buffer inherits the coding system used to decode
 624    the subprocess output.  */
 625 extern int inherit_process_coding_system;
 626
 627 /* Coding-system to be used for encoding terminal output.  This
 628    structure contains information of a coding-system specified by the
 629    function `set-terminal-coding-system'.  */
 630 extern struct coding_system terminal_coding;
 631
 632 /* Coding system to be used to encode text for terminal display when
 633    terminal coding system is nil.  */
 634 extern struct coding_system safe_terminal_coding;
 635
 636 /* Coding-system of what is sent from terminal keyboard.  This
 637    structure contains information of a coding-system specified by the
 638    function `set-keyboard-coding-system'.  */
 639 extern struct coding_system keyboard_coding;
 640
 641 /* Default coding systems used for process I/O.  */
 642 extern Lisp_Object Vdefault_process_coding_system;
 643
 644 /* Function to call to force a user to force select a propert coding
 645    system.  */
 646 extern Lisp_Object Vselect_safe_coding_system_function;
 647
 648 /* Coding system for file names, or nil if none.  */
 649 extern Lisp_Object Vfile_name_coding_system;
 650
 651 /* Coding system for file names used only when
 652    Vfile_name_coding_system is nil.  */
 653 extern Lisp_Object Vdefault_file_name_coding_system;
 654
 655 #endif
 656
 657 /* Error signaled when there's a problem with detecting coding system */
 658 extern Lisp_Object Qcoding_system_error;
 659
 660 extern char emacs_mule_bytes[256];
 661 extern int emacs_mule_string_char P_ ((unsigned char *));
 662
 663 #endif /* EMACS_CODING_H */