git.chise.org Git - chise/xemacs-chise.git.1/blob - src/buffer.h

   1 /* Header file for the buffer manipulation primitives.
   2    Copyright (C) 1985, 1986, 1992, 1993, 1994, 1995
   3    Free Software Foundation, Inc.
   4    Copyright (C) 1995 Sun Microsystems, Inc.
   5
   6 This file is part of XEmacs.
   7
   8 XEmacs is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with XEmacs; see the file COPYING.  If not, write to
  20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 /* Synched up with: FSF 19.30. */
  24
  25 /* Authorship:
  26
  27    FSF: long ago.
  28    JWZ: separated out bufslots.h, early in Lemacs.
  29    Ben Wing: almost completely rewritten for Mule, 19.12.
  30  */
  31
  32 #ifndef INCLUDED_buffer_h_
  33 #define INCLUDED_buffer_h_
  34
  35 #ifdef MULE
  36 #include "mule-charset.h"
  37 #endif
  38
  39 #include "casetab.h"
  40 #include "chartab.h"
  41
  42 /************************************************************************/
  43 /*                                                                      */
  44 /*                    definition of Lisp buffer object                  */
  45 /*                                                                      */
  46 /************************************************************************/
  47
  48 /* Note: we keep both Bytind and Bufpos versions of some of the
  49    important buffer positions because they are accessed so much.
  50    If we didn't do this, we would constantly be invalidating the
  51    bufpos<->bytind cache under Mule.
  52
  53    Note that under non-Mule, both versions will always be the
  54    same so we don't really need to keep track of them.  But it
  55    simplifies the logic to go ahead and do so all the time and
  56    the memory loss is insignificant. */
  57
  58 /* Formerly, it didn't much matter what went inside the struct buffer_text
  59    and what went outside it.  Now it does, with the advent of "indirect
  60    buffers" that share text with another buffer.  An indirect buffer
  61    shares the same *text* as another buffer, but has its own buffer-local
  62    variables, its own accessible region, and its own markers and extents.
  63    (Due to the nature of markers, it doesn't actually matter much whether
  64    we stick them inside or out of the struct buffer_text -- the user won't
  65    notice any difference -- but we go ahead and put them outside for
  66    consistency and overall saneness of algorithm.)
  67
  68    FSFmacs gets away with not maintaining any "children" pointers from
  69    a buffer to the indirect buffers that refer to it by putting the
  70    markers inside of the struct buffer_text, using markers to keep track
  71    of BEGV and ZV in indirect buffers, and relying on the fact that
  72    all intervals (text properties and overlays) use markers for their
  73    start and end points.  We don't do this for extents (markers are
  74    inefficient anyway and take up space), so we have to maintain
  75    children pointers.  This is not terribly hard, though, and the
  76    code to maintain this is just like the code already present in
  77    extent-parent and extent-children.
  78    */
  79
  80 struct buffer_text
  81 {
  82   Bufbyte *beg;         /* Actual address of buffer contents. */
  83   Bytind gpt;           /* Index of gap in buffer. */
  84   Bytind z;             /* Index of end of buffer. */
  85   Bufpos bufz;          /* Equivalent as a Bufpos. */
  86   int gap_size;         /* Size of buffer's gap */
  87   int end_gap_size;     /* Size of buffer's end gap */
  88   long modiff;          /* This counts buffer-modification events
  89                            for this buffer.  It is incremented for
  90                            each such event, and never otherwise
  91                            changed.  */
  92   long save_modiff;     /* Previous value of modiff, as of last
  93                            time buffer visited or saved a file.  */
  94
  95 #ifdef MULE
  96   /* We keep track of a "known" region for very fast access.
  97      This information is text-only so it goes here. */
  98   Bufpos mule_bufmin, mule_bufmax;
  99   Bytind mule_bytmin, mule_bytmax;
 100   int mule_shifter, mule_three_p;
 101
 102   /* And we also cache 16 positions for fairly fast access near those
 103      positions. */
 104   Bufpos mule_bufpos_cache[16];
 105   Bytind mule_bytind_cache[16];
 106 #endif
 107
 108   /* Similar to the above, we keep track of positions for which line
 109      number has last been calculated.  See line-number.c. */
 110   Lisp_Object line_number_cache;
 111
 112   /* Change data that goes with the text. */
 113   struct buffer_text_change_data *changes;
 114
 115 };
 116
 117 struct buffer
 118 {
 119   struct lcrecord_header header;
 120
 121   /* This structure holds the coordinates of the buffer contents
 122      in ordinary buffers.  In indirect buffers, this is not used.  */
 123   struct buffer_text own_text;
 124
 125   /* This points to the `struct buffer_text' that is used for this buffer.
 126      In an ordinary buffer, this is the own_text field above.
 127      In an indirect buffer, this is the own_text field of another buffer.  */
 128   struct buffer_text *text;
 129
 130   Bytind pt;            /* Position of point in buffer. */
 131   Bufpos bufpt;         /* Equivalent as a Bufpos. */
 132   Bytind begv;          /* Index of beginning of accessible range. */
 133   Bufpos bufbegv;       /* Equivalent as a Bufpos. */
 134   Bytind zv;            /* Index of end of accessible range. */
 135   Bufpos bufzv;         /* Equivalent as a Bufpos. */
 136
 137   int face_change;      /* This is set when a change in how the text should
 138                            be displayed (e.g., font, color) is made. */
 139
 140   /* change data indicating what portion of the text has changed
 141      since the last time this was reset.  Used by redisplay.
 142      Logically we should keep this with the text structure, but
 143      redisplay resets it for each buffer individually and we don't
 144      want interference between an indirect buffer and its base
 145      buffer. */
 146   struct each_buffer_change_data *changes;
 147
 148 #ifdef REGION_CACHE_NEEDS_WORK
 149   /* If the long line scan cache is enabled (i.e. the buffer-local
 150      variable cache-long-line-scans is non-nil), newline_cache
 151      points to the newline cache, and width_run_cache points to the
 152      width run cache.
 153
 154      The newline cache records which stretches of the buffer are
 155      known *not* to contain newlines, so that they can be skipped
 156      quickly when we search for newlines.
 157
 158      The width run cache records which stretches of the buffer are
 159      known to contain characters whose widths are all the same.  If
 160      the width run cache maps a character to a value > 0, that value
 161      is the character's width; if it maps a character to zero, we
 162      don't know what its width is.  This allows compute_motion to
 163      process such regions very quickly, using algebra instead of
 164      inspecting each character.  See also width_table, below.  */
 165   struct region_cache *newline_cache;
 166   struct region_cache *width_run_cache;
 167 #endif /* REGION_CACHE_NEEDS_WORK */
 168
 169   /* The markers that refer to this buffer.  This is actually a single
 170      marker -- successive elements in its marker `chain' are the other
 171      markers referring to this buffer */
 172   Lisp_Marker *markers;
 173
 174   /* The buffer's extent info.  This is its own type, an extent-info
 175      object (done this way for ease in marking / finalizing). */
 176   Lisp_Object extent_info;
 177
 178   /* ----------------------------------------------------------------- */
 179   /* All the stuff above this line is the responsibility of insdel.c,
 180      with some help from marker.c and extents.c.
 181      All the stuff below this line is the responsibility of buffer.c. */
 182
 183   /* In an indirect buffer, this points to the base buffer.
 184      In an ordinary buffer, it is 0.
 185      We DO mark through this slot. */
 186   struct buffer *base_buffer;
 187
 188   /* List of indirect buffers whose base is this buffer.
 189      If we are an indirect buffer, this will be nil.
 190      Do NOT mark through this. */
 191   Lisp_Object indirect_children;
 192
 193   /* Flags saying which DEFVAR_PER_BUFFER variables
 194      are local to this buffer.  */
 195   int local_var_flags;
 196
 197   /* Set to the modtime of the visited file when read or written.
 198      -1 means visited file was nonexistent.
 199      0  means visited file modtime unknown; in no case complain
 200      about any mismatch on next save attempt.  */
 201   int modtime;
 202
 203   /* the value of text->modiff at the last auto-save.  */
 204   long auto_save_modified;
 205
 206   /* The time at which we detected a failure to auto-save,
 207      Or -1 if we didn't have a failure.  */
 208   int auto_save_failure_time;
 209
 210   /* Position in buffer at which display started
 211      the last time this buffer was displayed.  */
 212   int last_window_start;
 213
 214   /* Everything from here down must be a Lisp_Object */
 215
 216 #define MARKED_SLOT(x) Lisp_Object x
 217 #include "bufslots.h"
 218 #undef MARKED_SLOT
 219 };
 220
 221 DECLARE_LRECORD (buffer, struct buffer);
 222 #define XBUFFER(x) XRECORD (x, buffer, struct buffer)
 223 #define XSETBUFFER(x, p) XSETRECORD (x, p, buffer)
 224 #define BUFFERP(x) RECORDP (x, buffer)
 225 #define CHECK_BUFFER(x) CHECK_RECORD (x, buffer)
 226 #define CONCHECK_BUFFER(x) CONCHECK_RECORD (x, buffer)
 227
 228 #define BUFFER_LIVE_P(b) (!NILP ((b)->name))
 229
 230 #define CHECK_LIVE_BUFFER(x) do {                       \
 231   CHECK_BUFFER (x);                                     \
 232   if (!BUFFER_LIVE_P (XBUFFER (x)))                     \
 233     dead_wrong_type_argument (Qbuffer_live_p, (x));     \
 234 } while (0)
 235
 236 #define CONCHECK_LIVE_BUFFER(x) do {                    \
 237   CONCHECK_BUFFER (x);                                  \
 238   if (!BUFFER_LIVE_P (XBUFFER (x)))                     \
 239     x = wrong_type_argument (Qbuffer_live_p, (x));      \
 240 } while (0)
 241
 242 \f
 243 #define BUFFER_BASE_BUFFER(b) ((b)->base_buffer ? (b)->base_buffer : (b))
 244
 245 /* Map over buffers sharing the same text as MPS_BUF.  MPS_BUFVAR is a
 246    variable that gets the buffer values (beginning with the base
 247    buffer, then the children), and MPS_BUFCONS should be a temporary
 248    Lisp_Object variable.  */
 249 #define MAP_INDIRECT_BUFFERS(mps_buf, mps_bufvar, mps_bufcons)                  \
 250 for (mps_bufcons = Qunbound,                                                    \
 251      mps_bufvar = BUFFER_BASE_BUFFER (mps_buf);                                 \
 252      UNBOUNDP (mps_bufcons) ?                                                   \
 253         (mps_bufcons = mps_bufvar->indirect_children,                           \
 254         1)                                                                      \
 255        : (!NILP (mps_bufcons)                                                   \
 256           && (mps_bufvar = XBUFFER (XCAR (mps_bufcons)), 1)                     \
 257           && (mps_bufcons = XCDR (mps_bufcons), 1));                            \
 258      )
 259
 260 \f
 261
 262 /************************************************************************/
 263 /*                                                                      */
 264 /*                 working with raw internal-format data                */
 265 /*                                                                      */
 266 /************************************************************************/
 267
 268 /* NOTE: In all the following macros, we follow these rules concerning
 269    multiple evaluation of the arguments:
 270
 271    1) Anything that's an lvalue can be evaluated more than once.
 272    2) Anything that's a Lisp Object can be evaluated more than once.
 273       This should probably be changed, but this follows the way
 274       that all the macros in lisp.h do things.
 275    3) 'struct buffer *' arguments can be evaluated more than once.
 276    4) Nothing else can be evaluated more than once.  Use inline
 277       functions, if necessary, to prevent multiple evaluation.
 278    5) An exception to (4) is that there are some macros below that
 279       may evaluate their arguments more than once.  They are all
 280       denoted with the word "unsafe" in their name and are generally
 281       meant to be called only by other macros that have already
 282       stored the calling values in temporary variables.
 283
 284
 285    Use the following functions/macros on contiguous strings of data.
 286    If the text you're operating on is known to come from a buffer, use
 287    the buffer-level functions below -- they know about the gap and may
 288    be more efficient.
 289
 290
 291   (A) For working with charptr's (pointers to internally-formatted text):
 292   -----------------------------------------------------------------------
 293
 294    VALID_CHARPTR_P (ptr):
 295         Given a charptr, does it point to the beginning of a character?
 296
 297    ASSERT_VALID_CHARPTR (ptr):
 298         If error-checking is enabled, assert that the given charptr
 299         points to the beginning of a character.  Otherwise, do nothing.
 300
 301    INC_CHARPTR (ptr):
 302         Given a charptr (assumed to point at the beginning of a character),
 303         modify that pointer so it points to the beginning of the next
 304         character.
 305
 306    DEC_CHARPTR (ptr):
 307         Given a charptr (assumed to point at the beginning of a
 308         character or at the very end of the text), modify that pointer
 309         so it points to the beginning of the previous character.
 310
 311    VALIDATE_CHARPTR_BACKWARD (ptr):
 312         Make sure that PTR is pointing to the beginning of a character.
 313         If not, back up until this is the case.   Note that there are not
 314         too many places where it is legitimate to do this sort of thing.
 315         It's an error if you're passed an "invalid" char * pointer.
 316         NOTE: PTR *must* be pointing to a valid part of the string (i.e.
 317         not the very end, unless the string is zero-terminated or
 318         something) in order for this function to not cause crashes.
 319
 320    VALIDATE_CHARPTR_FORWARD (ptr):
 321         Make sure that PTR is pointing to the beginning of a character.
 322         If not, move forward until this is the case.  Note that there
 323         are not too many places where it is legitimate to do this sort
 324         of thing.  It's an error if you're passed an "invalid" char *
 325         pointer.
 326
 327
 328    (B) For working with the length (in bytes and characters) of a
 329        section of internally-formatted text:
 330    --------------------------------------------------------------
 331
 332    bytecount_to_charcount (ptr, nbi):
 333         Given a pointer to a text string and a length in bytes,
 334         return the equivalent length in characters.
 335
 336    charcount_to_bytecount (ptr, nch):
 337         Given a pointer to a text string and a length in characters,
 338         return the equivalent length in bytes.
 339
 340    charptr_n_addr (ptr, n):
 341         Return a pointer to the beginning of the character offset N
 342         (in characters) from PTR.
 343
 344
 345    (C) For retrieving or changing the character pointed to by a charptr:
 346    ---------------------------------------------------------------------
 347
 348    charptr_emchar (ptr):
 349         Retrieve the character pointed to by PTR as an Emchar.
 350
 351    charptr_emchar_n (ptr, n):
 352         Retrieve the character at offset N (in characters) from PTR,
 353         as an Emchar.
 354
 355    set_charptr_emchar (ptr, ch):
 356         Store the character CH (an Emchar) as internally-formatted
 357         text starting at PTR.  Return the number of bytes stored.
 358
 359    charptr_copy_char (ptr, ptr2):
 360         Retrieve the character pointed to by PTR and store it as
 361         internally-formatted text in PTR2.
 362
 363
 364    (D) For working with Emchars:
 365    -----------------------------
 366
 367    [Note that there are other functions/macros for working with Emchars
 368     in mule-charset.h, for retrieving the charset of an Emchar
 369     and such.  These are only valid when MULE is defined.]
 370
 371    valid_char_p (ch):
 372         Return whether the given Emchar is valid.
 373
 374    CHARP (ch):
 375         Return whether the given Lisp_Object is a character.
 376
 377    CHECK_CHAR_COERCE_INT (ch):
 378         Signal an error if CH is not a valid character or integer Lisp_Object.
 379         If CH is an integer Lisp_Object, convert it to a character Lisp_Object,
 380         but merely by repackaging, without performing tests for char validity.
 381
 382    MAX_EMCHAR_LEN:
 383         Maximum number of buffer bytes per Emacs character.
 384
 385 */
 386
 387
 388 /* ---------------------------------------------------------------------- */
 389 /* (A) For working with charptr's (pointers to internally-formatted text) */
 390 /* ---------------------------------------------------------------------- */
 391
 392 #ifdef MULE
 393 # define VALID_CHARPTR_P(ptr) BUFBYTE_FIRST_BYTE_P (* (unsigned char *) ptr)
 394 #else
 395 # define VALID_CHARPTR_P(ptr) 1
 396 #endif
 397
 398 #ifdef ERROR_CHECK_BUFPOS
 399 # define ASSERT_VALID_CHARPTR(ptr) assert (VALID_CHARPTR_P (ptr))
 400 #else
 401 # define ASSERT_VALID_CHARPTR(ptr)
 402 #endif
 403
 404 /* Note that INC_CHARPTR() and DEC_CHARPTR() have to be written in
 405    completely separate ways.  INC_CHARPTR() cannot use the DEC_CHARPTR()
 406    trick of looking for a valid first byte because it might run off
 407    the end of the string.  DEC_CHARPTR() can't use the INC_CHARPTR()
 408    method because it doesn't have easy access to the first byte of
 409    the character it's moving over. */
 410
 411 #define REAL_INC_CHARPTR(ptr) \
 412   ((void) ((ptr) += REP_BYTES_BY_FIRST_BYTE (* (unsigned char *) (ptr))))
 413
 414 #define REAL_INC_CHARBYTIND(ptr, pos) \
 415   (pos += REP_BYTES_BY_FIRST_BYTE (* (unsigned char *) (ptr)))
 416
 417 #define REAL_DEC_CHARPTR(ptr) do {      \
 418   (ptr)--;                              \
 419 } while (!VALID_CHARPTR_P (ptr))
 420
 421 #ifdef ERROR_CHECK_BUFPOS
 422 #define INC_CHARPTR(ptr) do {           \
 423   ASSERT_VALID_CHARPTR (ptr);           \
 424   REAL_INC_CHARPTR (ptr);               \
 425 } while (0)
 426
 427 #define INC_CHARBYTIND(ptr, pos) do {           \
 428   ASSERT_VALID_CHARPTR (ptr);                   \
 429   REAL_INC_CHARBYTIND (ptr, pos);               \
 430 } while (0)
 431
 432 #define DEC_CHARPTR(ptr) do {                   \
 433   const Bufbyte *dc_ptr1 = (ptr);               \
 434   const Bufbyte *dc_ptr2 = dc_ptr1;             \
 435   REAL_DEC_CHARPTR (dc_ptr2);                   \
 436   assert (dc_ptr1 - dc_ptr2 ==                  \
 437           REP_BYTES_BY_FIRST_BYTE (*dc_ptr2));  \
 438   (ptr) = (Bufbyte *) dc_ptr2;                  \
 439 } while (0)
 440
 441 #else /* ! ERROR_CHECK_BUFPOS */
 442 #define INC_CHARBYTIND(ptr, pos) REAL_INC_CHARBYTIND (ptr, pos)
 443 #define INC_CHARPTR(ptr) REAL_INC_CHARPTR (ptr)
 444 #define DEC_CHARPTR(ptr) REAL_DEC_CHARPTR (ptr)
 445 #endif /* ! ERROR_CHECK_BUFPOS */
 446
 447 #ifdef MULE
 448
 449 #define VALIDATE_CHARPTR_BACKWARD(ptr) do {     \
 450   while (!VALID_CHARPTR_P (ptr)) ptr--;         \
 451 } while (0)
 452
 453 /* This needs to be trickier to avoid the possibility of running off
 454    the end of the string. */
 455
 456 #define VALIDATE_CHARPTR_FORWARD(ptr) do {      \
 457   Bufbyte *vcf_ptr = (ptr);                     \
 458   VALIDATE_CHARPTR_BACKWARD (vcf_ptr);          \
 459   if (vcf_ptr != (ptr))                         \
 460     {                                           \
 461       (ptr) = vcf_ptr;                          \
 462       INC_CHARPTR (ptr);                        \
 463     }                                           \
 464 } while (0)
 465
 466 #else /* not MULE */
 467 #define VALIDATE_CHARPTR_BACKWARD(ptr)
 468 #define VALIDATE_CHARPTR_FORWARD(ptr)
 469 #endif /* not MULE */
 470
 471 /* -------------------------------------------------------------- */
 472 /* (B) For working with the length (in bytes and characters) of a */
 473 /*     section of internally-formatted text                       */
 474 /* -------------------------------------------------------------- */
 475
 476 INLINE_HEADER const Bufbyte *
 477 charptr_n_addr (const Bufbyte *ptr, Charcount offset);
 478 INLINE_HEADER const Bufbyte *
 479 charptr_n_addr (const Bufbyte *ptr, Charcount offset)
 480 {
 481   return ptr + charcount_to_bytecount (ptr, offset);
 482 }
 483
 484 /* -------------------------------------------------------------------- */
 485 /* (C) For retrieving or changing the character pointed to by a charptr */
 486 /* -------------------------------------------------------------------- */
 487
 488 #define simple_charptr_emchar(ptr)              ((Emchar) (ptr)[0])
 489 #define simple_set_charptr_emchar(ptr, x)       ((ptr)[0] = (Bufbyte) (x), 1)
 490 #define simple_charptr_copy_char(ptr, ptr2)     ((ptr2)[0] = *(ptr), 1)
 491
 492 #ifdef MULE
 493
 494 Emchar non_ascii_charptr_emchar (const Bufbyte *ptr);
 495 Bytecount non_ascii_set_charptr_emchar (Bufbyte *ptr, Emchar c);
 496 Bytecount non_ascii_charptr_copy_char (const Bufbyte *src, Bufbyte *dst);
 497
 498 INLINE_HEADER Emchar charptr_emchar (const Bufbyte *ptr);
 499 INLINE_HEADER Emchar
 500 charptr_emchar (const Bufbyte *ptr)
 501 {
 502   return BYTE_ASCII_P (*ptr) ?
 503     simple_charptr_emchar (ptr) :
 504     non_ascii_charptr_emchar (ptr);
 505 }
 506
 507 INLINE_HEADER Bytecount set_charptr_emchar (Bufbyte *ptr, Emchar x);
 508 INLINE_HEADER Bytecount
 509 set_charptr_emchar (Bufbyte *ptr, Emchar x)
 510 {
 511   return !CHAR_MULTIBYTE_P (x) ?
 512     simple_set_charptr_emchar (ptr, x) :
 513     non_ascii_set_charptr_emchar (ptr, x);
 514 }
 515
 516 /* Copy the character pointed to by SRC into DST.
 517    Return the number of bytes copied.  */
 518 INLINE_HEADER Bytecount
 519 charptr_copy_char (const Bufbyte *src, Bufbyte *dst);
 520 INLINE_HEADER Bytecount
 521 charptr_copy_char (const Bufbyte *src, Bufbyte *dst)
 522 {
 523   return BYTE_ASCII_P (*src) ?
 524     simple_charptr_copy_char (src, dst) :
 525     non_ascii_charptr_copy_char (src, dst);
 526 }
 527
 528 #else /* not MULE */
 529
 530 # define charptr_emchar(ptr)            simple_charptr_emchar (ptr)
 531 # define set_charptr_emchar(ptr, x)     simple_set_charptr_emchar (ptr, x)
 532 # define charptr_copy_char(ptr, ptr2)   simple_charptr_copy_char (ptr, ptr2)
 533
 534 #endif /* not MULE */
 535
 536 #define charptr_emchar_n(ptr, offset) \
 537   charptr_emchar (charptr_n_addr (ptr, offset))
 538
 539
 540 /* ---------------------------- */
 541 /* (D) For working with Emchars */
 542 /* ---------------------------- */
 543
 544 #ifdef MULE
 545
 546 int non_ascii_valid_char_p (Emchar ch);
 547
 548 INLINE_HEADER int valid_char_p (Emchar ch);
 549 INLINE_HEADER int
 550 valid_char_p (Emchar ch)
 551 {
 552   return ((unsigned int) (ch) <= 0xff) || non_ascii_valid_char_p (ch);
 553 }
 554
 555 #else /* not MULE */
 556
 557 #define valid_char_p(ch) ((unsigned int) (ch) <= 0xff)
 558
 559 #endif /* not MULE */
 560
 561 #define CHAR_INTP(x) (INTP (x) && valid_char_p (XINT (x)))
 562
 563 #define CHAR_OR_CHAR_INTP(x) (CHARP (x) || CHAR_INTP (x))
 564
 565 INLINE_HEADER Emchar XCHAR_OR_CHAR_INT (Lisp_Object obj);
 566 INLINE_HEADER Emchar
 567 XCHAR_OR_CHAR_INT (Lisp_Object obj)
 568 {
 569   return CHARP (obj) ? XCHAR (obj) : XINT (obj);
 570 }
 571
 572 #define CHECK_CHAR_COERCE_INT(x) do {           \
 573   if (CHARP (x))                                \
 574      ;                                          \
 575   else if (CHAR_INTP (x))                       \
 576     x = make_char (XINT (x));                   \
 577   else                                          \
 578     x = wrong_type_argument (Qcharacterp, x);   \
 579 } while (0)
 580
 581 #ifdef MULE
 582 # define MAX_EMCHAR_LEN 4
 583 #else
 584 # define MAX_EMCHAR_LEN 1
 585 #endif
 586
 587 \f
 588 /*----------------------------------------------------------------------*/
 589 /*          Accessor macros for important positions in a buffer         */
 590 /*----------------------------------------------------------------------*/
 591
 592 /* We put them here because some stuff below wants them before the
 593    place where we would normally put them. */
 594
 595 /* None of these are lvalues.  Use the settor macros below to change
 596    the positions. */
 597
 598 /* Beginning of buffer.  */
 599 #define BI_BUF_BEG(buf) ((Bytind) 1)
 600 #define BUF_BEG(buf) ((Bufpos) 1)
 601
 602 /* Beginning of accessible range of buffer.  */
 603 #define BI_BUF_BEGV(buf) ((buf)->begv + 0)
 604 #define BUF_BEGV(buf) ((buf)->bufbegv + 0)
 605
 606 /* End of accessible range of buffer.  */
 607 #define BI_BUF_ZV(buf) ((buf)->zv + 0)
 608 #define BUF_ZV(buf) ((buf)->bufzv + 0)
 609
 610 /* End of buffer.  */
 611 #define BI_BUF_Z(buf) ((buf)->text->z + 0)
 612 #define BUF_Z(buf) ((buf)->text->bufz + 0)
 613
 614 /* Point. */
 615 #define BI_BUF_PT(buf) ((buf)->pt + 0)
 616 #define BUF_PT(buf) ((buf)->bufpt + 0)
 617
 618 /*----------------------------------------------------------------------*/
 619 /*              Converting between positions and addresses              */
 620 /*----------------------------------------------------------------------*/
 621
 622 /* Convert the address of a byte in the buffer into a position.  */
 623 INLINE_HEADER Bytind BI_BUF_PTR_BYTE_POS (struct buffer *buf, Bufbyte *ptr);
 624 INLINE_HEADER Bytind
 625 BI_BUF_PTR_BYTE_POS (struct buffer *buf, Bufbyte *ptr)
 626 {
 627   return (ptr - buf->text->beg + 1
 628           - ((ptr - buf->text->beg + 1) > buf->text->gpt
 629              ? buf->text->gap_size : 0));
 630 }
 631
 632 #define BUF_PTR_BYTE_POS(buf, ptr) \
 633   bytind_to_bufpos (buf, BI_BUF_PTR_BYTE_POS (buf, ptr))
 634
 635 /* Address of byte at position POS in buffer. */
 636 INLINE_HEADER Bufbyte * BI_BUF_BYTE_ADDRESS (struct buffer *buf, Bytind pos);
 637 INLINE_HEADER Bufbyte *
 638 BI_BUF_BYTE_ADDRESS (struct buffer *buf, Bytind pos)
 639 {
 640   return (buf->text->beg +
 641           ((pos >= buf->text->gpt ? (pos + buf->text->gap_size) : pos)
 642            - 1));
 643 }
 644
 645 #define BUF_BYTE_ADDRESS(buf, pos) \
 646   BI_BUF_BYTE_ADDRESS (buf, bufpos_to_bytind (buf, pos))
 647
 648 /* Address of byte before position POS in buffer. */
 649 INLINE_HEADER Bufbyte * BI_BUF_BYTE_ADDRESS_BEFORE (struct buffer *buf, Bytind pos);
 650 INLINE_HEADER Bufbyte *
 651 BI_BUF_BYTE_ADDRESS_BEFORE (struct buffer *buf, Bytind pos)
 652 {
 653   return (buf->text->beg +
 654           ((pos > buf->text->gpt ? (pos + buf->text->gap_size) : pos)
 655            - 2));
 656 }
 657
 658 #define BUF_BYTE_ADDRESS_BEFORE(buf, pos) \
 659   BI_BUF_BYTE_ADDRESS_BEFORE (buf, bufpos_to_bytind (buf, pos))
 660
 661 /*----------------------------------------------------------------------*/
 662 /*          Converting between byte indices and memory indices          */
 663 /*----------------------------------------------------------------------*/
 664
 665 INLINE_HEADER int valid_memind_p (struct buffer *buf, Memind x);
 666 INLINE_HEADER int
 667 valid_memind_p (struct buffer *buf, Memind x)
 668 {
 669   return ((x >= 1 && x <= (Memind) buf->text->gpt) ||
 670           (x  > (Memind) (buf->text->gpt + buf->text->gap_size) &&
 671            x <= (Memind) (buf->text->z   + buf->text->gap_size)));
 672 }
 673
 674 INLINE_HEADER Memind bytind_to_memind (struct buffer *buf, Bytind x);
 675 INLINE_HEADER Memind
 676 bytind_to_memind (struct buffer *buf, Bytind x)
 677 {
 678   return (Memind) ((x > buf->text->gpt) ? (x + buf->text->gap_size) : x);
 679 }
 680
 681
 682 INLINE_HEADER Bytind memind_to_bytind (struct buffer *buf, Memind x);
 683 INLINE_HEADER Bytind
 684 memind_to_bytind (struct buffer *buf, Memind x)
 685 {
 686 #ifdef ERROR_CHECK_BUFPOS
 687   assert (valid_memind_p (buf, x));
 688 #endif
 689   return (Bytind) ((x > (Memind) buf->text->gpt) ?
 690                    x - buf->text->gap_size :
 691                    x);
 692 }
 693
 694 #define memind_to_bufpos(buf, x) \
 695   bytind_to_bufpos (buf, memind_to_bytind (buf, x))
 696 #define bufpos_to_memind(buf, x) \
 697   bytind_to_memind (buf, bufpos_to_bytind (buf, x))
 698
 699 /* These macros generalize many standard buffer-position functions to
 700    either a buffer or a string. */
 701
 702 /* Converting between Meminds and Bytinds, for a buffer-or-string.
 703    For strings, this is a no-op.  For buffers, this resolves
 704    to the standard memind<->bytind converters. */
 705
 706 #define buffer_or_string_bytind_to_memind(obj, ind) \
 707   (BUFFERP (obj) ? bytind_to_memind (XBUFFER (obj), ind) : (Memind) ind)
 708
 709 #define buffer_or_string_memind_to_bytind(obj, ind) \
 710   (BUFFERP (obj) ? memind_to_bytind (XBUFFER (obj), ind) : (Bytind) ind)
 711
 712 /* Converting between Bufpos's and Bytinds, for a buffer-or-string.
 713    For strings, this maps to the bytecount<->charcount converters. */
 714
 715 #define buffer_or_string_bufpos_to_bytind(obj, pos)             \
 716   (BUFFERP (obj) ? bufpos_to_bytind (XBUFFER (obj), pos) :      \
 717    (Bytind) charcount_to_bytecount (XSTRING_DATA (obj), pos))
 718
 719 #define buffer_or_string_bytind_to_bufpos(obj, ind)             \
 720   (BUFFERP (obj) ? bytind_to_bufpos (XBUFFER (obj), ind) :      \
 721    (Bufpos) bytecount_to_charcount (XSTRING_DATA (obj), ind))
 722
 723 /* Similar for Bufpos's and Meminds. */
 724
 725 #define buffer_or_string_bufpos_to_memind(obj, pos)             \
 726   (BUFFERP (obj) ? bufpos_to_memind (XBUFFER (obj), pos) :      \
 727    (Memind) charcount_to_bytecount (XSTRING_DATA (obj), pos))
 728
 729 #define buffer_or_string_memind_to_bufpos(obj, ind)             \
 730   (BUFFERP (obj) ? memind_to_bufpos (XBUFFER (obj), ind) :      \
 731    (Bufpos) bytecount_to_charcount (XSTRING_DATA (obj), ind))
 732
 733 /************************************************************************/
 734 /*                                                                      */
 735 /*                    working with buffer-level data                    */
 736 /*                                                                      */
 737 /************************************************************************/
 738
 739 /*
 740
 741    (A) Working with byte indices:
 742    ------------------------------
 743
 744    VALID_BYTIND_P(buf, bi):
 745         Given a byte index, does it point to the beginning of a character?
 746
 747    ASSERT_VALID_BYTIND_UNSAFE(buf, bi):
 748         If error-checking is enabled, assert that the given byte index
 749         is within range and points to the beginning of a character
 750         or to the end of the buffer.  Otherwise, do nothing.
 751
 752    ASSERT_VALID_BYTIND_BACKWARD_UNSAFE(buf, bi):
 753         If error-checking is enabled, assert that the given byte index
 754         is within range and satisfies ASSERT_VALID_BYTIND() and also
 755         does not refer to the beginning of the buffer. (i.e. movement
 756         backwards is OK.) Otherwise, do nothing.
 757
 758    ASSERT_VALID_BYTIND_FORWARD_UNSAFE(buf, bi):
 759         If error-checking is enabled, assert that the given byte index
 760         is within range and satisfies ASSERT_VALID_BYTIND() and also
 761         does not refer to the end of the buffer. (i.e. movement
 762         forwards is OK.) Otherwise, do nothing.
 763
 764    VALIDATE_BYTIND_BACKWARD(buf, bi):
 765         Make sure that the given byte index is pointing to the beginning
 766         of a character.  If not, back up until this is the case.  Note
 767         that there are not too many places where it is legitimate to do
 768         this sort of thing.  It's an error if you're passed an "invalid"
 769         byte index.
 770
 771    VALIDATE_BYTIND_FORWARD(buf, bi):
 772         Make sure that the given byte index is pointing to the beginning
 773         of a character.  If not, move forward until this is the case.
 774         Note that there are not too many places where it is legitimate
 775         to do this sort of thing.  It's an error if you're passed an
 776         "invalid" byte index.
 777
 778    INC_BYTIND(buf, bi):
 779         Given a byte index (assumed to point at the beginning of a
 780         character), modify that value so it points to the beginning
 781         of the next character.
 782
 783    DEC_BYTIND(buf, bi):
 784         Given a byte index (assumed to point at the beginning of a
 785         character), modify that value so it points to the beginning
 786         of the previous character.  Unlike for DEC_CHARPTR(), we can
 787         do all the assert()s because there are sentinels at the
 788         beginning of the gap and the end of the buffer.
 789
 790    BYTIND_INVALID:
 791         A constant representing an invalid Bytind.  Valid Bytinds
 792         can never have this value.
 793
 794
 795    (B) Converting between Bufpos's and Bytinds:
 796    --------------------------------------------
 797
 798     bufpos_to_bytind(buf, bu):
 799         Given a Bufpos, return the equivalent Bytind.
 800
 801     bytind_to_bufpos(buf, bi):
 802         Given a Bytind, return the equivalent Bufpos.
 803
 804     make_bufpos(buf, bi):
 805         Given a Bytind, return the equivalent Bufpos as a Lisp Object.
 806  */
 807
 808
 809 /*----------------------------------------------------------------------*/
 810 /*                       working with byte indices                      */
 811 /*----------------------------------------------------------------------*/
 812
 813 #ifdef MULE
 814 # define VALID_BYTIND_P(buf, x) \
 815   BUFBYTE_FIRST_BYTE_P (*BI_BUF_BYTE_ADDRESS (buf, x))
 816 #else
 817 # define VALID_BYTIND_P(buf, x) 1
 818 #endif
 819
 820 #ifdef ERROR_CHECK_BUFPOS
 821
 822 # define ASSERT_VALID_BYTIND_UNSAFE(buf, x) do {                \
 823   assert (BUFFER_LIVE_P (buf));                                 \
 824   assert ((x) >= BI_BUF_BEG (buf) && x <= BI_BUF_Z (buf));      \
 825   assert (VALID_BYTIND_P (buf, x));                             \
 826 } while (0)
 827 # define ASSERT_VALID_BYTIND_BACKWARD_UNSAFE(buf, x) do {       \
 828   assert (BUFFER_LIVE_P (buf));                                 \
 829   assert ((x) > BI_BUF_BEG (buf) && x <= BI_BUF_Z (buf));       \
 830   assert (VALID_BYTIND_P (buf, x));                             \
 831 } while (0)
 832 # define ASSERT_VALID_BYTIND_FORWARD_UNSAFE(buf, x) do {        \
 833   assert (BUFFER_LIVE_P (buf));                                 \
 834   assert ((x) >= BI_BUF_BEG (buf) && x < BI_BUF_Z (buf));       \
 835   assert (VALID_BYTIND_P (buf, x));                             \
 836 } while (0)
 837
 838 #else /* not ERROR_CHECK_BUFPOS */
 839 # define ASSERT_VALID_BYTIND_UNSAFE(buf, x)
 840 # define ASSERT_VALID_BYTIND_BACKWARD_UNSAFE(buf, x)
 841 # define ASSERT_VALID_BYTIND_FORWARD_UNSAFE(buf, x)
 842
 843 #endif /* not ERROR_CHECK_BUFPOS */
 844
 845 /* Note that, although the Mule version will work fine for non-Mule
 846    as well (it should reduce down to nothing), we provide a separate
 847    version to avoid compilation warnings and possible non-optimal
 848    results with stupid compilers. */
 849
 850 #ifdef MULE
 851 # define VALIDATE_BYTIND_BACKWARD(buf, x) do {          \
 852   Bufbyte *VBB_ptr = BI_BUF_BYTE_ADDRESS (buf, x);      \
 853   while (!BUFBYTE_FIRST_BYTE_P (*VBB_ptr))              \
 854     VBB_ptr--, (x)--;                                   \
 855 } while (0)
 856 #else
 857 # define VALIDATE_BYTIND_BACKWARD(buf, x)
 858 #endif
 859
 860 /* Note that, although the Mule version will work fine for non-Mule
 861    as well (it should reduce down to nothing), we provide a separate
 862    version to avoid compilation warnings and possible non-optimal
 863    results with stupid compilers. */
 864
 865 #ifdef MULE
 866 # define VALIDATE_BYTIND_FORWARD(buf, x) do {           \
 867   Bufbyte *VBF_ptr = BI_BUF_BYTE_ADDRESS (buf, x);      \
 868   while (!BUFBYTE_FIRST_BYTE_P (*VBF_ptr))              \
 869     VBF_ptr++, (x)++;                                   \
 870 } while (0)
 871 #else
 872 # define VALIDATE_BYTIND_FORWARD(buf, x)
 873 #endif
 874
 875 /* Note that in the simplest case (no MULE, no ERROR_CHECK_BUFPOS),
 876    this crap reduces down to simply (x)++. */
 877
 878 #define INC_BYTIND(buf, x) do                           \
 879 {                                                       \
 880   ASSERT_VALID_BYTIND_FORWARD_UNSAFE (buf, x);          \
 881   /* Note that we do the increment first to             \
 882      make sure that the pointer in                      \
 883      VALIDATE_BYTIND_FORWARD() ends up on               \
 884      the correct side of the gap */                     \
 885   (x)++;                                                \
 886   VALIDATE_BYTIND_FORWARD (buf, x);                     \
 887 } while (0)
 888
 889 /* Note that in the simplest case (no MULE, no ERROR_CHECK_BUFPOS),
 890    this crap reduces down to simply (x)--. */
 891
 892 #define DEC_BYTIND(buf, x) do                           \
 893 {                                                       \
 894   ASSERT_VALID_BYTIND_BACKWARD_UNSAFE (buf, x);         \
 895   /* Note that we do the decrement first to             \
 896      make sure that the pointer in                      \
 897      VALIDATE_BYTIND_BACKWARD() ends up on              \
 898      the correct side of the gap */                     \
 899   (x)--;                                                \
 900   VALIDATE_BYTIND_BACKWARD (buf, x);                    \
 901 } while (0)
 902
 903 INLINE_HEADER Bytind prev_bytind (struct buffer *buf, Bytind x);
 904 INLINE_HEADER Bytind
 905 prev_bytind (struct buffer *buf, Bytind x)
 906 {
 907   DEC_BYTIND (buf, x);
 908   return x;
 909 }
 910
 911 INLINE_HEADER Bytind next_bytind (struct buffer *buf, Bytind x);
 912 INLINE_HEADER Bytind
 913 next_bytind (struct buffer *buf, Bytind x)
 914 {
 915   INC_BYTIND (buf, x);
 916   return x;
 917 }
 918
 919 #define BYTIND_INVALID ((Bytind) -1)
 920
 921 /*----------------------------------------------------------------------*/
 922 /*         Converting between buffer positions and byte indices         */
 923 /*----------------------------------------------------------------------*/
 924
 925 #ifdef MULE
 926
 927 Bytind bufpos_to_bytind_func (struct buffer *buf, Bufpos x);
 928 Bufpos bytind_to_bufpos_func (struct buffer *buf, Bytind x);
 929
 930 /* The basic algorithm we use is to keep track of a known region of
 931    characters in each buffer, all of which are of the same width.  We
 932    keep track of the boundaries of the region in both Bufpos and
 933    Bytind coordinates and also keep track of the char width, which
 934    is 1 - 4 bytes.  If the position we're translating is not in
 935    the known region, then we invoke a function to update the known
 936    region to surround the position in question.  This assumes
 937    locality of reference, which is usually the case.
 938
 939    Note that the function to update the known region can be simple
 940    or complicated depending on how much information we cache.
 941    For the moment, we don't cache any information, and just move
 942    linearly forward or back from the known region, with a few
 943    shortcuts to catch all-ASCII buffers. (Note that this will
 944    thrash with bad locality of reference.) A smarter method would
 945    be to keep some sort of pseudo-extent layer over the buffer;
 946    maybe keep track of the bufpos/bytind correspondence at the
 947    beginning of each line, which would allow us to do a binary
 948    search over the pseudo-extents to narrow things down to the
 949    correct line, at which point you could use a linear movement
 950    method.  This would also mesh well with efficiently
 951    implementing a line-numbering scheme.
 952
 953    Note also that we have to multiply or divide by the char width
 954    in order to convert the positions.  We do some tricks to avoid
 955    ever actually having to do a multiply or divide, because that
 956    is typically an expensive operation (esp. divide).  Multiplying
 957    or dividing by 1, 2, or 4 can be implemented simply as a
 958    shift left or shift right, and we keep track of a shifter value
 959    (0, 1, or 2) indicating how much to shift.  Multiplying by 3
 960    can be implemented by doubling and then adding the original
 961    value.  Dividing by 3, alas, cannot be implemented in any
 962    simple shift/subtract method, as far as I know; so we just
 963    do a table lookup.  For simplicity, we use a table of size
 964    128K, which indexes the "divide-by-3" values for the first
 965    64K non-negative numbers. (Note that we can increase the
 966    size up to 384K, i.e. indexing the first 192K non-negative
 967    numbers, while still using shorts in the array.) This also
 968    means that the size of the known region can be at most
 969    64K for width-three characters.
 970    */
 971
 972 extern short three_to_one_table[];
 973
 974 INLINE_HEADER int real_bufpos_to_bytind (struct buffer *buf, Bufpos x);
 975 INLINE_HEADER int
 976 real_bufpos_to_bytind (struct buffer *buf, Bufpos x)
 977 {
 978   if (x >= buf->text->mule_bufmin && x <= buf->text->mule_bufmax)
 979     return (buf->text->mule_bytmin +
 980             ((x - buf->text->mule_bufmin) << buf->text->mule_shifter) +
 981             (buf->text->mule_three_p ? (x - buf->text->mule_bufmin) : 0));
 982   else
 983     return bufpos_to_bytind_func (buf, x);
 984 }
 985
 986 INLINE_HEADER int real_bytind_to_bufpos (struct buffer *buf, Bytind x);
 987 INLINE_HEADER int
 988 real_bytind_to_bufpos (struct buffer *buf, Bytind x)
 989 {
 990   if (x >= buf->text->mule_bytmin && x <= buf->text->mule_bytmax)
 991     return (buf->text->mule_bufmin +
 992             ((buf->text->mule_three_p
 993               ? three_to_one_table[x - buf->text->mule_bytmin]
 994               : (x - buf->text->mule_bytmin) >> buf->text->mule_shifter)));
 995   else
 996     return bytind_to_bufpos_func (buf, x);
 997 }
 998
 999 #else /* not MULE */
1000
1001 # define real_bufpos_to_bytind(buf, x)  ((Bytind) x)
1002 # define real_bytind_to_bufpos(buf, x)  ((Bufpos) x)
1003
1004 #endif /* not MULE */
1005
1006 #ifdef ERROR_CHECK_BUFPOS
1007
1008 Bytind bufpos_to_bytind (struct buffer *buf, Bufpos x);
1009 Bufpos bytind_to_bufpos (struct buffer *buf, Bytind x);
1010
1011 #else /* not ERROR_CHECK_BUFPOS */
1012
1013 #define bufpos_to_bytind real_bufpos_to_bytind
1014 #define bytind_to_bufpos real_bytind_to_bufpos
1015
1016 #endif /* not ERROR_CHECK_BUFPOS */
1017
1018 #define make_bufpos(buf, ind) make_int (bytind_to_bufpos (buf, ind))
1019
1020 /*----------------------------------------------------------------------*/
1021 /*         Converting between buffer bytes and Emacs characters         */
1022 /*----------------------------------------------------------------------*/
1023
1024 /* The character at position POS in buffer. */
1025 #define BI_BUF_FETCH_CHAR(buf, pos) \
1026   charptr_emchar (BI_BUF_BYTE_ADDRESS (buf, pos))
1027 #define BUF_FETCH_CHAR(buf, pos) \
1028   BI_BUF_FETCH_CHAR (buf, bufpos_to_bytind (buf, pos))
1029
1030 /* The character at position POS in buffer, as a string.  This is
1031    equivalent to set_charptr_emchar (str, BUF_FETCH_CHAR (buf, pos))
1032    but is faster for Mule. */
1033
1034 # define BI_BUF_CHARPTR_COPY_CHAR(buf, pos, str) \
1035   charptr_copy_char (BI_BUF_BYTE_ADDRESS (buf, pos), str)
1036 #define BUF_CHARPTR_COPY_CHAR(buf, pos, str) \
1037   BI_BUF_CHARPTR_COPY_CHAR (buf, bufpos_to_bytind (buf, pos), str)
1038
1039 \f
1040 /************************************************************************/
1041 /*                                                                      */
1042 /*         Converting between internal and external format              */
1043 /*                                                                      */
1044 /************************************************************************/
1045 /*
1046   All client code should use only the two macros
1047
1048   TO_EXTERNAL_FORMAT (source_type, source, sink_type, sink, coding_system)
1049   TO_INTERNAL_FORMAT (source_type, source, sink_type, sink, coding_system)
1050
1051   Typical use is
1052
1053   TO_EXTERNAL_FORMAT (DATA, (ptr, len),
1054                       LISP_BUFFER, buffer,
1055                       Qfile_name);
1056
1057   The source or sink can be specified in one of these ways:
1058
1059   DATA,   (ptr, len),    // input data is a fixed buffer of size len
1060   ALLOCA, (ptr, len),    // output data is in a alloca()ed buffer of size len
1061   MALLOC, (ptr, len),    // output data is in a malloc()ed buffer of size len
1062   C_STRING_ALLOCA, ptr,  // equivalent to ALLOCA (ptr, len_ignored) on output
1063   C_STRING_MALLOC, ptr,  // equivalent to MALLOC (ptr, len_ignored) on output
1064   C_STRING,     ptr,     // equivalent to DATA, (ptr, strlen (ptr) + 1) on input
1065   LISP_STRING,  string,  // input or output is a Lisp_Object of type string
1066   LISP_BUFFER,  buffer,  // output is written to (point) in lisp buffer
1067   LISP_LSTREAM, lstream, // input or output is a Lisp_Object of type lstream
1068   LISP_OPAQUE,  object,  // input or output is a Lisp_Object of type opaque
1069
1070   When specifying the sink, use lvalues, since the macro will assign to them,
1071   except when the sink is an lstream or a lisp buffer.
1072
1073   The macros accept the kinds of sources and sinks appropriate for
1074   internal and external data representation.  See the type_checking_assert
1075   macros below for the actual allowed types.
1076
1077   Since some sources and sinks use one argument (a Lisp_Object) to
1078   specify them, while others take a (pointer, length) pair, we use
1079   some C preprocessor trickery to allow pair arguments to be specified
1080   by parenthesizing them, as in the examples above.
1081
1082   Anything prefixed by dfc_ (`data format conversion') is private.
1083   They are only used to implement these macros.
1084
1085   Using C_STRING* is appropriate for using with external APIs that take
1086   null-terminated strings.  For internal data, we should try to be
1087   '\0'-clean - i.e. allow arbitrary data to contain embedded '\0'.
1088
1089   Sometime in the future we might allow output to C_STRING_ALLOCA or
1090   C_STRING_MALLOC _only_ with TO_EXTERNAL_FORMAT(), not
1091   TO_INTERNAL_FORMAT().  */
1092
1093 #define TO_EXTERNAL_FORMAT(source_type, source, sink_type, sink, coding_system) \
1094 do {                                                                            \
1095   dfc_conversion_type dfc_simplified_source_type;                               \
1096   dfc_conversion_type dfc_simplified_sink_type;                                 \
1097   dfc_conversion_data dfc_source;                                               \
1098   dfc_conversion_data dfc_sink;                                                 \
1099                                                                                 \
1100   type_checking_assert                                                          \
1101     ((DFC_TYPE_##source_type == DFC_TYPE_DATA ||                                \
1102       DFC_TYPE_##source_type == DFC_TYPE_C_STRING ||                            \
1103       DFC_TYPE_##source_type == DFC_TYPE_LISP_STRING ||                         \
1104       DFC_TYPE_##source_type == DFC_TYPE_LISP_OPAQUE ||                         \
1105       DFC_TYPE_##source_type == DFC_TYPE_LISP_LSTREAM)                          \
1106     &&                                                                          \
1107      (DFC_TYPE_##sink_type == DFC_TYPE_ALLOCA ||                                \
1108       DFC_TYPE_##sink_type == DFC_TYPE_MALLOC ||                                \
1109       DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_ALLOCA ||                       \
1110       DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_MALLOC ||                       \
1111       DFC_TYPE_##sink_type == DFC_TYPE_LISP_LSTREAM ||                          \
1112       DFC_TYPE_##sink_type == DFC_TYPE_LISP_OPAQUE));                           \
1113                                                                                 \
1114   DFC_SOURCE_##source_type##_TO_ARGS (source);                                  \
1115   DFC_SINK_##sink_type##_TO_ARGS     (sink);                                    \
1116                                                                                 \
1117   DFC_CONVERT_TO_EXTERNAL_FORMAT (dfc_simplified_source_type, &dfc_source,      \
1118                                   coding_system,                                \
1119                                   dfc_simplified_sink_type,   &dfc_sink);       \
1120                                                                                 \
1121   DFC_##sink_type##_USE_CONVERTED_DATA (sink);                                  \
1122 } while (0)
1123
1124 #define TO_INTERNAL_FORMAT(source_type, source, sink_type, sink, coding_system) \
1125 do {                                                                            \
1126   dfc_conversion_type dfc_simplified_source_type;                               \
1127   dfc_conversion_type dfc_simplified_sink_type;                                 \
1128   dfc_conversion_data dfc_source;                                               \
1129   dfc_conversion_data dfc_sink;                                                 \
1130                                                                                 \
1131   type_checking_assert                                                          \
1132     ((DFC_TYPE_##source_type == DFC_TYPE_DATA ||                                \
1133       DFC_TYPE_##source_type == DFC_TYPE_C_STRING ||                            \
1134       DFC_TYPE_##source_type == DFC_TYPE_LISP_OPAQUE ||                         \
1135       DFC_TYPE_##source_type == DFC_TYPE_LISP_LSTREAM)                          \
1136      &&                                                                         \
1137      (DFC_TYPE_##sink_type == DFC_TYPE_ALLOCA ||                                \
1138       DFC_TYPE_##sink_type == DFC_TYPE_MALLOC ||                                \
1139       DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_ALLOCA ||                       \
1140       DFC_TYPE_##sink_type == DFC_TYPE_C_STRING_MALLOC ||                       \
1141       DFC_TYPE_##sink_type == DFC_TYPE_LISP_STRING ||                           \
1142       DFC_TYPE_##sink_type == DFC_TYPE_LISP_LSTREAM ||                          \
1143       DFC_TYPE_##sink_type == DFC_TYPE_LISP_BUFFER));                           \
1144                                                                                 \
1145   DFC_SOURCE_##source_type##_TO_ARGS (source);                                  \
1146   DFC_SINK_##sink_type##_TO_ARGS     (sink);                                    \
1147                                                                                 \
1148   DFC_CONVERT_TO_INTERNAL_FORMAT (dfc_simplified_source_type, &dfc_source,      \
1149                                   coding_system,                                \
1150                                   dfc_simplified_sink_type,   &dfc_sink);       \
1151                                                                                 \
1152   DFC_##sink_type##_USE_CONVERTED_DATA (sink);                                  \
1153 } while (0)
1154
1155 #ifdef FILE_CODING
1156 #define DFC_CONVERT_TO_EXTERNAL_FORMAT dfc_convert_to_external_format
1157 #define DFC_CONVERT_TO_INTERNAL_FORMAT dfc_convert_to_internal_format
1158 #else
1159 /* ignore coding_system argument */
1160 #define DFC_CONVERT_TO_EXTERNAL_FORMAT(a, b, coding_system, c, d) \
1161  dfc_convert_to_external_format (a, b, c, d)
1162 #define DFC_CONVERT_TO_INTERNAL_FORMAT(a, b, coding_system, c, d) \
1163  dfc_convert_to_internal_format (a, b, c, d)
1164 #endif
1165
1166 typedef union
1167 {
1168   struct { const void *ptr; size_t len; } data;
1169   Lisp_Object lisp_object;
1170 } dfc_conversion_data;
1171
1172 enum dfc_conversion_type
1173 {
1174   DFC_TYPE_DATA,
1175   DFC_TYPE_ALLOCA,
1176   DFC_TYPE_MALLOC,
1177   DFC_TYPE_C_STRING,
1178   DFC_TYPE_C_STRING_ALLOCA,
1179   DFC_TYPE_C_STRING_MALLOC,
1180   DFC_TYPE_LISP_STRING,
1181   DFC_TYPE_LISP_LSTREAM,
1182   DFC_TYPE_LISP_OPAQUE,
1183   DFC_TYPE_LISP_BUFFER
1184 };
1185 typedef enum dfc_conversion_type dfc_conversion_type;
1186
1187 /* WARNING: These use a static buffer.  This can lead to disaster if
1188    these functions are not used *very* carefully.  Another reason to only use
1189    TO_EXTERNAL_FORMAT() and TO_INTERNAL_FORMAT(). */
1190 void
1191 dfc_convert_to_external_format (dfc_conversion_type source_type,
1192                                 dfc_conversion_data *source,
1193 #ifdef FILE_CODING
1194                                 Lisp_Object coding_system,
1195 #endif
1196                                 dfc_conversion_type sink_type,
1197                                 dfc_conversion_data *sink);
1198 void
1199 dfc_convert_to_internal_format (dfc_conversion_type source_type,
1200                                 dfc_conversion_data *source,
1201 #ifdef FILE_CODING
1202                                 Lisp_Object coding_system,
1203 #endif
1204                                 dfc_conversion_type sink_type,
1205                                 dfc_conversion_data *sink);
1206 /* CPP Trickery */
1207 #define DFC_CPP_CAR(x,y) (x)
1208 #define DFC_CPP_CDR(x,y) (y)
1209
1210 /* Convert `source' to args for dfc_convert_to_*_format() */
1211 #define DFC_SOURCE_DATA_TO_ARGS(val) do {               \
1212   dfc_source.data.ptr = DFC_CPP_CAR val;                \
1213   dfc_source.data.len = DFC_CPP_CDR val;                \
1214   dfc_simplified_source_type = DFC_TYPE_DATA;           \
1215 } while (0)
1216 #define DFC_SOURCE_C_STRING_TO_ARGS(val) do {           \
1217   dfc_source.data.len =                                 \
1218     strlen ((char *) (dfc_source.data.ptr = (val)));    \
1219   dfc_simplified_source_type = DFC_TYPE_DATA;           \
1220 } while (0)
1221 #define DFC_SOURCE_LISP_STRING_TO_ARGS(val) do {        \
1222   Lisp_Object dfc_slsta = (val);                        \
1223   type_checking_assert (STRINGP (dfc_slsta));           \
1224   dfc_source.lisp_object = dfc_slsta;                   \
1225   dfc_simplified_source_type = DFC_TYPE_LISP_STRING;    \
1226 } while (0)
1227 #define DFC_SOURCE_LISP_LSTREAM_TO_ARGS(val) do {       \
1228   Lisp_Object dfc_sllta = (val);                        \
1229   type_checking_assert (LSTREAMP (dfc_sllta));          \
1230   dfc_source.lisp_object = dfc_sllta;                   \
1231   dfc_simplified_source_type = DFC_TYPE_LISP_LSTREAM;   \
1232 } while (0)
1233 #define DFC_SOURCE_LISP_OPAQUE_TO_ARGS(val) do {        \
1234   Lisp_Opaque *dfc_slota = XOPAQUE (val);               \
1235   dfc_source.data.ptr = OPAQUE_DATA (dfc_slota);        \
1236   dfc_source.data.len = OPAQUE_SIZE (dfc_slota);        \
1237   dfc_simplified_source_type = DFC_TYPE_DATA;           \
1238 } while (0)
1239
1240 /* Convert `sink' to args for dfc_convert_to_*_format() */
1241 #define DFC_SINK_ALLOCA_TO_ARGS(val)            \
1242   dfc_simplified_sink_type = DFC_TYPE_DATA
1243 #define DFC_SINK_C_STRING_ALLOCA_TO_ARGS(val)   \
1244   dfc_simplified_sink_type = DFC_TYPE_DATA
1245 #define DFC_SINK_MALLOC_TO_ARGS(val)            \
1246   dfc_simplified_sink_type = DFC_TYPE_DATA
1247 #define DFC_SINK_C_STRING_MALLOC_TO_ARGS(val)   \
1248   dfc_simplified_sink_type = DFC_TYPE_DATA
1249 #define DFC_SINK_LISP_STRING_TO_ARGS(val)       \
1250   dfc_simplified_sink_type = DFC_TYPE_DATA
1251 #define DFC_SINK_LISP_OPAQUE_TO_ARGS(val)       \
1252   dfc_simplified_sink_type = DFC_TYPE_DATA
1253 #define DFC_SINK_LISP_LSTREAM_TO_ARGS(val) do {         \
1254   Lisp_Object dfc_sllta = (val);                        \
1255   type_checking_assert (LSTREAMP (dfc_sllta));          \
1256   dfc_sink.lisp_object = dfc_sllta;                     \
1257   dfc_simplified_sink_type = DFC_TYPE_LISP_LSTREAM;     \
1258 } while (0)
1259 #define DFC_SINK_LISP_BUFFER_TO_ARGS(val) do {          \
1260   struct buffer *dfc_slbta = XBUFFER (val);             \
1261   dfc_sink.lisp_object =                                \
1262     make_lisp_buffer_output_stream                      \
1263     (dfc_slbta, BUF_PT (dfc_slbta), 0);                 \
1264   dfc_simplified_sink_type = DFC_TYPE_LISP_LSTREAM;     \
1265 } while (0)
1266
1267 /* Assign to the `sink' lvalue(s) using the converted data. */
1268 typedef union { char c; void *p; } *dfc_aliasing_voidpp;
1269 #define DFC_ALLOCA_USE_CONVERTED_DATA(sink) do {                        \
1270   void * dfc_sink_ret = alloca (dfc_sink.data.len + 1);                 \
1271   memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 1);      \
1272   ((dfc_aliasing_voidpp) &(DFC_CPP_CAR sink))->p = dfc_sink_ret;        \
1273   (DFC_CPP_CDR sink) = dfc_sink.data.len;                               \
1274 } while (0)
1275 #define DFC_MALLOC_USE_CONVERTED_DATA(sink) do {                        \
1276   void * dfc_sink_ret = xmalloc (dfc_sink.data.len + 1);                \
1277   memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 1);      \
1278   ((dfc_aliasing_voidpp) &(DFC_CPP_CAR sink))->p = dfc_sink_ret;        \
1279   (DFC_CPP_CDR sink) = dfc_sink.data.len;                               \
1280 } while (0)
1281 #define DFC_C_STRING_ALLOCA_USE_CONVERTED_DATA(sink) do {               \
1282   void * dfc_sink_ret = alloca (dfc_sink.data.len + 1);                 \
1283   memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 1);      \
1284   (sink) = (char *) dfc_sink_ret;                                       \
1285 } while (0)
1286 #define DFC_C_STRING_MALLOC_USE_CONVERTED_DATA(sink) do {               \
1287   void * dfc_sink_ret = xmalloc (dfc_sink.data.len + 1);                \
1288   memcpy (dfc_sink_ret, dfc_sink.data.ptr, dfc_sink.data.len + 1);      \
1289   (sink) = (char *) dfc_sink_ret;                                       \
1290 } while (0)
1291 #define DFC_LISP_STRING_USE_CONVERTED_DATA(sink) \
1292   sink = make_string ((Bufbyte *) dfc_sink.data.ptr, dfc_sink.data.len)
1293 #define DFC_LISP_OPAQUE_USE_CONVERTED_DATA(sink) \
1294   sink = make_opaque (dfc_sink.data.ptr, dfc_sink.data.len)
1295 #define DFC_LISP_LSTREAM_USE_CONVERTED_DATA(sink) /* data already used */
1296 #define DFC_LISP_BUFFER_USE_CONVERTED_DATA(sink) \
1297   Lstream_delete (XLSTREAM (dfc_sink.lisp_object))
1298
1299 /* Someday we might want to distinguish between Qnative and Qfile_name
1300    by using coding-system aliases, but for now it suffices to have
1301    these be identical.  Qnative can be used as the coding_system
1302    argument to TO_EXTERNAL_FORMAT() and TO_INTERNAL_FORMAT(). */
1303 #define Qnative Qfile_name
1304
1305 #if defined (WIN32_NATIVE) || defined (CYGWIN)
1306 /* #### kludge!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1307    Remove this as soon as my Mule code is integrated. */
1308 #define Qmswindows_tstr Qnative
1309 #endif
1310
1311 /* More stand-ins */
1312 #define Qcommand_argument_encoding Qnative
1313 #define Qenvironment_variable_encoding Qnative
1314
1315 /* Convenience macros for extremely common invocations */
1316 #define C_STRING_TO_EXTERNAL(in, out, coding_system) \
1317   TO_EXTERNAL_FORMAT (C_STRING, in, C_STRING_ALLOCA, out, coding_system)
1318 #define C_STRING_TO_EXTERNAL_MALLOC(in, out, coding_system) \
1319   TO_EXTERNAL_FORMAT (C_STRING, in, C_STRING_MALLOC, out, coding_system)
1320 #define EXTERNAL_TO_C_STRING(in, out, coding_system) \
1321   TO_INTERNAL_FORMAT (C_STRING, in, C_STRING_ALLOCA, out, coding_system)
1322 #define EXTERNAL_TO_C_STRING_MALLOC(in, out, coding_system) \
1323   TO_INTERNAL_FORMAT (C_STRING, in, C_STRING_MALLOC, out, coding_system)
1324 #define LISP_STRING_TO_EXTERNAL(in, out, coding_system) \
1325   TO_EXTERNAL_FORMAT (LISP_STRING, in, C_STRING_ALLOCA, out, coding_system)
1326 #define LISP_STRING_TO_EXTERNAL_MALLOC(in, out, coding_system) \
1327   TO_EXTERNAL_FORMAT (LISP_STRING, in, C_STRING_MALLOC, out, coding_system)
1328
1329 \f
1330 /************************************************************************/
1331 /*                                                                      */
1332 /*                          fake charset functions                      */
1333 /*                                                                      */
1334 /************************************************************************/
1335
1336 /* used when MULE is not defined, so that Charset-type stuff can still
1337    be done */
1338
1339 #ifndef MULE
1340
1341 #define Vcharset_ascii Qnil
1342
1343 #define CHAR_CHARSET(ch) Vcharset_ascii
1344 #define CHAR_LEADING_BYTE(ch) LEADING_BYTE_ASCII
1345 #define LEADING_BYTE_ASCII 0x80
1346 #define NUM_LEADING_BYTES 1
1347 #define MIN_LEADING_BYTE 0x80
1348 #define CHARSETP(cs) 1
1349 #define CHARSET_BY_LEADING_BYTE(lb) Vcharset_ascii
1350 #define XCHARSET_LEADING_BYTE(cs) LEADING_BYTE_ASCII
1351 #define XCHARSET_GRAPHIC(cs) -1
1352 #define XCHARSET_COLUMNS(cs) 1
1353 #define XCHARSET_DIMENSION(cs) 1
1354 #define REP_BYTES_BY_FIRST_BYTE(fb) 1
1355 #define BREAKUP_CHAR(ch, charset, byte1, byte2) do {    \
1356   (charset) = Vcharset_ascii;                           \
1357   (byte1) = (ch);                                       \
1358   (byte2) = 0;                                          \
1359 } while (0)
1360 #define BYTE_ASCII_P(byte) 1
1361
1362 #endif /* ! MULE */
1363 \f
1364 /************************************************************************/
1365 /*                                                                      */
1366 /*                  higher-level buffer-position functions              */
1367 /*                                                                      */
1368 /************************************************************************/
1369
1370 /*----------------------------------------------------------------------*/
1371 /*           Settor macros for important positions in a buffer          */
1372 /*----------------------------------------------------------------------*/
1373
1374 /* Set beginning of accessible range of buffer.  */
1375 #define SET_BOTH_BUF_BEGV(buf, val, bival)      \
1376 do                                              \
1377 {                                               \
1378   (buf)->begv = (bival);                        \
1379   (buf)->bufbegv = (val);                       \
1380 } while (0)
1381
1382 /* Set end of accessible range of buffer.  */
1383 #define SET_BOTH_BUF_ZV(buf, val, bival)        \
1384 do                                              \
1385 {                                               \
1386   (buf)->zv = (bival);                          \
1387   (buf)->bufzv = (val);                         \
1388 } while (0)
1389
1390 /* Set point. */
1391 /* Since BEGV and ZV are almost never set, it's reasonable to enforce
1392    the restriction that the Bufpos and Bytind values must both be
1393    specified.  However, point is set in lots and lots of places.  So
1394    we provide the ability to specify both (for efficiency) or just
1395    one. */
1396 #define BOTH_BUF_SET_PT(buf, val, bival) set_buffer_point (buf, val, bival)
1397 #define BI_BUF_SET_PT(buf, bival) \
1398   BOTH_BUF_SET_PT (buf, bytind_to_bufpos (buf, bival), bival)
1399 #define BUF_SET_PT(buf, value) \
1400   BOTH_BUF_SET_PT (buf, value, bufpos_to_bytind (buf, value))
1401
1402
1403 #if 0 /* FSFmacs */
1404 /* These macros exist in FSFmacs because SET_PT() in FSFmacs incorrectly
1405    does too much stuff, such as moving out of invisible extents. */
1406 #define TEMP_SET_PT(position) (temp_set_point ((position), current_buffer))
1407 #define SET_BUF_PT(buf, value) ((buf)->pt = (value))
1408 #endif /* FSFmacs */
1409
1410 /*----------------------------------------------------------------------*/
1411 /*                      Miscellaneous buffer values                     */
1412 /*----------------------------------------------------------------------*/
1413
1414 /* Number of characters in buffer */
1415 #define BUF_SIZE(buf) (BUF_Z (buf) - BUF_BEG (buf))
1416
1417 /* Is this buffer narrowed? */
1418 #define BUF_NARROWED(buf) \
1419    ((BI_BUF_BEGV (buf) != BI_BUF_BEG (buf)) || \
1420     (BI_BUF_ZV   (buf) != BI_BUF_Z   (buf)))
1421
1422 /* Modification count.  */
1423 #define BUF_MODIFF(buf) ((buf)->text->modiff)
1424
1425 /* Saved modification count.  */
1426 #define BUF_SAVE_MODIFF(buf) ((buf)->text->save_modiff)
1427
1428 /* Face changed.  */
1429 #define BUF_FACECHANGE(buf) ((buf)->face_change)
1430
1431 #define POINT_MARKER_P(marker) \
1432    (XMARKER (marker)->buffer != 0 && \
1433     EQ (marker, XMARKER (marker)->buffer->point_marker))
1434
1435 #define BUF_MARKERS(buf) ((buf)->markers)
1436
1437 /* WARNING:
1438
1439    The new definitions of CEILING_OF() and FLOOR_OF() differ semantically
1440    from the old ones (in FSF Emacs and XEmacs 19.11 and before).
1441    Conversion is as follows:
1442
1443    OLD_BI_CEILING_OF(n) = NEW_BI_CEILING_OF(n) - 1
1444    OLD_BI_FLOOR_OF(n) = NEW_BI_FLOOR_OF(n + 1)
1445
1446    The definitions were changed because the new definitions are more
1447    consistent with the way everything else works in Emacs.
1448  */
1449
1450 /* Properties of CEILING_OF and FLOOR_OF (also apply to BI_ variants):
1451
1452    1) FLOOR_OF (CEILING_OF (n)) = n
1453       CEILING_OF (FLOOR_OF (n)) = n
1454
1455    2) CEILING_OF (n) = n if and only if n = ZV
1456       FLOOR_OF (n) = n if and only if n = BEGV
1457
1458    3) CEILING_OF (CEILING_OF (n)) = ZV
1459       FLOOR_OF (FLOOR_OF (n)) = BEGV
1460
1461    4) The bytes in the regions
1462
1463       [BYTE_ADDRESS (n), BYTE_ADDRESS_BEFORE (CEILING_OF (n))]
1464
1465       and
1466
1467       [BYTE_ADDRESS (FLOOR_OF (n)), BYTE_ADDRESS_BEFORE (n)]
1468
1469       are contiguous.
1470    */
1471
1472
1473 /*  Return the maximum index in the buffer it is safe to scan forwards
1474     past N to.  This is used to prevent buffer scans from running into
1475     the gap (e.g. search.c).  All characters between N and CEILING_OF(N)
1476     are located contiguous in memory.  Note that the character *at*
1477     CEILING_OF(N) is not contiguous in memory. */
1478 #define BI_BUF_CEILING_OF(b, n)                                         \
1479   ((n) < (b)->text->gpt && (b)->text->gpt < BI_BUF_ZV (b) ?             \
1480    (b)->text->gpt : BI_BUF_ZV (b))
1481 #define BUF_CEILING_OF(b, n)                                            \
1482   bytind_to_bufpos (b, BI_BUF_CEILING_OF (b, bufpos_to_bytind (b, n)))
1483
1484 /*  Return the minimum index in the buffer it is safe to scan backwards
1485     past N to.  All characters between FLOOR_OF(N) and N are located
1486     contiguous in memory.  Note that the character *at* N may not be
1487     contiguous in memory. */
1488 #define BI_BUF_FLOOR_OF(b, n)                                           \
1489         (BI_BUF_BEGV (b) < (b)->text->gpt && (b)->text->gpt < (n) ?     \
1490          (b)->text->gpt : BI_BUF_BEGV (b))
1491 #define BUF_FLOOR_OF(b, n)                                              \
1492   bytind_to_bufpos (b, BI_BUF_FLOOR_OF (b, bufpos_to_bytind (b, n)))
1493
1494 #define BI_BUF_CEILING_OF_IGNORE_ACCESSIBLE(b, n)                       \
1495   ((n) < (b)->text->gpt && (b)->text->gpt < BI_BUF_Z (b) ?              \
1496    (b)->text->gpt : BI_BUF_Z (b))
1497 #define BUF_CEILING_OF_IGNORE_ACCESSIBLE(b, n)                          \
1498   bytind_to_bufpos                                                      \
1499    (b, BI_BUF_CEILING_OF_IGNORE_ACCESSIBLE (b, bufpos_to_bytind (b, n)))
1500
1501 #define BI_BUF_FLOOR_OF_IGNORE_ACCESSIBLE(b, n)                         \
1502         (BI_BUF_BEG (b) < (b)->text->gpt && (b)->text->gpt < (n) ?      \
1503          (b)->text->gpt : BI_BUF_BEG (b))
1504 #define BUF_FLOOR_OF_IGNORE_ACCESSIBLE(b, n)                            \
1505   bytind_to_bufpos                                                      \
1506    (b, BI_BUF_FLOOR_OF_IGNORE_ACCESSIBLE (b, bufpos_to_bytind (b, n)))
1507
1508
1509 extern struct buffer *current_buffer;
1510
1511 /* This is the initial (startup) directory, as used for the *scratch* buffer.
1512    We're making this a global to make others aware of the startup directory.
1513    `initial_directory' is stored in external format.
1514  */
1515 extern char initial_directory[];
1516 extern void init_initial_directory (void);   /* initialize initial_directory */
1517
1518 EXFUN (Fbuffer_disable_undo, 1);
1519 EXFUN (Fbuffer_modified_p, 1);
1520 EXFUN (Fbuffer_name, 1);
1521 EXFUN (Fcurrent_buffer, 0);
1522 EXFUN (Ferase_buffer, 1);
1523 EXFUN (Fget_buffer, 1);
1524 EXFUN (Fget_buffer_create, 1);
1525 EXFUN (Fget_file_buffer, 1);
1526 EXFUN (Fkill_buffer, 1);
1527 EXFUN (Fother_buffer, 3);
1528 EXFUN (Frecord_buffer, 1);
1529 EXFUN (Fset_buffer, 1);
1530 EXFUN (Fset_buffer_modified_p, 2);
1531
1532 extern Lisp_Object QSscratch, Qafter_change_function, Qafter_change_functions;
1533 extern Lisp_Object Qbefore_change_function, Qbefore_change_functions;
1534 extern Lisp_Object Qbuffer_or_string_p, Qdefault_directory, Qfirst_change_hook;
1535 extern Lisp_Object Qpermanent_local, Vafter_change_function;
1536 extern Lisp_Object Vafter_change_functions, Vbefore_change_function;
1537 extern Lisp_Object Vbefore_change_functions, Vbuffer_alist, Vbuffer_defaults;
1538 extern Lisp_Object Vinhibit_read_only, Vtransient_mark_mode;
1539
1540 /* This structure marks which slots in a buffer have corresponding
1541    default values in Vbuffer_defaults.
1542    Each such slot has a nonzero value in this structure.
1543    The value has only one nonzero bit.
1544
1545    When a buffer has its own local value for a slot,
1546    the bit for that slot (found in the same slot in this structure)
1547    is turned on in the buffer's local_var_flags slot.
1548
1549    If a slot in this structure is zero, then even though there may
1550    be a DEFVAR_BUFFER_LOCAL for the slot, there is no default value for it;
1551    and the corresponding slot in Vbuffer_defaults is not used.  */
1552
1553 extern struct buffer buffer_local_flags;
1554
1555
1556 /* Allocation of buffer data. */
1557
1558 #ifdef REL_ALLOC
1559
1560 char *r_alloc (unsigned char **, size_t);
1561 char *r_re_alloc (unsigned char **, size_t);
1562 void r_alloc_free (unsigned char **);
1563
1564 #define BUFFER_ALLOC(data, size) \
1565   ((Bufbyte *) r_alloc ((unsigned char **) &data, (size) * sizeof(Bufbyte)))
1566 #define BUFFER_REALLOC(data, size) \
1567   ((Bufbyte *) r_re_alloc ((unsigned char **) &data, (size) * sizeof(Bufbyte)))
1568 #define BUFFER_FREE(data) r_alloc_free ((unsigned char **) &(data))
1569 #define R_ALLOC_DECLARE(var,data) r_alloc_declare (&(var), data)
1570
1571 #else /* !REL_ALLOC */
1572
1573 #define BUFFER_ALLOC(data,size)\
1574         (data = xnew_array (Bufbyte, size))
1575 #define BUFFER_REALLOC(data,size)\
1576         ((Bufbyte *) xrealloc (data, (size) * sizeof(Bufbyte)))
1577 /* Avoid excess parentheses, or syntax errors may rear their heads. */
1578 #define BUFFER_FREE(data) xfree (data)
1579 #define R_ALLOC_DECLARE(var,data)
1580
1581 #endif /* !REL_ALLOC */
1582
1583 extern Lisp_Object Vbuffer_alist;
1584 void set_buffer_internal (struct buffer *b);
1585 struct buffer *decode_buffer (Lisp_Object buffer, int allow_string);
1586
1587 /* from editfns.c */
1588 void widen_buffer (struct buffer *b, int no_clip);
1589 int beginning_of_line_p (struct buffer *b, Bufpos pt);
1590
1591 /* from insdel.c */
1592 void set_buffer_point (struct buffer *buf, Bufpos pos, Bytind bipos);
1593 void find_charsets_in_bufbyte_string (unsigned char *charsets,
1594                                       const Bufbyte *str,
1595                                       Bytecount len);
1596 void find_charsets_in_emchar_string (unsigned char *charsets,
1597                                      const Emchar *str,
1598                                      Charcount len);
1599 int bufbyte_string_displayed_columns (const Bufbyte *str, Bytecount len);
1600 int emchar_string_displayed_columns (const Emchar *str, Charcount len);
1601 void convert_bufbyte_string_into_emchar_dynarr (const Bufbyte *str,
1602                                                 Bytecount len,
1603                                                 Emchar_dynarr *dyn);
1604 Charcount convert_bufbyte_string_into_emchar_string (const Bufbyte *str,
1605                                                      Bytecount len,
1606                                                      Emchar *arr);
1607 void convert_emchar_string_into_bufbyte_dynarr (Emchar *arr, int nels,
1608                                                 Bufbyte_dynarr *dyn);
1609 Bufbyte *convert_emchar_string_into_malloced_string (Emchar *arr, int nels,
1610                                                     Bytecount *len_out);
1611 /* from marker.c */
1612 void init_buffer_markers (struct buffer *b);
1613 void uninit_buffer_markers (struct buffer *b);
1614
1615 /* flags for get_buffer_pos_char(), get_buffer_range_char(), etc. */
1616 /* At most one of GB_COERCE_RANGE and GB_NO_ERROR_IF_BAD should be
1617    specified.  At most one of GB_NEGATIVE_FROM_END and GB_NO_ERROR_IF_BAD
1618    should be specified. */
1619
1620 #define GB_ALLOW_PAST_ACCESSIBLE        (1 << 0)
1621 #define GB_ALLOW_NIL                    (1 << 1)
1622 #define GB_CHECK_ORDER                  (1 << 2)
1623 #define GB_COERCE_RANGE                 (1 << 3)
1624 #define GB_NO_ERROR_IF_BAD              (1 << 4)
1625 #define GB_NEGATIVE_FROM_END            (1 << 5)
1626 #define GB_HISTORICAL_STRING_BEHAVIOR   (GB_NEGATIVE_FROM_END | GB_ALLOW_NIL)
1627
1628 Bufpos get_buffer_pos_char (struct buffer *b, Lisp_Object pos,
1629                             unsigned int flags);
1630 Bytind get_buffer_pos_byte (struct buffer *b, Lisp_Object pos,
1631                             unsigned int flags);
1632 void get_buffer_range_char (struct buffer *b, Lisp_Object from, Lisp_Object to,
1633                             Bufpos *from_out, Bufpos *to_out,
1634                             unsigned int flags);
1635 void get_buffer_range_byte (struct buffer *b, Lisp_Object from, Lisp_Object to,
1636                             Bytind *from_out, Bytind *to_out,
1637                             unsigned int flags);
1638 Charcount get_string_pos_char (Lisp_Object string, Lisp_Object pos,
1639                                unsigned int flags);
1640 Bytecount get_string_pos_byte (Lisp_Object string, Lisp_Object pos,
1641                                unsigned int flags);
1642 void get_string_range_char (Lisp_Object string, Lisp_Object from,
1643                             Lisp_Object to, Charcount *from_out,
1644                             Charcount *to_out, unsigned int flags);
1645 void get_string_range_byte (Lisp_Object string, Lisp_Object from,
1646                             Lisp_Object to, Bytecount *from_out,
1647                             Bytecount *to_out, unsigned int flags);
1648 Bufpos get_buffer_or_string_pos_char (Lisp_Object object, Lisp_Object pos,
1649                                       unsigned int flags);
1650 Bytind get_buffer_or_string_pos_byte (Lisp_Object object, Lisp_Object pos,
1651                                       unsigned int flags);
1652 void get_buffer_or_string_range_char (Lisp_Object object, Lisp_Object from,
1653                                       Lisp_Object to, Bufpos *from_out,
1654                                       Bufpos *to_out, unsigned int flags);
1655 void get_buffer_or_string_range_byte (Lisp_Object object, Lisp_Object from,
1656                                       Lisp_Object to, Bytind *from_out,
1657                                       Bytind *to_out, unsigned int flags);
1658 Bufpos buffer_or_string_accessible_begin_char (Lisp_Object object);
1659 Bufpos buffer_or_string_accessible_end_char (Lisp_Object object);
1660 Bytind buffer_or_string_accessible_begin_byte (Lisp_Object object);
1661 Bytind buffer_or_string_accessible_end_byte (Lisp_Object object);
1662 Bufpos buffer_or_string_absolute_begin_char (Lisp_Object object);
1663 Bufpos buffer_or_string_absolute_end_char (Lisp_Object object);
1664 Bytind buffer_or_string_absolute_begin_byte (Lisp_Object object);
1665 Bytind buffer_or_string_absolute_end_byte (Lisp_Object object);
1666 void record_buffer (Lisp_Object buf);
1667 Lisp_Object get_buffer (Lisp_Object name,
1668                         int error_if_deleted_or_does_not_exist);
1669 int map_over_sharing_buffers (struct buffer *buf,
1670                               int (*mapfun) (struct buffer *buf,
1671                                              void *closure),
1672                               void *closure);
1673
1674 \f
1675 /************************************************************************/
1676 /*                         Case conversion                              */
1677 /************************************************************************/
1678
1679 /* A "trt" table is a mapping from characters to other characters,
1680    typically used to convert between uppercase and lowercase.  For
1681    compatibility reasons, trt tables are currently in the form of
1682    a Lisp string of 256 characters, specifying the conversion for each
1683    of the first 256 Emacs characters (i.e. the 256 Latin-1 characters).
1684    This should be generalized at some point to support conversions for
1685    all of the allowable Mule characters.
1686    */
1687
1688 /* The _1 macros are named as such because they assume that you have
1689    already guaranteed that the character values are all in the range
1690    0 - 255.  Bad lossage will happen otherwise. */
1691
1692 #define MAKE_TRT_TABLE() Fmake_char_table (Qgeneric)
1693 INLINE_HEADER Emchar TRT_TABLE_CHAR_1 (Lisp_Object table, Emchar c);
1694 INLINE_HEADER Emchar
1695 TRT_TABLE_CHAR_1 (Lisp_Object table, Emchar ch)
1696 {
1697   Lisp_Object TRT_char;
1698   TRT_char = get_char_table (ch, XCHAR_TABLE (table));
1699   if (NILP (TRT_char))
1700     return ch;
1701   else
1702     return XCHAR (TRT_char);
1703 }
1704 #define SET_TRT_TABLE_CHAR_1(table, ch1, ch2)   \
1705   Fput_char_table (make_char (ch1), make_char (ch2), table);
1706
1707 INLINE_HEADER Emchar TRT_TABLE_OF (Lisp_Object trt, Emchar c);
1708 INLINE_HEADER Emchar
1709 TRT_TABLE_OF (Lisp_Object trt, Emchar c)
1710 {
1711   return TRT_TABLE_CHAR_1 (trt, c);
1712 }
1713
1714 /* Macros used below. */
1715 #define DOWNCASE_TABLE_OF(buf, c)       \
1716   TRT_TABLE_OF (XCASE_TABLE_DOWNCASE (buf->case_table), c)
1717 #define UPCASE_TABLE_OF(buf, c)         \
1718   TRT_TABLE_OF (XCASE_TABLE_UPCASE (buf->case_table), c)
1719
1720 /* 1 if CH is upper case.  */
1721
1722 INLINE_HEADER int UPPERCASEP (struct buffer *buf, Emchar ch);
1723 INLINE_HEADER int
1724 UPPERCASEP (struct buffer *buf, Emchar ch)
1725 {
1726   return DOWNCASE_TABLE_OF (buf, ch) != ch;
1727 }
1728
1729 /* 1 if CH is lower case.  */
1730
1731 INLINE_HEADER int LOWERCASEP (struct buffer *buf, Emchar ch);
1732 INLINE_HEADER int
1733 LOWERCASEP (struct buffer *buf, Emchar ch)
1734 {
1735   return (UPCASE_TABLE_OF   (buf, ch) != ch &&
1736           DOWNCASE_TABLE_OF (buf, ch) == ch);
1737 }
1738
1739 /* 1 if CH is neither upper nor lower case.  */
1740
1741 INLINE_HEADER int NOCASEP (struct buffer *buf, Emchar ch);
1742 INLINE_HEADER int
1743 NOCASEP (struct buffer *buf, Emchar ch)
1744 {
1745   return UPCASE_TABLE_OF (buf, ch) == ch;
1746 }
1747
1748 /* Upcase a character, or make no change if that cannot be done.  */
1749
1750 INLINE_HEADER Emchar UPCASE (struct buffer *buf, Emchar ch);
1751 INLINE_HEADER Emchar
1752 UPCASE (struct buffer *buf, Emchar ch)
1753 {
1754   return (DOWNCASE_TABLE_OF (buf, ch) == ch) ? UPCASE_TABLE_OF (buf, ch) : ch;
1755 }
1756
1757 /* Upcase a character known to be not upper case.  Unused. */
1758
1759 #define UPCASE1(buf, ch) UPCASE_TABLE_OF (buf, ch)
1760
1761 /* Downcase a character, or make no change if that cannot be done. */
1762
1763 #define DOWNCASE(buf, ch) DOWNCASE_TABLE_OF (buf, ch)
1764
1765 /************************************************************************/
1766 /*              Lisp string representation convenience functions        */
1767 /************************************************************************/
1768 /* Because the representation of internally formatted data is subject to change,
1769    It's bad style to do something like strcmp (XSTRING_DATA (s), "foo")
1770    Instead, use the portable: bufbyte_strcmp (XSTRING_DATA (s), "foo")
1771    or bufbyte_memcmp (XSTRING_DATA (s), "foo", 3) */
1772
1773 /* Like strcmp, except first arg points at internally formatted data,
1774    while the second points at a string of only ASCII chars. */
1775 INLINE_HEADER int
1776 bufbyte_strcmp (const Bufbyte *bp, const char *ascii_string);
1777 INLINE_HEADER int
1778 bufbyte_strcmp (const Bufbyte *bp, const char *ascii_string)
1779 {
1780 #ifdef MULE
1781   while (1)
1782     {
1783       int diff;
1784       type_checking_assert (BYTE_ASCII_P (*ascii_string));
1785       if ((diff = charptr_emchar (bp) - *(Bufbyte *) ascii_string) != 0)
1786         return diff;
1787       if (*ascii_string == '\0')
1788         return 0;
1789       ascii_string++;
1790       INC_CHARPTR (bp);
1791     }
1792 #else
1793   return strcmp ((char *)bp, ascii_string);
1794 #endif
1795 }
1796
1797
1798 /* Like memcmp, except first arg points at internally formatted data,
1799    while the second points at a string of only ASCII chars. */
1800 INLINE_HEADER int
1801 bufbyte_memcmp (const Bufbyte *bp, const char *ascii_string, size_t len);
1802 INLINE_HEADER int
1803 bufbyte_memcmp (const Bufbyte *bp, const char *ascii_string, size_t len)
1804 {
1805 #ifdef MULE
1806   while (len--)
1807     {
1808       int diff = charptr_emchar (bp) - *(Bufbyte *) ascii_string;
1809       type_checking_assert (BYTE_ASCII_P (*ascii_string));
1810       if (diff != 0)
1811         return diff;
1812       ascii_string++;
1813       INC_CHARPTR (bp);
1814     }
1815   return 0;
1816 #else
1817   return memcmp (bp, ascii_string, len);
1818 #endif
1819 }
1820
1821 #endif /* INCLUDED_buffer_h_ */