#ifndef lint #ifdef sccs static char sccsid[] = "@(#)ps_impl.c 20.41 93/06/28"; #endif #endif /* * (c) Copyright 1989 Sun Microsystems, Inc. Sun design patents * pending in the U.S. and foreign countries. See LEGAL NOTICE * file for terms of the license. */ /* * 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 #include #include #include #include #include #include #include #include #ifdef SVR4 #include #endif /* SVR4 */ static Es_status ps_commit(); static Es_handle ps_destroy(), ps_scratch_destroy(); 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 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; { Pkg_private 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); } Pkg_private Es_handle ps_create(client_data, original, scratch) Xv_opaque client_data; Es_handle original, scratch; { Pkg_private ft_object ft_create(); Pkg_private void ft_set(); Es_handle esh = ps_NEW(100); register Piece_table private; register Piece pieces; if (es_set_position(scratch, 0) != 0) { xv_error((Xv_opaque)scratch, ERROR_STRING, XV_MSG("ps_create(): cannot reset scratch stream"), ERROR_PKG, TEXTSW, 0); 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); } 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: xv_error(NULL, ERROR_STRING, XV_MSG("ps_create(): alloc failure"), ERROR_PKG, TEXTSW, 0); 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. * * 1) 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; } } } /* 2) 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; /* * Watch out for replaces that end exactly at a multiple of * scratch_max_len, because this requires repositioning of * physical scratch stream to make succeeding calls work properly. */ if ((private->scratch_position % private->scratch_max_len) == 0) { (void) private->scratch_ops->set_position(esh, 0); } 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); #ifdef OW_I18N static CHAR *wrap_msg_wcs; #endif 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); #ifdef OW_I18N wrap_msg_wcs = _xv_mbstowcsdup(wrap_msg); read_count = STRLEN(wrap_msg_wcs); #else read_count = strlen(wrap_msg); #endif 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; #ifdef OW_I18N BCOPY(wrap_msg_wcs + current_pos, bufp, read_count); #else XV_BCOPY(wrap_msg + current_pos, bufp, read_count); #endif *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) { if(console_fd = fopen("/dev/console", "a")) { fprintf(console_fd, XV_MSG("Text has been lost in a cmdtool transcript because the maximum edit log size has been exceeded.\n")); fflush(console_fd); max_transcript_alert_displayed = 1; fclose(console_fd); } } } #ifdef OW_I18N if (wrap_msg_wcs) free((char *)wrap_msg_wcs); #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, old_start; unsigned int first_valid; 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); /* * BIG BUG: sizeof(long_temp) has to be divisable by sizeof(CHAR) */ es_temp = es_replace(scratch, private->rec_insert + SIZEOF(long_temp), SIZEOF(long_temp), (CHAR *) &long_temp, &replace_used); } else { if (delta != 0) { if(SCRATCH_HAS_WRAPPED(private) && (current > private->pieces.last_plus_one - 3) && (private->length > private->scratch_max_len * 2) && (current > 30)) { pieces = PIECES_IN_TABLE(private); old_start = private->pieces.last_plus_one / 2 - 13; first_valid = SCRATCH_FIRST_VALID(private); if(PS_SANDP_POS(pieces[old_start]) >= first_valid) if(PS_SANDP_POS(pieces[old_start /= 2]) >= first_valid) old_start = 0; for(old_start++; PS_SANDP_POS(pieces[old_start]) < first_valid; old_start++); old_start -= 2; ft_shift_out(&private->pieces, 10, old_start); INVALIDATE_CURRENT(private); current = current - (old_start - 10); } /* 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 */ if ((current + 1) < private->pieces.last_plus_one) 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; /* * BIG BUG: This is a very bad hack. If sizeof(r_header) * is not divisable by sizeof(CHAR), then we will be in big problem. */ result = es_replace(esh, ES_INFINITY, SIZEOF(r_header), (CHAR *) &r_header, &replace_used); return (result); } static int record_deleted_pieces(esh, pieces, first, last_plus_one, next) Es_handle esh; 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); /* * BIG BUG: This is a very bad hack. If sizeof(d_header) * is not divisable by sizeof(CHAR), then we will be in big problem. */ 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, 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; } /* * BIG BUG: sizeof(count) has to be divisable by sizeof(CHAR) */ *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); XV_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; if (current < private->pieces.last_plus_one) 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, pieces, current, current + last_valid + 1, &private->rec_insert); long_temp = 0; /* * BIG BUG: sizeof(long_temp) has to be divisable by sizeof(CHAR) */ (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 { if ((current + last_valid + 1) < private->pieces.last_plus_one) 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); /* * BIG BUG: sizeof(r_header) has to be divisable by sizeof(CHAR) */ (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); /* * BIG BUG: sizeof(r_header) has to be divisable by sizeof(CHAR) */ (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--) { /* * BIG BUG: sizeof(d_header) has to be divisable * by sizeof(CHAR)sizeof */ (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); if (current < private->pieces.last_plus_one) 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) { if (current < private->pieces.last_plus_one) 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++) { /* * BIG BUG: sizeof(d_header) has to be divisable by * sizeof(CHAR)sizeof */ (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); } } } /* * BIG BUG: sizeof(insert_len) has to be divisable by * sizeof(CHAR)sizeof */ (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); if (current < private->pieces.last_plus_one) 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 #ifdef ANSI_FUNC_PROTO ps_get(Es_handle esh, Es_attribute attribute, ...) #else ps_get(esh, attribute, va_alist) Es_handle esh; Es_attribute attribute; va_dcl #endif { 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 ((caddr_t) 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, attribute); #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; Attr_attribute *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) 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) 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) 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) 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) attrs[1]; break; case ES_STATUS_PTR: status = (Es_status *) attrs[1]; *status = status_dummy; break; case ES_UNDO_MARK: /* -1 below is because 0 == ES_NULL_UNDO_MARK */ undo_mark = ((Es_index) attrs[1]) - 1; ps_undo_to_mark(esh, undo_mark, notify_proc, notify_data); break; case ES_UNDO_NOTIFY_PAIR: notify_proc = (int (*) ()) attrs[1]; notify_data = (char *) attrs[2]; break; default: break; } } return ((*status == ES_SUCCESS)); }