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