src/buffer.h

   1 /* Header file for the buffer manipulation primitives.
   2    Copyright (C) 1985, 1986, 1993, 1994, 1995 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #ifdef USE_TEXT_PROPERTIES
  23 #define SET_PT(position) (set_point ((position), current_buffer))
  24 #define TEMP_SET_PT(position) (temp_set_point ((position), current_buffer))
  25
  26 #define BUF_SET_PT(buffer, position) (set_point ((position), (buffer)))
  27 #define BUF_TEMP_SET_PT(buffer, position) (temp_set_point ((position), (buffer)))
  28
  29 #else  /* don't support text properties */
  30
  31 #define SET_PT(position) (current_buffer->pt = (position))
  32 #define TEMP_SET_PT(position) (current_buffer->pt = (position))
  33
  34 #define BUF_SET_PT(buffer, position) (buffer->pt = (position))
  35 #define BUF_TEMP_SET_PT(buffer, position) (buffer->pt = (position))
  36 #endif /* don't support text properties */
  37
  38 /* Character position of beginning of buffer.  */
  39 #define BEG (1)
  40
  41 /* Character position of beginning of accessible range of buffer.  */
  42 #define BEGV (current_buffer->begv)
  43
  44 /* Character position of point in buffer.  The "+ 0" makes this
  45    not an l-value, so you can't assign to it.  Use SET_PT instead.  */
  46 #define PT (current_buffer->pt + 0)
  47
  48 /* Character position of gap in buffer.  */
  49 #define GPT (current_buffer->text->gpt)
  50
  51 /* Character position of end of accessible range of buffer.  */
  52 #define ZV (current_buffer->zv)
  53
  54 /* Character position of end of buffer.  */
  55 #define Z (current_buffer->text->z)
  56
  57 /* Is the current buffer narrowed? */
  58 #define NARROWED        ((BEGV != BEG) || (ZV != Z))
  59
  60 /* Modification count.  */
  61 #define MODIFF (current_buffer->text->modiff)
  62
  63 /* Overlay modification count.  */
  64 #define OVERLAY_MODIFF (current_buffer->text->overlay_modiff)
  65
  66 /* Modification count as of last visit or save.  */
  67 #define SAVE_MODIFF (current_buffer->text->save_modiff)
  68
  69 /* Address of beginning of buffer.  */
  70 #define BEG_ADDR (current_buffer->text->beg)
  71
  72 /* Address of beginning of accessible range of buffer.  */
  73 #define BEGV_ADDR (POS_ADDR (current_buffer->begv))
  74
  75 /* Address of point in buffer.  */
  76 #define PT_ADDR (POS_ADDR (current_buffer->pt))
  77
  78 /* Address of beginning of gap in buffer.  */
  79 #define GPT_ADDR (current_buffer->text->beg + current_buffer->text->gpt - 1)
  80
  81 /* Address of end of gap in buffer.  */
  82 #define GAP_END_ADDR (current_buffer->text->beg + current_buffer->text->gpt + current_buffer->text->gap_size - 1)
  83
  84 /* Address of end of accessible range of buffer.  */
  85 #define ZV_ADDR (POS_ADDR (current_buffer->zv))
  86
  87 /* Address of end of buffer.  */
  88 #define Z_ADDR (current_buffer->text->beg + current_buffer->text->gap_size + current_buffer->text->z - 1)
  89
  90 /* Size of gap.  */
  91 #define GAP_SIZE (current_buffer->text->gap_size)
  92
  93 /* Now similar macros for a specified buffer.
  94    Note that many of these evaluate the buffer argument more than once.  */
  95
  96 /* Character position of beginning of buffer.  */
  97 #define BUF_BEG(buf) (1)
  98
  99 /* Character position of beginning of accessible range of buffer.  */
 100 #define BUF_BEGV(buf) ((buf)->begv)
 101
 102 /* Character position of point in buffer.  */
 103 #define BUF_PT(buf) ((buf)->pt)
 104
 105 /* Character position of gap in buffer.  */
 106 #define BUF_GPT(buf) ((buf)->text->gpt)
 107
 108 /* Character position of end of accessible range of buffer.  */
 109 #define BUF_ZV(buf) ((buf)->zv)
 110
 111 /* Character position of end of buffer.  */
 112 #define BUF_Z(buf) ((buf)->text->z)
 113
 114 /* Is this buffer narrowed? */
 115 #define BUF_NARROWED(buf) ((BUF_BEGV (buf) != BUF_BEG (buf)) \
 116                            || (BUF_ZV (buf) != BUF_Z (buf)))
 117
 118 /* Modification count.  */
 119 #define BUF_MODIFF(buf) ((buf)->text->modiff)
 120
 121 /* Modification count as of last visit or save.  */
 122 #define BUF_SAVE_MODIFF(buf) ((buf)->text->save_modiff)
 123
 124 /* Overlay modification count.  */
 125 #define BUF_OVERLAY_MODIFF(buf) ((buf)->text->overlay_modiff)
 126
 127 /* Interval tree of buffer.  */
 128 #define BUF_INTERVALS(buf) ((buf)->text->intervals)
 129
 130 /* Marker chain of buffer.  */
 131 #define BUF_MARKERS(buf) ((buf)->text->markers)
 132
 133 /* Address of beginning of buffer.  */
 134 #define BUF_BEG_ADDR(buf) ((buf)->text->beg)
 135
 136 /* Address of beginning of gap of buffer.  */
 137 #define BUF_GPT_ADDR(buf) ((buf)->text->beg + (buf)->text->gpt - 1)
 138
 139 /* Address of end of buffer.  */
 140 #define BUF_Z_ADDR(buf) ((buf)->text->beg + (buf)->text->gap_size + (buf)->text->z - 1)
 141
 142 /* Macro for setting the value of BUF_ZV (BUF) to VALUE,
 143    by varying the end of the accessible region.  */
 144 #define SET_BUF_ZV(buf, value) ((buf)->zv = (value))
 145 #define SET_BUF_PT(buf, value) ((buf)->pt = (value))
 146
 147 /* Size of gap.  */
 148 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size)
 149
 150 /* Return the address of character at position POS in buffer BUF.
 151    Note that both arguments can be computed more than once.  */
 152 #define BUF_CHAR_ADDRESS(buf, pos) \
 153 ((buf)->text->beg + (pos) - 1           \
 154  + ((pos) >= (buf)->text->gpt ? (buf)->text->gap_size : 0))
 155
 156 /* Convert the address of a char in the buffer into a character position.  */
 157 #define PTR_CHAR_POS(ptr) \
 158 ((ptr) - (current_buffer)->text->beg                                    \
 159  - (ptr - (current_buffer)->text->beg < (unsigned) GPT ? 0 : GAP_SIZE)  \
 160  + 1)
 161
 162 /* Convert the address of a char in the buffer into a character position.  */
 163 #define BUF_PTR_CHAR_POS(buf, ptr)                      \
 164 ((ptr) - (buf)->text->beg                               \
 165  - (ptr - (buf)->text->beg < (unsigned) BUF_GPT ((buf)) \
 166     ? 0 : BUF_GAP_SIZE ((buf)))                         \
 167  + 1)
 168 \f
 169 struct buffer_text
 170   {
 171     unsigned char *beg;         /* Actual address of buffer contents.  */
 172     int gpt;                    /* Index of gap in buffer.  */
 173     int z;                      /* Index of end of buffer.  */
 174     int gap_size;               /* Size of buffer's gap.  */
 175     int modiff;                 /* This counts buffer-modification events
 176                                    for this buffer.  It is incremented for
 177                                    each such event, and never otherwise
 178                                    changed.  */
 179     int save_modiff;            /* Previous value of modiff, as of last
 180                                    time buffer visited or saved a file.  */
 181
 182     int overlay_modiff;         /* Counts modifications to overlays.  */
 183
 184     /* Properties of this buffer's text -- conditionally compiled.  */
 185     DECLARE_INTERVALS
 186
 187     /* The markers that refer to this buffer.
 188        This is actually a single marker ---
 189        successive elements in its marker `chain'
 190        are the other markers referring to this buffer.  */
 191     Lisp_Object markers;
 192   };
 193
 194 struct buffer
 195   {
 196     /* Everything before the `name' slot must be of a non-Lisp_Object type,
 197        and every slot after `name' must be a Lisp_Object.
 198
 199        Check out mark_buffer (alloc.c) to see why.  */
 200
 201     EMACS_INT size;
 202
 203     /* Next buffer, in chain of all buffers including killed buffers.
 204        This chain is used only for garbage collection, in order to
 205        collect killed buffers properly.
 206        Note that vectors and most pseudovectors are all on one chain,
 207        but buffers are on a separate chain of their own.  */
 208     struct buffer *next;
 209
 210     /* This structure holds the coordinates of the buffer contents
 211        in ordinary buffers.  In indirect buffers, this is not used.  */
 212     struct buffer_text own_text;
 213
 214     /* This points to the `struct buffer_text' that used for this buffer.
 215        In an ordinary buffer, this is the own_text field above.
 216        In an indirect buffer, this is the own_text field of another buffer.  */
 217     struct buffer_text *text;
 218
 219     /* Position of point in buffer.  */
 220     int pt;
 221     /* Index of beginning of accessible range.  */
 222     int begv;
 223     /* Index of end of accessible range.  */
 224     int zv;
 225
 226     /* In an indirect buffer, this points to the base buffer.
 227        In an ordinary buffer, it is 0.  */
 228     struct buffer *base_buffer;
 229
 230     /* Flags saying which DEFVAR_PER_BUFFER variables
 231        are local to this buffer.  */
 232     int local_var_flags;
 233     /* Set to the modtime of the visited file when read or written.
 234        -1 means visited file was nonexistent.
 235        0 means visited file modtime unknown; in no case complain
 236        about any mismatch on next save attempt.  */
 237     int modtime;
 238     /* the value of text->modiff at the last auto-save.  */
 239     int auto_save_modified;
 240     /* The time at which we detected a failure to auto-save,
 241        Or -1 if we didn't have a failure.  */
 242     int auto_save_failure_time;
 243     /* Position in buffer at which display started
 244        the last time this buffer was displayed.  */
 245     int last_window_start;
 246
 247     /* Set nonzero whenever the narrowing is changed in this buffer.  */
 248     int clip_changed;
 249
 250     /* If the long line scan cache is enabled (i.e. the buffer-local
 251        variable cache-long-line-scans is non-nil), newline_cache
 252        points to the newline cache, and width_run_cache points to the
 253        width run cache.
 254
 255        The newline cache records which stretches of the buffer are
 256        known *not* to contain newlines, so that they can be skipped
 257        quickly when we search for newlines.
 258
 259        The width run cache records which stretches of the buffer are
 260        known to contain characters whose widths are all the same.  If
 261        the width run cache maps a character to a value > 0, that value is
 262        the character's width; if it maps a character to zero, we don't
 263        know what its width is.  This allows compute_motion to process
 264        such regions very quickly, using algebra instead of inspecting
 265        each character.   See also width_table, below.  */
 266     struct region_cache *newline_cache;
 267     struct region_cache *width_run_cache;
 268
 269     /* Everything from here down must be a Lisp_Object */
 270
 271
 272     /* The name of this buffer.  */
 273     Lisp_Object name;
 274     /* The name of the file visited in this buffer, or nil.  */
 275     Lisp_Object filename;
 276     /* Dir for expanding relative file names.  */
 277     Lisp_Object directory;
 278     /* True iff this buffer has been backed up (if you write to the
 279        visited file and it hasn't been backed up, then a backup will
 280        be made).  */
 281     /* This isn't really used by the C code, so could be deleted.  */
 282     Lisp_Object backed_up;
 283     /* Length of file when last read or saved.
 284        This is not in the  struct buffer_text
 285        because it's not used in indirect buffers at all.  */
 286     Lisp_Object save_length;
 287     /* File name used for auto-saving this buffer.
 288        This is not in the  struct buffer_text
 289        because it's not used in indirect buffers at all.  */
 290     Lisp_Object auto_save_file_name;
 291
 292     /* Non-nil if buffer read-only.  */
 293     Lisp_Object read_only;
 294     /* "The mark".  This is a marker which may
 295        point into this buffer or may point nowhere.  */
 296     Lisp_Object mark;
 297
 298     /* Alist of elements (SYMBOL . VALUE-IN-THIS-BUFFER)
 299        for all per-buffer variables of this buffer.  */
 300     Lisp_Object local_var_alist;
 301
 302     /* Symbol naming major mode (eg, lisp-mode).  */
 303     Lisp_Object major_mode;
 304     /* Pretty name of major mode (eg, "Lisp"). */
 305     Lisp_Object mode_name;
 306     /* Mode line element that controls format of mode line.  */
 307     Lisp_Object mode_line_format;
 308
 309     /* Keys that are bound local to this buffer.  */
 310     Lisp_Object keymap;
 311     /* This buffer's local abbrev table.  */
 312     Lisp_Object abbrev_table;
 313     /* This buffer's syntax table.  */
 314     Lisp_Object syntax_table;
 315     /* This buffer's category table.  */
 316     Lisp_Object category_table;
 317
 318     /* Values of several buffer-local variables */
 319     /* tab-width is buffer-local so that redisplay can find it
 320        in buffers that are not current */
 321     Lisp_Object case_fold_search;
 322     Lisp_Object tab_width;
 323     Lisp_Object fill_column;
 324     Lisp_Object left_margin;
 325     /* Function to call when insert space past fill column.  */
 326     Lisp_Object auto_fill_function;
 327     /* nil: text, t: binary.
 328        This value is meaningful only on certain operating systems.  */
 329     /* Actually, we don't need this flag any more because end-of-line
 330        is handled correctly according to the buffer-file-coding-system
 331        of the buffer.  Just keeping it for backward compatibility.  */
 332     Lisp_Object buffer_file_type;
 333
 334     /* Case table for case-conversion in this buffer.
 335        This char-table maps each char into its lower-case version.  */
 336     Lisp_Object downcase_table;
 337     /* Char-table mapping each char to its upper-case version.  */
 338     Lisp_Object upcase_table;
 339     /* Char-table for conversion for case-folding search.  */
 340     Lisp_Object case_canon_table;
 341     /* Char-table of equivalences for case-folding search.  */
 342     Lisp_Object case_eqv_table;
 343
 344     /* Non-nil means do not display continuation lines.  */
 345     Lisp_Object truncate_lines;
 346     /* Non-nil means display ctl chars with uparrow.  */
 347     Lisp_Object ctl_arrow;
 348     /* Non-nil means display text from right to left.  */
 349     Lisp_Object direction_reversed;
 350     /* Non-nil means do selective display;
 351        see doc string in syms_of_buffer (buffer.c) for details.  */
 352     Lisp_Object selective_display;
 353 #ifndef old
 354     /* Non-nil means show ... at end of line followed by invisible lines.  */
 355     Lisp_Object selective_display_ellipses;
 356 #endif
 357     /* Alist of (FUNCTION . STRING) for each minor mode enabled in buffer.  */
 358     Lisp_Object minor_modes;
 359     /* t if "self-insertion" should overwrite; `binary' if it should also
 360        overwrite newlines and tabs - for editing executables and the like.  */
 361     Lisp_Object overwrite_mode;
 362     /* non-nil means abbrev mode is on.  Expand abbrevs automatically.  */
 363     Lisp_Object abbrev_mode;
 364     /* Display table to use for text in this buffer.  */
 365     Lisp_Object display_table;
 366     /* t means the mark and region are currently active.  */
 367     Lisp_Object mark_active;
 368
 369     /* Changes in the buffer are recorded here for undo.
 370        t means don't record anything.
 371        This information belongs to the base buffer of an indirect buffer,
 372        But we can't store it in the  struct buffer_text
 373        because local variables have to be right in the  struct buffer.
 374        So we copy it around in set_buffer_internal.  */
 375     Lisp_Object undo_list;
 376
 377     /* List of overlays that end at or before the current center,
 378        in order of end-position.  */
 379     Lisp_Object overlays_before;
 380
 381     /* List of overlays that end after  the current center,
 382        in order of start-position.  */
 383     Lisp_Object overlays_after;
 384
 385     /* Position where the overlay lists are centered.  */
 386     Lisp_Object overlay_center;
 387
 388     /* Non-nil means the buffer contents are regarded as multi-byte
 389        form of characters, not a binary code.  */
 390     Lisp_Object enable_multibyte_characters;
 391
 392     /* Coding system to be used for encoding the buffer contents on
 393        saving.  */
 394     Lisp_Object buffer_file_coding_system;
 395
 396     /* List of symbols naming the file format used for visited file. */
 397     Lisp_Object file_format;
 398
 399     /* True if the newline position cache and width run cache are
 400        enabled.  See search.c and indent.c.  */
 401     Lisp_Object cache_long_line_scans;
 402
 403     /* If the width run cache is enabled, this table contains the
 404        character widths width_run_cache (see above) assumes.  When we
 405        do a thorough redisplay, we compare this against the buffer's
 406        current display table to see whether the display table has
 407        affected the widths of any characters.  If it has, we
 408        invalidate the width run cache, and re-initialize width_table.  */
 409     Lisp_Object width_table;
 410
 411     /* In an indirect buffer, or a buffer that is the base of an
 412        indirect buffer, this holds a marker that records
 413        PT for this buffer when the buffer is not current.  */
 414     Lisp_Object pt_marker;
 415
 416     /* In an indirect buffer, or a buffer that is the base of an
 417        indirect buffer, this holds a marker that records
 418        BEGV for this buffer when the buffer is not current.  */
 419     Lisp_Object begv_marker;
 420
 421     /* In an indirect buffer, or a buffer that is the base of an
 422        indirect buffer, this holds a marker that records
 423        ZV for this buffer when the buffer is not current.  */
 424     Lisp_Object zv_marker;
 425
 426     /* This holds the point value before the last scroll operation.
 427        Explicitly setting point sets this to nil.  */
 428     Lisp_Object point_before_scroll;
 429
 430     /* Truename of the visited file, or nil.  */
 431     Lisp_Object file_truename;
 432
 433     /* Invisibility spec of this buffer.
 434        t => any non-nil `invisible' property means invisible.
 435        A list => `invisible' property means invisible
 436                  if it is memq in that list.  */
 437     Lisp_Object invisibility_spec;
 438
 439     /* This is the last window that was selected with this buffer in it,
 440        or nil if that window no longer displays this buffer.  */
 441     Lisp_Object last_selected_window;
 442
 443     /* Incremented each time the buffer is displayed in a window.  */
 444     Lisp_Object display_count;
 445
 446     /* These are so we don't have to recompile everything
 447        the next few times we add a new slot.  */
 448     Lisp_Object extra2, extra3;
 449   };
 450 \f
 451 /* This points to the current buffer.  */
 452
 453 extern struct buffer *current_buffer;
 454
 455 /* This structure holds the default values of the buffer-local variables
 456    that have special slots in each buffer.
 457    The default value occupies the same slot in this structure
 458    as an individual buffer's value occupies in that buffer.
 459    Setting the default value also goes through the alist of buffers
 460    and stores into each buffer that does not say it has a local value.  */
 461
 462 extern struct buffer buffer_defaults;
 463
 464 /* This structure marks which slots in a buffer have corresponding
 465    default values in buffer_defaults.
 466    Each such slot has a nonzero value in this structure.
 467    The value has only one nonzero bit.
 468
 469    When a buffer has its own local value for a slot,
 470    the bit for that slot (found in the same slot in this structure)
 471    is turned on in the buffer's local_var_flags slot.
 472
 473    If a slot in this structure is zero, then even though there may
 474    be a Lisp-level local variable for the slot, it has no default value,
 475    and the corresponding slot in buffer_defaults is not used.  */
 476
 477 extern struct buffer buffer_local_flags;
 478
 479 /* For each buffer slot, this points to the Lisp symbol name
 480    for that slot in the current buffer.  It is 0 for slots
 481    that don't have such names.  */
 482
 483 extern struct buffer buffer_local_symbols;
 484
 485 /* This structure holds the required types for the values in the
 486    buffer-local slots.  If a slot contains Qnil, then the
 487    corresponding buffer slot may contain a value of any type.  If a
 488    slot contains an integer, then prospective values' tags must be
 489    equal to that integer.  When a tag does not match, the function
 490    buffer_slot_type_mismatch will signal an error.  The value Qnil may
 491    always be safely stored in any slot.  */
 492 extern struct buffer buffer_local_types;
 493 \f
 494 /* Return the address of position N.  No range checking.  */
 495 #define POS_ADDR(n) (((n)>= GPT ? GAP_SIZE : 0) + (n) + BEG_ADDR - 1)
 496
 497 /* Return the byte at position N.  No range checking.  */
 498 #define FETCH_BYTE(n) *(POS_ADDR ((n)))
 499
 500 /* Variables used locally in FETCH_MULTIBYTE_CHAR.  */
 501 extern unsigned char *_fetch_multibyte_char_p;
 502 extern int _fetch_multibyte_char_len;
 503
 504 /* Return character code of multi-byte form at position POS.  If POS
 505    doesn't point the head of valid multi-byte form, only the byte at
 506    POS is returned.  No range checking.  */
 507
 508 #define FETCH_MULTIBYTE_CHAR(pos)                                       \
 509   (_fetch_multibyte_char_p = (((pos) >= GPT ? GAP_SIZE : 0)             \
 510                                + (pos) + BEG_ADDR - 1),                 \
 511    _fetch_multibyte_char_len = ((pos) >= GPT ? ZV : GPT) - (pos),       \
 512    STRING_CHAR (_fetch_multibyte_char_p, _fetch_multibyte_char_len))
 513
 514 /* Return character at position POS.  No range checking.  */
 515 #define FETCH_CHAR(pos)                                 \
 516   (!NILP (current_buffer->enable_multibyte_characters)  \
 517    ? FETCH_MULTIBYTE_CHAR ((pos))                       \
 518    : FETCH_BYTE ((pos)))
 519
 520 /* BUFFER_CEILING_OF (resp. BUFFER_FLOOR_OF), when applied to n, return
 521    the max (resp. min) p such that
 522
 523    POS_ADDR (p) - POS_ADDR (n) == p - n       */
 524
 525 #define BUFFER_CEILING_OF(n) (((n) < GPT && GPT < ZV ? GPT : ZV) - 1)
 526 #define BUFFER_FLOOR_OF(n) (BEGV <= GPT && GPT <= (n) ? GPT : BEGV)
 527
 528 extern void reset_buffer ();
 529 extern void evaporate_overlays ();
 530
 531 extern Lisp_Object Fbuffer_name ();
 532 extern Lisp_Object Fget_file_buffer ();
 533 extern Lisp_Object Fnext_overlay_change ();
 534 extern Lisp_Object Fdelete_overlay ();
 535
 536 /* Functions to call before and after each text change.  */
 537 extern Lisp_Object Vbefore_change_function;
 538 extern Lisp_Object Vafter_change_function;
 539 extern Lisp_Object Vbefore_change_functions;
 540 extern Lisp_Object Vafter_change_functions;
 541 extern Lisp_Object Vfirst_change_hook;
 542 extern Lisp_Object Qbefore_change_functions;
 543 extern Lisp_Object Qafter_change_functions;
 544 extern Lisp_Object Qfirst_change_hook;
 545
 546 extern Lisp_Object Vdeactivate_mark;
 547 extern Lisp_Object Vtransient_mark_mode;
 548 \f
 549 /* Overlays */
 550
 551 /* 1 if the OV is an overlay object.  */
 552 #define OVERLAY_VALID(OV) (OVERLAYP (OV))
 553
 554 /* Return the marker that stands for where OV starts in the buffer.  */
 555 #define OVERLAY_START(OV) (XOVERLAY (OV)->start)
 556
 557 /* Return the marker that stands for where OV ends in the buffer.  */
 558 #define OVERLAY_END(OV) (XOVERLAY (OV)->end)
 559
 560 /* Return the actual buffer position for the marker P.
 561    We assume you know which buffer it's pointing into.  */
 562
 563 #define OVERLAY_POSITION(P) \
 564  (GC_MARKERP (P) ? marker_position (P) : (abort (), 0))
 565
 566 /* Allocation of buffer text.  */
 567
 568 #ifdef REL_ALLOC
 569 #define BUFFER_ALLOC(data,size) ((unsigned char *) r_alloc (&data, (size)))
 570 #define BUFFER_REALLOC(data,size) ((unsigned char *) r_re_alloc (&data, (size)))
 571 #define BUFFER_FREE(data) (r_alloc_free (&data))
 572 #define R_ALLOC_DECLARE(var,data) (r_alloc_declare (&var, (data)))
 573 #else
 574 #define BUFFER_ALLOC(data,size) (data = (unsigned char *) malloc ((size)))
 575 #define BUFFER_REALLOC(data,size) ((unsigned char *) realloc ((data), (size)))
 576 #define BUFFER_FREE(data) (free ((data)))
 577 #define R_ALLOC_DECLARE(var,data)
 578 #endif