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