github.com/Arquivotheca.SunOS-4.1.4
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
ff309bfe1c8e554728af4b8a4e9cee4d026a7e35
Arquivotheca.SunOS-4.1.4/usr.lib/libsuntool/text/ps_impl.c
seta75D ff309bfe1c Init
2021-10-11 18:37:13 -03:00

1665 lines
53 KiB
C
Raw Blame History

#ifndef lint
#ifdef sccs
static char sccsid[] = "@(#)ps_impl.c 1.1 94/10/31";
#endif
#endif
/*
* Copyright (c) 1986, 1987 by Sun Microsystems Inc.
*/
/*
* Entity stream implementation for manager of two other streams.
*
* Conceptually, suppose we want the piece source to contain:
* AB0CD12E345FGH67I8JK9LMN
* and the original source contains:
* ABCDEFGHIJKLMN
* then the operation sequence:
* replace start:2 stop_plus_one:2 with:"0"
* replace start:5 stop_plus_one:5 with:"12"
* etc
* will generate a scratch source that looks like:
* xx0xx12xx345xx67xx8xx9
* and the piece table will alternate with:
* virtual pos:0, length:2, source:original, source_pos:0
* virtual pos:2, length:1, source:scratch, source_pos:sizeof(xx)
* virtual pos:3, length:2, source:original, source_pos:2
* virtual pos:5, length:2, source:scratch, source_pos:2*sizeof(xx)+1
* etc
*
* It is important that a piece in the piece table represent a contiguous
* run of entities in the original or scratch stream. Thus, if a break is
* detected during the first read of a piece, a new piece must be created.
*
* 87Mar23: A major new feature is support for a maximum size that the
* scratch stream is allowed to grow to. The basic design:
* Most of the piece_stream code believes that the scratch stream grows
* without bound. However, in reality, if the client sets a maximum size on
* the scratch stream, the ops vector for the scratch stream is modified
* so that the logical index space of [0..private->scratch_length) is
* mapped to the physical index space of [0..private->scratch_max_len),
* essentially by making all accesses to the logical indices be modulo
* private->scratch_max_len.
* Some special care must be taken with UNDO and secondary piece streams,
* as these both can use logical indices to reference entities that are no
* longer physically available.
*/
#include <suntool/primal.h>
#include <suntool/textsw_impl.h>
#include <stdio.h>
#include <varargs.h>
#include <suntool/ps_impl.h>
#include <suntool/alert.h>
#include <suntool/frame.h>
#include "sunwindow/sv_malloc.h"
extern char *calloc();
extern char *malloc();
static Es_status ps_commit();
static Es_handle ps_destroy(), ps_scratch_destroy();
static caddr_t ps_get();
static Es_index ps_get_length(), ps_scratch_get_length();
static Es_index ps_get_position(), ps_scratch_get_position();
static Es_index ps_set_position(), ps_scratch_set_position();
static Es_index ps_read(), ps_scratch_read();
static Es_index ps_replace(), ps_scratch_replace();
static int ps_set();
static void make_current_valid();
static Es_index write_header_etc();
static struct es_ops ps_ops = {
ps_commit,
ps_destroy,
ps_get,
ps_get_length,
ps_get_position,
ps_set_position,
ps_read,
ps_replace,
ps_set
};
static int max_transcript_alert_displayed; /* default = 0 */
#define INVALIDATE_CURRENT(private) \
(private)->current = CURRENT_NULL
#define SET_POSITION(private, to) \
INVALIDATE_CURRENT(private); (private)->position = (to)
#define VALID_PIECE_INDEX(private, index) \
((index < (private)->pieces.last_plus_one) && \
(PIECES_IN_TABLE(private)[index].pos != ES_INFINITY))
static char *wrap_msg = "\n\
*** Text is lost because the maximum edit log size has been exceeded. ***\n\n\n";
#ifdef DEBUG
#define MAX_PIECE_LENGTH 100000
#define MAX_LENGTH 4000000
#endif
static Es_handle
ps_NEW(piece_count)
int piece_count;
{
extern ft_object ft_create();
Es_handle esh = NEW(Es_object);
register Piece_table private = NEW(struct piece_table_object);
if (esh == NULL || private == NULL)
goto AllocFailed;
private->magic = PS_MAGIC;
if (piece_count > 0) {
private->pieces = FT_CLIENT_CREATE(piece_count, Piece_object);
if (private->pieces.seq == NULL)
goto AllocFailed;
FT_CLEAR_ALL(private->pieces);
} else
private->pieces.last_plus_one = 0;
esh->data = (caddr_t)private;
esh->ops = &ps_ops;
return(esh);
AllocFailed:
if (private)
free((char *)private);
if (esh)
free((char *)esh);
return((Es_handle)NULL);
}
extern Es_handle
ps_create(client_data, original, scratch)
caddr_t client_data;
Es_handle original, scratch;
{
extern ft_object ft_create();
extern int ft_set();
Es_handle esh = ps_NEW(100);
register Piece_table private;
register Piece pieces;
if (es_set_position(scratch, 0) != 0) {
(void) fprintf(stderr,
"ps_create: cannot reset scratch stream.\n");
return(NULL);
}
if (esh == NULL)
goto AllocFailed;
private = ABS_TO_REP(esh);
SET_POSITION(private, 0);
private->length = (original != ES_NULL) ? es_get_length(original) : 0;
pieces = PIECES_IN_TABLE(private);
if (private->length > 0) {
pieces[0].pos = es_set_position(original, 0);
PS_SET_ORIGINAL_SANDP(pieces[0], pieces[0].pos);
#ifdef notdef
The following fails because it does not match the state after a replace of
everything by nothing. However, it is probably correct should the
end_of_stream condition change to an empty piece at the end.
} else {
pieces[0].pos = 0;
PS_SET_SCRATCH_SANDP(pieces[0], pieces[0].pos);
#endif
}
pieces[0].length = private->length;
private->original = original;
private->scratch = scratch;
private->last_write_plus_one = ES_INFINITY;
private->rec_start = ES_INFINITY;
private->rec_insert = ES_INFINITY;
private->oldest_not_undone_mark = ES_INFINITY;
private->rec_insert_len = 0;
private->client_data = client_data;
private->scratch_max_len = ES_INFINITY;
/* scratch_length need not be valid, but must be < scratch_max_len */
private->scratch_length = 0;
private->scratch_ops = (Es_ops)0;
private->status = ES_SUCCESS;
return(esh);
AllocFailed:
(void) fprintf(stderr, "ps_create: alloc failure.\n");
return(NULL);
}
/* ARGSUSED */
static Es_status
ps_commit(esh)
Es_handle esh;
{
return(ES_SUCCESS);
}
static Es_handle
ps_destroy(esh)
Es_handle esh;
{
register Piece_table private = ABS_TO_REP(esh);
free((char *)esh);
ft_destroy(&private->pieces);
free((char *)private);
return NULL;
}
static Es_handle
ps_scratch_destroy(esh)
Es_handle esh;
{
register Piece_table private = SCRATCH_TO_REP(esh);
free((char *)esh->ops);
esh->ops = private->scratch_ops;
return(es_destroy(esh));
}
static Es_index
ps_get_length(esh)
Es_handle esh;
{
register Piece_table private = ABS_TO_REP(esh);
return (private->length);
}
static Es_index
ps_scratch_get_length(esh)
Es_handle esh;
{
register Piece_table private = SCRATCH_TO_REP(esh);
return (private->scratch_length);
}
static Es_index
ps_get_position(esh)
Es_handle esh;
{
register Piece_table private = ABS_TO_REP(esh);
return(private->position);
}
static Es_index
ps_scratch_get_position(esh)
Es_handle esh;
{
register Piece_table private = SCRATCH_TO_REP(esh);
return(private->scratch_position);
}
static Es_index
ps_set_position(esh, pos)
Es_handle esh;
register Es_index pos;
{
register Piece_table private = ABS_TO_REP(esh);
register Piece pieces = PIECES_IN_TABLE(private);
if (pos > private->length) {
ASSUME(pos == ES_INFINITY || private->parent);
pos = private->length;
} else if (pos < pieces[0].pos) {
pos = pieces[0].pos;
if (pos == ES_INFINITY) /* Checks for empty source. */
pos = 0;
}
ASSUME(0 <= pos && pos <= MAX_LENGTH);
/* Client's often lose track of the position, so check if setting to
* current position to avoid invalidating caches unnecessarily.
*/
if (pos != private->position) {
/* Try to maintain private->current */
if (private->current != CURRENT_NULL) {
if ((pos < pieces[private->current].pos) ||
(pos >= pieces[private->current].pos +
pieces[private->current].length))
INVALIDATE_CURRENT(private);
}
private->position = pos;
}
return (private->position);
}
static Es_index
ps_scratch_set_position(esh, pos)
Es_handle esh;
register Es_index pos;
{
register Piece_table private = SCRATCH_TO_REP(esh);
if (pos > private->scratch_length)
pos = private->scratch_length;
private->scratch_position = pos;
pos = pos % private->scratch_max_len;
pos = private->scratch_ops->set_position(esh, pos);
ASSUME(pos == (private->scratch_position % private->scratch_max_len));
return(private->scratch_position);
}
#ifdef DEBUG
static int
ps_pieces_are_consistent(private)
register Piece_table private;
{
register Piece pieces = PIECES_IN_TABLE(private);
register Es_index pos = pieces[0].pos;
register int current;
ASSUME(pos == 0 || pos == ES_INFINITY || private->parent);
for (current = 0; VALID_PIECE_INDEX(private, current); current++) {
ASSUME(pos == pieces[current].pos);
ASSUME(0 < pieces[current].length || (current == 0 && pos == 0));
ASSUME(pieces[current].length < MAX_PIECE_LENGTH);
pos += pieces[current].length;
ASSUME(pos <= private->length);
ASSUME(PS_SANDP_POS(pieces[current]) < MAX_LENGTH);
}
return(!0);
}
#endif
static Es_index
ps_scratch_read(esh, len, bufp, resultp)
Es_handle esh;
u_int len,
*resultp;
register char *bufp;
{
register Piece_table private = SCRATCH_TO_REP(esh);
register Es_index first_valid, last_plus_one;
Es_index remainder;
long int count_read;
if (!SCRATCH_HAS_WRAPPED(private)) {
private->scratch_position =
private->scratch_ops->read(esh, len, bufp, resultp);
} else {
first_valid = SCRATCH_FIRST_VALID(private);
last_plus_one = private->scratch_position + len;
/*
* scratch stream has wrapped around, so valid "logical" scratch
* indices are [first_valid..scratch_length).
* Watch for:
* a) read of characters that no longer exist, and
* b) read that is "split" around physical scratch end.
* First, look to see if read begins at valid position.
*/
if (private->scratch_position < first_valid) {
/* Invalid start, but may extend into valid positions.
* However, caller does not know that start is invalid; only
* way to communicate this is to read nothing this time.
* Move position to start of valid range (which changes
* private->scratch_position as a side-effect).
*/
(void) es_set_position(esh, first_valid);
*resultp = 0;
goto Return;
}
/* Second, look for "split" read. */
if ((private->scratch_position / private->scratch_max_len) !=
((last_plus_one-1) / private->scratch_max_len)) {
/* Split => read at end of scratch, then at start. */
remainder = private->scratch_max_len -
private->scratch_ops->get_position(esh);
(void) private->scratch_ops->read(esh, remainder, bufp,
&count_read);
(void) private->scratch_ops->set_position(esh, 0);
(void) private->scratch_ops->read(esh, len-count_read,
bufp+count_read, resultp);
*resultp += count_read;
} else {
(void) private->scratch_ops->read(esh, len, bufp, resultp);
}
/* Update the scratch_position, and watch out for read that
* ends exactly at multiple of scratch_max_len, because this
* requires repositioning of physical scratch stream to make
* succeeding calls work properly.
*/
private->scratch_position += *resultp;
if ((private->scratch_position % private->scratch_max_len) ==
0) {
(void) private->scratch_ops->set_position(esh, 0);
}
}
Return:
ASSUME(private->scratch_ops->get_position(esh) ==
(private->scratch_position % private->scratch_max_len));
ASSUME(ps_pieces_are_consistent(private));
return(private->scratch_position);
}
static Es_index
ps_scratch_replace(esh, last_plus_one, count, buf, count_used)
Es_handle esh;
Es_index last_plus_one;
long int count, *count_used;
char *buf;
{
register Piece_table private = SCRATCH_TO_REP(esh);
register Es_index first_valid, max_lpo;
Es_index remainder;
long int count_replaced;
if (last_plus_one > private->scratch_length) {
last_plus_one = private->scratch_length;
}
max_lpo = private->scratch_position + count;
if (last_plus_one > max_lpo) {
max_lpo = last_plus_one;
}
ASSUME(last_plus_one >= private->scratch_position);
if (!SCRATCH_HAS_WRAPPED(private) &&
(max_lpo <= private->scratch_max_len) ) {
private->scratch_position =
private->scratch_ops->replace(esh, last_plus_one, count,
buf, count_used);
private->scratch_length =
private->scratch_ops->get_length(esh);
} else {
first_valid = (SCRATCH_HAS_WRAPPED(private))
? SCRATCH_FIRST_VALID(private) : 0;
*count_used = count;
/*
* Either scratch stream has wrapped around, or it is about to
* wrap around. In either case, the valid "logical"
* scratch indices are [first_valid..scratch_length).
* Bytes that vanish into hole at start of scratch stream are
* treated as used.
* Watch for:
* a) range of characters that no longer exist, and
* b) "split" around physical scratch end.
* First, look to see if replace begins at valid position.
*/
remainder = first_valid - private->scratch_position;
if (remainder > 0) {
/* Invalid start, but may extend into valid positions.
* Move position to start of valid range (which changes
* private->scratch_position as a side-effect).
*/
(void) es_set_position(esh, first_valid);
if (last_plus_one < first_valid) {
/* Entire range to replace is invalid. */
goto Return;
} else if (count > 0) {
/* Discard any new bytes replacing invalid bytes. */
if (count > remainder) {
count -= remainder;
buf += remainder;
} else {
count = 0;
}
}
}
/* Second, look for "split" replace. */
if ((private->scratch_position / private->scratch_max_len) !=
((max_lpo-1) / private->scratch_max_len) ) {
/* Split => replace at end of scratch, then at start.
* NOTE: caller guarantees that count > remainder
*/
remainder = private->scratch_max_len -
private->scratch_ops->get_position(esh);
ASSUME(count > remainder);
(void) private->scratch_ops->replace(
esh,
private->scratch_max_len,
remainder,
buf, &count_replaced);
(void) private->scratch_ops->set_position(esh, 0);
(void) private->scratch_ops->replace(
esh,
count - remainder,
count - remainder,
buf + remainder, &count_replaced);
} else {
/* If here, then overwrite physical scratch after a wrap. */
(void) private->scratch_ops->replace(
esh,
(private->scratch_position %
private->scratch_max_len) + count,
count, buf, &count_replaced);
}
private->scratch_position += count;
if (private->scratch_position > private->scratch_length) {
private->scratch_length = private->scratch_position;
}
}
Return:
ASSUME(private->scratch_ops->get_position(esh) ==
(private->scratch_position % private->scratch_max_len));
return(private->scratch_position);
}
static Piece
split_piece(pieces, current, delta)
ft_handle pieces;
register int current;
register long int delta;
/* Splits the piece_object pieces[current] in two with the second piece, the
* new pieces[current+1], starting at pieces[current].pos+delta.
* Returns a properly cast sequence, as old cached version may be invalidated
* by the call to ft_shift_up.
*/
{
register Piece old, new;
register int is_scratch;
register Es_index source_pos;
ft_shift_up(pieces, current+1, current+2, 10);
/* Can invalidate &pieces.seq[i] */
old = ((Piece)(pieces->seq)) + current;
new = old + 1;
is_scratch = PS_SANDP_SOURCE(old[0]);
source_pos = PS_SANDP_POS(old[0]);
new->pos = old->pos + delta;
source_pos += delta;
new->length = old->length - delta;
old->length = delta;
PS_SET_SANDP(new[0], source_pos, is_scratch);
return((Piece)(pieces->seq));
}
static Es_index
ps_read(esh, len, bufp, resultp)
Es_handle esh;
u_int len,
*resultp;
register char *bufp;
{
#ifdef DEBUG_TRACE
Es_index next, pos;
char temp;
pos = (ABS_TO_REP(esh))->position;
next = ps_debug_read(esh, len, bufp, resultp);
(void) fprintf(stdout,
"ps_read at pos %d of %d chars got %d chars; %s %d ...\n",
pos, len, *resultp, "next read at", next);
#ifdef DEBUG_TRACE_CONTENTS
temp = bufp[*resultp];
bufp[*resultp] = '\0';
(void) fprintf(stdout, "%s\n^^^\n", bufp);
bufp[*resultp] = temp;
#endif
return(next);
}
static Es_index
ps_debug_read(esh, len, bufp, resultp)
Es_handle esh;
u_int len,
*resultp;
register char *bufp;
{
#endif
/*
* "current" must be signed, because it can become -1 when deciding whether
* to combine pieces containing invalid physical scratch indices.
*/
int read_count, save_current;
Es_index next_pos, original_len;
register int current, to_read;
register long int delta;
register Es_index current_pos;
register Es_handle current_esh;
register Piece pieces;
register Piece_table private = ABS_TO_REP(esh);
if (private->length - private->position < len) {
len = private->length - private->position;
}
pieces = PIECES_IN_TABLE(private);
*resultp = 0;
if (private->current == CURRENT_NULL) {
current =
ft_bounding_index(&private->pieces, private->position);
} else
current = private->current;
while (VALID_PIECE_INDEX(private, current) && len > 0) {
delta = private->position - pieces[current].pos;
ASSERT(*resultp == 0 || delta == 0);
current_esh = (PS_SANDP_SOURCE(pieces[current]) ?
private->scratch :
private->original);
current_pos = PS_SANDP_POS(pieces[current]) + delta;
next_pos = es_set_position(current_esh, current_pos);
ASSERT(next_pos == current_pos);
to_read = pieces[current].length - delta;
if (to_read > len)
to_read = len;
next_pos = es_read(current_esh, to_read, bufp, &read_count);
/* BUG ALERT! If we ever support entities that are not bytes,
* the following addition must have a
* "* es_get(current_esh, ES_SIZE_OF_ENTITY)"
*/
bufp += read_count;
len -= read_count;
*resultp += read_count;
private->position += read_count; /* zaps private->current */
if (read_count < to_read) {
if (current_esh == private->original) {
/* The original entity stream has holes in it,
* and the initialization assumed it was contiguous,
* so the pieces and length must be corrected.
*/
pieces = split_piece(
&private->pieces, current, delta+read_count);
current++;
/* Compute the gap size */
delta = next_pos - (current_pos + read_count);
ASSERT(pieces[current].length > delta);
pieces[current].length -= delta;
private->length -= delta;
PS_SET_ORIGINAL_SANDP(pieces[current], next_pos);
} else {
/* The scratch entity stream has wrapped around, making a
* hole from [0..scratch_first_valid).
*/
ASSUME(SCRATCH_HAS_WRAPPED(private) ||
(private->parent &&
SCRATCH_HAS_WRAPPED(ABS_TO_REP(private->parent)) ));
/* Caller needs to be told where next successful read
* is, so search for piece containing valid scratch
* indices (WARNING: there may not be one).
*/
for (save_current = current,
current_pos = private->position;
VALID_PIECE_INDEX(private, current);
current++) {
ASSERT(PS_SANDP_SOURCE(pieces[current]));
delta = PS_SANDP_POS(pieces[current]);
if (delta >= next_pos) {
/* next_pos not referenced by pieces => go to start
* this piece, which is first beyond next_pos
*/
next_pos = delta;
} else if (next_pos >= delta+pieces[current].length) {
continue;
}
private->position =
(next_pos - delta) + pieces[current].pos;
/* Allow uniform handling of current below. */
current++;
break;
}
if (current_pos == private->position)
private->position = es_get_length(esh);
/* Although the pieces are correct it speeds up later
* reads if "runs of now invalid scratch references"
* are combined; however, only completely invalid
* pieces can be combined (else the record headers will
* be incorrectly included as part of the visible text).
* -2 backs over terminating and partially valid pieces.
*/
current -= 2;
if (save_current < current) {
delta = PS_LAST_PLUS_ONE(pieces[current]);
pieces[save_current].length =
delta - pieces[save_current].pos;
ft_shift_out(&private->pieces,
save_current+1, current+1);
}
/* A read at the beginning of the scratch stream which
* tries to read out of the start of the hole should
* give the client (an appropriate part of) wrap_msg.
* However, don't do this until AFTER finding out where
* next valid position is, otherwise can return too
* much text.
*/
for (current = 0, original_len = 0;
VALID_PIECE_INDEX(private, current);
current++) {
if (PS_SANDP_SOURCE(pieces[current]))
break;
original_len = PS_LAST_PLUS_ONE(pieces[current]);
}
current = private->pieces.last_plus_one;
INVALIDATE_CURRENT(private);
ASSUME(original_len <= current_pos);
read_count = strlen(wrap_msg);
if (*resultp == 0 &&
current_pos < original_len + read_count) {
FILE * console_fd;
if (private->position < original_len + read_count)
read_count = private->position - original_len;
read_count -= current_pos - original_len;
if (len < read_count)
read_count = len;
bcopy(wrap_msg+current_pos, bufp, read_count);
*resultp = read_count;
/* tell user that they are going to wrap */
/* Use the same flag for console error message */
if (max_transcript_alert_displayed != 1) {
console_fd = fopen("/dev/console", "a");
fprintf(console_fd, "The text transcript in a Commands window filled up, and the oldest saved text will be erased from the top as more is typed at the bottom.\n");
fflush(console_fd);
max_transcript_alert_displayed = 1;
fclose(console_fd);
}
#ifdef notdef
if (max_transcript_alert_displayed != 1) {
Event alert_event;
(void) alert_prompt(
(Frame)0,
&alert_event,
ALERT_MESSAGE_STRINGS,
"Text has been lost in a cmdtool transcript because",
"the maximum edit log size has been exceeded.",
0,
ALERT_BUTTON_YES, "Continue",
ALERT_TRIGGER, ACTION_STOP,
/* with trigger, yes or no bring it down */
0);
max_transcript_alert_displayed = 1;
}
#endif
}
}
/* All of the above code is free and easy with local
* variables because it expects to exit the loop here, so
* it will need to be rewritten if this break is removed!
*/
break;
}
current++;
}
if (VALID_PIECE_INDEX(private, current)) {
private->current = current;
if (pieces[current].pos > private->position)
private->current--;
/* Short read advances current anyway, so undo the advance. */
} else
INVALIDATE_CURRENT(private);
ASSUME(ps_pieces_are_consistent(private));
return (private->position);
}
/* The routines ps_replace, ps_insert_pieces, and ps_undo_to_mark all perform
* similar functions and a fix to one needs to be reflected in the others.
*/
static Es_index
ps_replace(esh, last_plus_one, count, buf, count_used)
Es_handle esh;
Es_index last_plus_one;
long int count, *count_used;
char *buf;
{
#ifdef DEBUG_TRACE
Es_index next, pos;
char temp;
pos = (ABS_TO_REP(esh))->position;
next = ps_debug_replace(esh, last_plus_one, count, buf, count_used);
(void) fprintf(stdout,
"ps_replace [%d..%d) by %d chars (used %d); next pos %d ...\n",
pos, last_plus_one, count, *count_used, "next read at", next);
if (buf) {
temp = buf[count];
buf[count] = '\0';
(void) fprintf(stdout, "%s\n^^^\n", buf);
buf[count] = temp;
}
return(next);
}
static Es_index
ps_debug_replace(esh, last_plus_one, count, buf, count_used)
Es_handle esh;
Es_index last_plus_one;
long int count, *count_used;
char *buf;
{
#endif
/* Assume that the piece stream looks like:
* O1O S1S O2O S2S S3S O3O O4O S4S
* where XnX means n-th chunk in stream X, and X2X may actually
* occur earlier in stream X than X1X.
* The possible cases are:
* 1) Replace an empty region, with subcases:
* 1a) Region is at end of previous replace, hence it can be treated
* as an extension of the previous replace, and the associated
* scratch piece can simply be lengthened. (S4S)
* 1b) Otherwise, a new piece must be created, and the piece that
* contains the empty region must be split (XnX -> XnX S5S XmX),
* unless the empty region is at the beginning of that piece
* (XnX -> S5S XnX).
* 2) Replace a region completely within one piece:
* 2a) If within latest scratch region, (1a) applies.
* 2b) If the region exactly matches the piece, re-cycle the piece to
* point at the new contents.
* 2c) Otherwise, (1b) applies.
* 3) Replace a region spanning multiple pieces.
* 3a) For partially enclosed pieces, (1) applies.
* 3b) For completely enclosed pieces, delete them all, except
* possibly one to use as in (2b) if (3a) does not occur.
*
* WARNING! Changes to the pieces can only be made AFTER calls to
* es_replace(scratch, ...) succeed, unless those changes do not
* break the assertions about the pieces OR are backed out in case
* of es_replace() failing.
*/
Es_index scratch_length;
Es_index es_temp, new_rec_insert;
long int long_temp;
int delete_pieces_length, replace_used;
register int current, end_index;
register long int delta; /* Has 2 meanings! */
register Es_handle scratch;
register Piece pieces;
register Piece_table private = ABS_TO_REP(esh);
*count_used = 0;
if (buf == NULL && count != 0) {
private->status = ES_INVALID_ARGUMENTS;
return(ES_CANNOT_SET);
}
if (private->parent != NULL) {
private->status = ES_INVALID_HANDLE;
return(ES_CANNOT_SET);
}
scratch = private->scratch;
scratch_length = es_set_position(scratch, ES_INFINITY);
new_rec_insert = ES_INFINITY; /* => extending current */
if (last_plus_one > private->length) {
last_plus_one = private->length;
}
ASSUME(last_plus_one >= private->position);
pieces = PIECES_IN_TABLE(private);
if (private->length == 0) {
/* Special case occurring after everything replaced by nothing. */
ASSUME(pieces[0].pos == ES_INFINITY);
if (count == 0) {
/* Nothing replaced by nothing => leave well enough alone! */
return(private->position);
}
pieces[current = 0].pos = 0;
goto Append_Only;
}
delta = get_current_offset(private);
current = private->current;
if (last_plus_one > private->position) {
/* Replace a NON-empty region */
if (delta != 0) {
/* Split the current piece at the insert point. */
pieces = split_piece(&private->pieces, current, delta);
current++;
}
if (last_plus_one > PS_LAST_PLUS_ONE(pieces[current])) {
/* Replace region spanning multiple pieces */
end_index =
ft_bounding_index(&private->pieces, last_plus_one-1);
/* -1 ensures that pieces[end_index] < last_plus_one,
* preventing creation of a 0-length piece below.
*/
ASSERT(VALID_PIECE_INDEX(private, end_index));
} else {
/* Replace region within a single piece */
end_index = current;
}
if (last_plus_one < PS_LAST_PLUS_ONE(pieces[end_index])) {
/* Split the end piece at the last_plus_one point */
pieces = split_piece(&private->pieces, end_index,
last_plus_one-pieces[end_index].pos);
}
/* Replace region now exactly equals [current..end_index] pieces.
* Make sure all es_replace(scratch, ...) succeed before
* modifying private->... (including pieces) any further.
*/
new_rec_insert =
write_header_etc(scratch, private, last_plus_one,
(long)count, buf, count_used,
&es_temp, &delete_pieces_length,
current, end_index+1);
if (new_rec_insert == ES_CANNOT_SET) {
goto Error_Return;
}
if (count == 0) {
current--; /* Make ft_shift_out & ft_add_delta work */
}
/* Recycle current piece, so don't shift it out */
ft_shift_out(&private->pieces, current+1, end_index+1);
/* Meaning 2: total change to length */
delta = count - delete_pieces_length;
} else if (count == 0) {
/* Empty region replaced by nothing => leave well enough alone!
* Not catching this case creates an extra 0-length piece.
*/
return(private->position);
} else {
/* Replace an empty region */
int at_end_of_stream = PS_IS_AT_END(private, delta, current);
if (private->position == private->last_write_plus_one) {
es_temp = es_replace(scratch, ES_INFINITY,
count, buf, count_used);
if (es_temp == ES_CANNOT_SET) {
goto Error_Return;
}
ASSUME(count == *count_used);
if (private->rec_insert_len == 0) {
/* Last replace was a delete, so no scratch piece exists */
/* Split the current piece at the insert point */
pieces = split_piece(&private->pieces, current, delta);
if (delta != 0) {
ASSUME(at_end_of_stream);
current++;
delta = 0;
}
PS_SET_SCRATCH_SANDP(pieces[current],
private->rec_insert+sizeof(long_temp));
} else if (at_end_of_stream) {
/* Last replace was at end of stream => don't back up */
} else {
ASSERT(delta == 0 && current > 0);
current--;
delta = private->position - pieces[current].pos;
}
ASSERT(delta == pieces[current].length);
delta = count; /* Meaning 2: total change to length */
private->rec_insert_len += delta;
pieces[current].length += delta;
/* Correct the insert length (this is very inefficient) */
long_temp = private->rec_insert_len;
es_temp = es_set_position(scratch, private->rec_insert);
ASSERT(es_temp == private->rec_insert);
es_temp = es_replace(scratch,
private->rec_insert+sizeof(long_temp),
sizeof(long_temp), (char *)&long_temp,
&replace_used);
} else {
if (delta != 0) {
/* Split the current piece at the insert point */
pieces = split_piece(&private->pieces, current, delta);
current++;
if (at_end_of_stream) {
/* Append at the very end of the stream will create
* a zero length piece which is unnecessary, so we
* detect this case and recycle the piece.
*/
goto Append_Only;
}
}
/* Handle the delta == 0 case. Create new piece */
pieces = split_piece(&private->pieces, current, 0L);
Append_Only:
/* Make sure all es_replace(scratch, ...) succeed before
* modifying private->... (including pieces) any further.
*/
new_rec_insert =
write_header_etc(scratch, private, last_plus_one, count,
buf, count_used, &es_temp, (int *)0,
-1, -1);
if (new_rec_insert == ES_CANNOT_SET) {
/* Reverse all damaging changes to pieces */
if (private->length == 0) {
pieces[0].pos = ES_INFINITY;
} else if (pieces[current].length == 0) {
ft_shift_out(&private->pieces, current, current+1);
}
goto Error_Return;
}
delta = count; /* Meaning 2: total change to length */
}
}
/* Update (if necessary) the fields tracking the insert record.
* Also fix up the associated piece fields.
*/
if (new_rec_insert != ES_INFINITY) {
private->rec_insert = new_rec_insert;
private->rec_insert_len = count;
private->rec_start = scratch_length;
if (private->oldest_not_undone_mark == ES_INFINITY)
private->oldest_not_undone_mark = scratch_length;
ASSUME(count == *count_used);
if (count != 0) {
pieces[current].length = count;
ASSERT(es_temp == private->rec_insert+sizeof(long_temp));
PS_SET_SCRATCH_SANDP(pieces[current], es_temp);
}
}
/* Adjust position, etc. to reflect the overall replace */
ft_add_delta(private->pieces, current+1, delta);
private->length += delta;
SET_POSITION(private, private->position + count);
private->last_write_plus_one = private->position;
ASSUME(0 <= private->position && private->position <= MAX_LENGTH);
ASSUME(ps_pieces_are_consistent(private));
return(private->position);
Error_Return:
private->status = (Es_status)es_get(scratch, ES_STATUS);
/* Copy scratch status first in case attempt to "back out"
* failed es_replace's modify the status.
*/
(void) es_set_position(scratch, scratch_length);
(void) es_replace(scratch, ES_INFINITY, 0, NULL, count_used);
INVALIDATE_CURRENT(private);
ASSUME(ps_pieces_are_consistent(private));
return(ES_CANNOT_SET);
}
static Es_index
write_record_header(esh, private, last_plus_one, dp_count)
Es_handle esh;
register Piece_table private;
Es_index last_plus_one;
int dp_count;
{
struct piece_record_header r_header;
register Es_index result;
int replace_used;
r_header.pos_prev_rec = private->rec_start;
r_header.flags = 0;
r_header.start = private->position;
r_header.stop_plus_one = last_plus_one;
r_header.dp_count = dp_count;
result = es_replace(esh, ES_INFINITY,
sizeof(r_header), (char *)&r_header,
&replace_used);
return(result);
}
static int
record_deleted_pieces(esh, private, pieces, first, last_plus_one, next)
Es_handle esh;
Piece_table private;
Piece pieces;
int first, last_plus_one;
Es_index *next;
{
struct deleted_piece d_header;
int dummy;
register Piece current, stop_plus_one;
register int result = 0;
register Es_index replace_result;
stop_plus_one = &pieces[last_plus_one];
for (current = &pieces[first]; current < stop_plus_one; current++) {
d_header.source_and_pos = current->source_and_pos;
result += (d_header.length = current->length);
replace_result =
es_replace(esh, ES_INFINITY,
sizeof(d_header), (char *)&d_header, &dummy);
if (replace_result == ES_CANNOT_SET)
break;
}
*next = replace_result;
return(result);
}
/* Returns the new value for private->rec_insert */
static Es_index
write_header_etc(esh, private, last_plus_one, count, buf, count_used,
contents_start,
deleted_pieces_length, first_deleted, last_plus_one_deleted)
register Es_handle esh;
register Piece_table private;
Es_index last_plus_one;
long int count;
long int *count_used;
char *buf;
Es_index *contents_start;
int *deleted_pieces_length;
int first_deleted, last_plus_one_deleted;
{
register Es_index result;
Es_index es_temp;
int replace_used;
/* Write the record header (and possibly) deleted pieces. */
result = write_record_header(esh, private, last_plus_one,
last_plus_one_deleted-first_deleted);
if (result == ES_CANNOT_SET)
return(ES_CANNOT_SET);
if (first_deleted < last_plus_one_deleted) {
*deleted_pieces_length =
record_deleted_pieces(esh, private, PIECES_IN_TABLE(private),
first_deleted, last_plus_one_deleted,
&es_temp);
if (es_temp == ES_CANNOT_SET)
return(ES_CANNOT_SET);
result = es_temp;
}
*contents_start =
es_replace(esh, ES_INFINITY, sizeof(count),
(char *)&count, &replace_used);
if (*contents_start == ES_CANNOT_SET)
return(ES_CANNOT_SET);
/* Do the insert */
if (count != 0) {
es_temp = es_replace(esh, ES_INFINITY, count, buf, count_used);
if (es_temp == ES_CANNOT_SET)
return(ES_CANNOT_SET);
}
return(result);
}
static Es_handle
ps_pieces_for_span(esh, first, last_plus_one, to_recycle)
Es_handle esh;
Es_index first, last_plus_one;
Es_handle to_recycle;
{
register Piece_table private = ABS_TO_REP(esh);
register Piece result_pieces;
register int is_scratch;
register Es_index delta, source_pos;
int first_index, last_index;
Es_handle result = (Es_handle)0;
Piece_table r_private;
if (last_plus_one > private->length)
last_plus_one = private->length;
if (first >= last_plus_one) {
goto Bad_Args;
}
ASSUME(allock());
first_index = ft_bounding_index(&private->pieces, first);
last_index = ft_bounding_index(&private->pieces, last_plus_one-1);
if (to_recycle) {
result = to_recycle;
r_private = ABS_TO_REP(result);
ASSUME(r_private->magic == PS_MAGIC && r_private->parent == esh);
if (r_private->pieces.last_plus_one <= (last_index-first_index)) {
ft_destroy(&r_private->pieces); /* Zeros .last_plus_one */
}
} else {
result = ps_NEW(0);
if (result == (Es_handle)0)
goto Out_Of_Memory;
r_private = ABS_TO_REP(result);
r_private->parent = esh;
r_private->original = private->original;
r_private->scratch = private->scratch;
r_private->last_write_plus_one = r_private->rec_insert =
r_private->rec_start = ES_CANNOT_SET;
r_private->rec_insert_len = -1;
}
if (r_private->pieces.last_plus_one == 0) {
r_private->pieces =
FT_CLIENT_CREATE(last_index-first_index+1, Piece_object);
if (r_private->pieces.seq == (Es_index *)0)
goto Out_Of_Memory;
}
FT_CLEAR_ALL(r_private->pieces);
copy_pieces(&r_private->pieces, 0, &private->pieces,
first_index, last_index+1);
/*
* Fix up the end pieces.
*/
result_pieces = &PIECES_IN_TABLE(r_private)[last_index-first_index];
result_pieces->length = last_plus_one - result_pieces->pos;
result_pieces = &PIECES_IN_TABLE(r_private)[0];
delta = first - result_pieces->pos;
if (delta != 0) {
result_pieces->pos = first;
is_scratch = PS_SANDP_SOURCE(*result_pieces);
source_pos = PS_SANDP_POS(*result_pieces);
source_pos += delta;
result_pieces->length -= delta;
PS_SET_SANDP(*result_pieces, source_pos, is_scratch);
}
SET_POSITION(r_private, first);
r_private->length = last_plus_one;
ASSUME(allock());
return(result);
Out_Of_Memory:
if (result) {
es_destroy(result);
result = (Es_handle)0;
}
Bad_Args:
if (to_recycle)
es_destroy(to_recycle);
return(result);
}
static
copy_pieces(to_table, to_index, from_table, first, last_plus_one)
register ft_handle to_table, from_table;
int to_index, first, last_plus_one;
{
register int sizeof_element = from_table->sizeof_element;
ASSERT(to_table->sizeof_element == sizeof_element);
bcopy((char *)from_table->seq + first*sizeof_element,
(char *)to_table->seq + to_index*sizeof_element,
(last_plus_one-first)*sizeof_element);
}
static int
get_current_offset(private)
register Piece_table private;
{
register Piece current;
register int result;
if (private->current == CURRENT_NULL)
private->current =
ft_bounding_index(&private->pieces, private->position);
ASSERT(VALID_PIECE_INDEX(private, private->current));
current = &PIECES_IN_TABLE(private)[private->current];
result = private->position - current->pos;
ASSUME(result < current->length ||
PS_IS_AT_END(private, result, private->current) );
return(result);
}
static void
ps_insert_pieces(esh, to_insert)
Es_handle esh, to_insert;
/*
* Much of this routine is stolen from ps_replace.
* A special convention established by this routine is that if the scratch
* stream has a replace record with start == stop_plus_one and a non-zero
* deleted piece count, then it is a result of inserting pieces, rather than
* characters.
*/
{
ft_handle rep = (ft_handle)
&(ABS_TO_REP(to_insert))->pieces;
long int long_temp;
int at_end_of_stream, replace_used;
long int delta;
int save_last_plus_one;
Es_index scratch_length, es_temp;
register Piece pieces;
register int current, last_valid;
register Piece_table private = ABS_TO_REP(esh);
register Es_handle scratch = private->scratch;
ASSERT(rep != FT_NULL);
last_valid = ft_bounding_index(rep, ES_INFINITY-1);
ASSERT(last_valid != rep->last_plus_one);
/* Prepare the insertion area. */
pieces = PIECES_IN_TABLE(private);
if (private->length == 0 && pieces[0].pos == ES_INFINITY) {
/* Special case that occurs if replaced everything by nothing. */
current = 0;
delta = 0;
at_end_of_stream = 1;
pieces[0].pos = 0;
pieces[0].length = 0;
PS_SET_SCRATCH_SANDP(pieces[0], 0);
} else {
INVALIDATE_CURRENT(private);
delta = get_current_offset(private);
current = private->current;
if (delta == 0) {
at_end_of_stream = 0;
} else {
at_end_of_stream = (delta == pieces[current].length);
/*
* Split the current piece at the insert point.
* This creates a zero length piece iff at_end_of_stream.
*/
pieces = split_piece(&private->pieces, current, delta);
current++;
}
}
#ifdef DEBUG
long_temp = pieces[current].pos;
#endif
/* Do the insert and associated bookkeeping */
ft_shift_up(&private->pieces, current, current+last_valid+1,
last_valid+1);
pieces = PIECES_IN_TABLE(private);
copy_pieces(&private->pieces, current, rep, 0, last_valid+1);
ASSERT(allock());
/* Offset inserted pieces so they match the insertion point.
* BUG ALERT: need version of ft_add_delta that takes stop index,
* but for now, monkey with the piece table itself.
*/
save_last_plus_one = private->pieces.last_plus_one;
private->pieces.last_plus_one = current+last_valid+1;
ft_add_delta(private->pieces, current,
private->position - rep->seq[0]);
private->pieces.last_plus_one = save_last_plus_one;
ASSERT(long_temp == pieces[current+last_valid+1].pos);
/* Write header info to scratch. */
scratch_length = es_set_position(scratch, ES_INFINITY);
es_temp = write_record_header(scratch, private, private->position,
last_valid+1);
if (es_temp != ES_CANNOT_SET) {
/* Can modify private->... iff es_replace succeeds */
private->rec_insert = es_temp;
private->rec_start = scratch_length;
if (private->oldest_not_undone_mark == ES_INFINITY)
private->oldest_not_undone_mark = scratch_length;
}
delta = record_deleted_pieces(
scratch, private, pieces,
current, current+last_valid+1,
&private->rec_insert);
long_temp = 0;
(void) es_replace(scratch, ES_INFINITY,
sizeof(long_temp), (char *)&long_temp,
&replace_used);
ASSERT(allock());
/* Adjust position, etc. to reflect the overall replace */
if (at_end_of_stream) {
/* Flush the extraneous zero length piece we created. */
ASSERT(pieces[current+last_valid+1].length == 0);
pieces[current+last_valid+1].pos = ES_INFINITY;
} else {
ft_add_delta(private->pieces, current+last_valid+1, delta);
}
private->last_write_plus_one = ES_INFINITY;
private->length += delta;
SET_POSITION(private, private->position + delta);
}
static Es_index
adjust_pos_after_edit(pos, start, delta)
register Es_index pos, start, delta;
{
if (delta > 0)
return((start <= pos) ? pos+delta : pos);
else if (start < pos)
return((start-delta < pos) ? pos+delta : start);
else
return(pos);
}
static void
ps_undo_to_mark(esh, mark, notify_proc, notify_data)
Es_handle esh;
Es_index mark;
int (*notify_proc)();
caddr_t notify_data;
/*
* The notify_proc gets called with the notify_data, the start of the affected
* range, and the delta. Thus a negative delta means [start..start-delta)
* contains the affected positions, while a positive delta indicates an
* insertion of entities to fill the range [start..start+delta).
*/
{
register Piece_table private = ABS_TO_REP(esh);
register Es_handle scratch = private->scratch;
register Piece pieces, this_piece;
register Es_index current_pos, scratch_pos,
save_pos = private->position;
Es_index delta,
mark_pos = mark;
struct piece_record_header r_header;
struct deleted_piece d_header;
int current, i, read;
long int insert_len;
if (es_get_length(scratch) == 0)
return;
/* For a bounded scratch stream, the mark_pos may now be invalid and
* need to be adjusted. The new value need not be exactly at a record
* header (luckily, else all of the record headers would have to be
* read twice).
*/
if (SCRATCH_HAS_WRAPPED(private) &&
mark_pos < SCRATCH_FIRST_VALID(private)) {
mark_pos = SCRATCH_FIRST_VALID(private);
}
/* Read back the information from the scratch source and undo it */
for (; (private->rec_start != ES_INFINITY) &&
(private->rec_start >= mark_pos);
private->rec_start = r_header.pos_prev_rec) {
(void) es_set_position(scratch, private->rec_start);
(void) es_read(scratch, sizeof(r_header),
(char *)&r_header, &read);
ASSUME(read == sizeof(r_header));
/* Check to see if piece is flagged as already undone.
* If not, make sure it is flagged now.
*/
if (r_header.flags & PS_ALREADY_UNDONE)
continue;
r_header.flags |= PS_ALREADY_UNDONE;
(void) es_set_position(scratch, private->rec_start);
(void) es_replace(scratch, private->rec_start+sizeof(r_header),
sizeof(r_header), (char *)&r_header, &read);
ASSUME(read == sizeof(r_header));
if (private->oldest_not_undone_mark == private->rec_start)
private->oldest_not_undone_mark = ES_INFINITY;
current_pos = r_header.start;
SET_POSITION(private, current_pos);
if (private->length == 0 &&
PIECES_IN_TABLE(private)[0].pos == ES_INFINITY) {
/* Special case occurs when nothing replaced everything.
* BUG ALERT: later on, we depend on the [0].pos being left
* as ES_INFINITY, else the ft_shift_up corrupts the
* piece table.
*/
current = 0;
delta = 0;
} else {
delta = get_current_offset(private);
current = private->current;
}
if ((r_header.start == r_header.stop_plus_one) &&
(r_header.dp_count != 0)) {
/* Remove the inserted pieces.
* Since ps_replace does NOT coalesce pieces, a single
* inserted piece may be turned into multiple pieces via
* sequences of "type-in edit-chars-deleting type-in", and
* UNDO of those sequences also does NOT coalesce the pieces,
* so when we go to UNDO the original insert we must not rely
* on a one-to-one mapping of the pieces.
*/
int piece_length, piece_count = 0;
ASSERT(delta == 0);
pieces = PIECES_IN_TABLE(private);
this_piece = &pieces[current];
for (i = r_header.dp_count; i > 0; i--) {
(void) es_read(scratch, sizeof(d_header),
(char *)&d_header, &read);
ASSERT(this_piece->pos == current_pos-delta);
ASSERT(this_piece->source_and_pos == d_header.source_and_pos);
delta -= d_header.length;
for (piece_length = d_header.length; piece_length > 0;
piece_count++) {
ASSERT(this_piece->length <= piece_length);
piece_length -= this_piece->length;
this_piece++;
}
}
ft_shift_out(&private->pieces, current,
current+piece_count);
ft_add_delta(private->pieces, current, delta);
save_pos = adjust_pos_after_edit(save_pos, current_pos, delta);
private->length += delta;
if (notify_proc) {
scratch_pos = es_get_position(scratch);
notify_proc(notify_data, current_pos, delta);
(void) es_set_position(scratch, scratch_pos);
}
} else {
/* Put back the deleted pieces */
if (delta == 0) {
ft_add_delta(private->pieces, current,
(long)(r_header.stop_plus_one-r_header.start));
} else {
ASSERT(PS_IS_AT_END(private, delta, current));
current++;
}
ft_shift_up(&private->pieces, current,
(int)(current+r_header.dp_count),
(int)r_header.dp_count);
pieces = PIECES_IN_TABLE(private);
this_piece = &pieces[current];
delta = r_header.stop_plus_one-current_pos;
save_pos = adjust_pos_after_edit(save_pos, current_pos, delta);
for (i = 0; i < r_header.dp_count; i++, this_piece++) {
(void) es_read(scratch, sizeof(d_header),
(char *)&d_header, &read);
this_piece->pos = current_pos;
this_piece->length = d_header.length;
this_piece->source_and_pos = d_header.source_and_pos;
current_pos += d_header.length;
}
ASSERT(current_pos == r_header.stop_plus_one);
if (delta != 0) { /* 0 iff no deleted pieces. */
private->length += delta;
if (notify_proc) {
scratch_pos = es_get_position(scratch);
notify_proc(notify_data, r_header.start, delta);
(void) es_set_position(scratch, scratch_pos);
}
}
}
(void) es_read(scratch, sizeof(insert_len),
(char *)&insert_len, &read);
if (insert_len > 0) {
/*
* Remove the inserted text.
* Note that the user sequence: type-in edit-char type-in ...
* can cause this insert to span multiple pieces in the
* piece table.
*/
current += r_header.dp_count;
this_piece = &pieces[current];
for (delta = 0, i = 0; delta < insert_len;
delta += this_piece->length, this_piece++) {
ASSERT(this_piece->pos == current_pos+delta);
ASSERT(this_piece->length <= insert_len-delta);
i++;
}
ft_shift_out(&private->pieces, current, current+i);
ft_add_delta(private->pieces, current, -insert_len);
save_pos =
adjust_pos_after_edit(save_pos, current_pos, -insert_len);
private->length -= insert_len;
if (notify_proc)
notify_proc(notify_data, current_pos, -insert_len);
}
ASSUME(ps_pieces_are_consistent(private));
}
(void) es_set_position(scratch, ES_INFINITY);
SET_POSITION(private, save_pos);
private->last_write_plus_one = ES_INFINITY;
}
static caddr_t
ps_get(esh, attribute, va_alist)
Es_handle esh;
Es_attribute attribute;
va_dcl
{
register Piece_table private = ABS_TO_REP(esh);
Es_index first, last_plus_one;
Es_handle pieces_for_span, to_recycle;
va_list args;
if ((private->magic != PS_MAGIC) && (attribute != ES_TYPE))
return((caddr_t)0);
switch (attribute) {
case ES_CLIENT_DATA:
return(private->client_data);
case ES_UNDO_MARK:
private->last_write_plus_one = ES_INFINITY;
/* +1 below is because 0 == ES_NULL_UNDO_MARK */
return((caddr_t)(es_get_length(private->scratch)+1));
case ES_HANDLE_FOR_SPAN:
va_start(args);
#ifdef lint
first = (args ? 0 : 0);
last_plus_one = 0;
to_recycle = 0;
#else
first = va_arg(args, Es_index);
last_plus_one = va_arg(args, Es_index);
to_recycle = va_arg(args, Es_handle);
#endif
pieces_for_span =
ps_pieces_for_span(esh, first, last_plus_one, to_recycle);
va_end(args);
return((caddr_t)pieces_for_span);
case ES_HAS_EDITS:
return((caddr_t)(private->oldest_not_undone_mark != ES_INFINITY));
case ES_PS_ORIGINAL:
return((caddr_t)(private->original));
case ES_PS_SCRATCH:
return((caddr_t)(private->scratch));
case ES_PS_SCRATCH_MAX_LEN:
return((caddr_t)(private->scratch_max_len));
case ES_STATUS:
return((caddr_t)(private->status));
case ES_SIZE_OF_ENTITY:
return(es_get(private->original, ES_SIZE_OF_ENTITY));
case ES_TYPE:
return((caddr_t)ES_TYPE_PIECE);
default:
return(0);
}
}
static int
ps_set(esh, attrs)
Es_handle esh;
caddr_t *attrs;
{
register Piece_table private = ABS_TO_REP(esh);
int (*notify_proc)() = (int (*)())0;
caddr_t notify_data = 0;
Es_index undo_mark;
Es_index first;
Es_handle to_recycle;
Es_status status_dummy = ES_SUCCESS;
register Es_status *status;
status = &status_dummy;
if (private->magic != PS_MAGIC)
*status = ES_INVALID_TYPE;
for (; *attrs && (*status == ES_SUCCESS); attrs = attr_next(attrs)) {
switch ((Es_attribute)*attrs) {
case ES_CLIENT_DATA:
private->client_data = attrs[1];
break;
case ES_HANDLE_TO_INSERT:
to_recycle = (Es_handle)LINT_CAST(attrs[1]);
if (private->scratch_max_len == ES_INFINITY) {
ps_insert_pieces(esh, to_recycle);
} else {
/* When scratch is bounded, copy contents, not pieces. */
*status = es_copy(to_recycle, esh, FALSE);
}
break;
case ES_PS_ORIGINAL:
/* Caller should destroy the old private->original iff
* return value is ES_SUCCESS, allowing for caller to
* recover in case of errors.
*/
to_recycle = (Es_handle)LINT_CAST(attrs[1]);
first = es_get_position(private->original);
if (to_recycle == ES_NULL) {
*status = ES_INVALID_HANDLE;
} else if (es_get_length(private->original) !=
es_get_length(to_recycle)) {
*status = ES_INCONSISTENT_LENGTH;
} else if (first != es_set_position(to_recycle, first)) {
*status = ES_INCONSISTENT_POS;
} else {
private->original = to_recycle;
}
break;
case ES_PS_SCRATCH_MAX_LEN:
first = (Es_index)LINT_CAST(attrs[1]);
if (first < SCRATCH_MIN_LEN ||
first < es_get_length(private->scratch)) {
*status = ES_INCONSISTENT_LENGTH;
} else if (first >= ES_INFINITY) {
if (private->scratch_max_len != ES_INFINITY) {
*status = ES_INCONSISTENT_LENGTH;
}
} else {
if (private->scratch_max_len == ES_INFINITY) {
es_set(private->scratch, ES_CLIENT_DATA, esh, 0);
private->scratch_max_len = first;
private->scratch_length =
es_get_length(private->scratch);
private->scratch_position =
es_get_position(private->scratch);
/* Modify the scratch ops vector. */
private->scratch_ops = private->scratch->ops;
private->scratch->ops =
(Es_ops)sv_malloc(sizeof(struct es_ops));
*private->scratch->ops = *private->scratch_ops;
private->scratch->ops->destroy = ps_scratch_destroy;
private->scratch->ops->get_length =
ps_scratch_get_length;
private->scratch->ops->get_position =
ps_scratch_get_position;
private->scratch->ops->set_position =
ps_scratch_set_position;
private->scratch->ops->read = ps_scratch_read;
private->scratch->ops->replace = ps_scratch_replace;
}
}
break;
case ES_STATUS:
private->status = (Es_status)LINT_CAST(attrs[1]);
break;
case ES_STATUS_PTR:
status = (Es_status *)LINT_CAST(attrs[1]);
*status = status_dummy;
break;
case ES_UNDO_MARK:
/* -1 below is because 0 == ES_NULL_UNDO_MARK */
undo_mark = ((Es_index)LINT_CAST(attrs[1]))-1;
ps_undo_to_mark(esh, undo_mark, notify_proc, notify_data);
break;
case ES_UNDO_NOTIFY_PAIR:
notify_proc = (int (*)())LINT_CAST(attrs[1]);
notify_data = attrs[2];
break;
default:
break;
}
}
return((*status == ES_SUCCESS));
}
Reference in New Issue View Git Blame Copy Permalink