![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to editbuf.cc CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / libg++ / libio|
Return to editbuf.cc CVS log | Up to [Apple XNU] / GNUtools / libg++ / libio |
1.1 root 1: /* This is part of libio/iostream, providing -*- C++ -*- input/output.
2: Copyright (C) 1993 Free Software Foundation
3:
4: This file is part of the GNU IO Library. This library is free
5: software; you can redistribute it and/or modify it under the
6: terms of the GNU General Public License as published by the
7: Free Software Foundation; either version 2, or (at your option)
8: any later version.
9:
10: This library is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with GNU CC; see the file COPYING. If not, write to
17: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
18:
19: As a special exception, if you link this library with files
20: compiled with a GNU compiler to produce an executable, this does not cause
21: the resulting executable to be covered by the GNU General Public License.
22: This exception does not however invalidate any other reasons why
23: the executable file might be covered by the GNU General Public License.
24:
25: Written by Per Bothner ([email protected]). */
26:
27: #ifdef __GNUG__
28: #pragma implementation
29: #endif
30: #include "libioP.h"
31: #include "editbuf.h"
32: #include <stddef.h>
33: extern "C" {
34: #include <stdlib.h>
35: }
36: /* NOTE: Some of the code here is taken from GNU emacs */
37: /* Hence this file falls under the GNU License! */
38:
39: // Invariants for edit_streambuf:
40: // An edit_streambuf is associated with a specific edit_string,
41: // which again is a sub-string of a specific edit_buffer.
42: // An edit_streambuf is always in either get mode or put mode, never both.
43: // In get mode, gptr() is the current position,
44: // and pbase(), pptr(), and epptr() are all NULL.
45: // In put mode, pptr() is the current position,
46: // and eback(), gptr(), and egptr() are all NULL.
47: // Any edit_streambuf that is actively doing insertion (as opposed to
48: // replacing) // must have its pptr() pointing to the start of the gap.
49: // Only one edit_streambuf can be actively inserting into a specific
50: // edit_buffer; the edit_buffer's _writer field points to that edit_streambuf.
51: // That edit_streambuf "owns" the gap, and the actual start of the
52: // gap is the pptr() of the edit_streambuf; the edit_buffer::_gap_start pointer
53: // will only be updated on an edit_streambuf::overflow().
54:
55: int edit_streambuf::truncate()
56: {
57: str->buffer->delete_range(str->buffer->tell((buf_char*)pptr()),
58: str->buffer->tell(str->end));
59: return 0;
60: }
61:
62: #ifdef OLD_STDIO
63: inline void disconnect_gap_from_file(edit_buffer* buffer, FILE* fp)
64: {
65: if (buffer->gap_start_ptr != &fp->__bufp)
66: return;
67: buffer->gap_start_normal = fp->__bufp;
68: buffer->gap_start_ptr = &buffer->gap_start_normal;
69: }
70: #endif
71:
72: void edit_streambuf::flush_to_buffer(edit_buffer* buffer)
73: {
74: if (pptr() > buffer->_gap_start && pptr() < buffer->gap_end())
75: buffer->_gap_start = pptr();
76: }
77:
78: void edit_streambuf::disconnect_gap_from_file(edit_buffer* buffer)
79: {
80: if (buffer->_writer != this) return;
81: flush_to_buffer(buffer);
82: setp(pptr(),pptr());
83: buffer->_writer = NULL;
84: }
85:
86: buf_index edit_buffer::tell(buf_char *ptr)
87: {
88: if (ptr <= gap_start())
89: return ptr - data;
90: else
91: return ptr - gap_end() + size1();
92: }
93:
94: #if 0
95: buf_index buf_cookie::tell()
96: {
97: return str->buffer->tell(file->__bufp);
98: }
99: #endif
100:
101: buf_index edit_buffer::tell(edit_mark*mark)
102: {
103: return tell(data + mark->index_in_buffer(this));
104: }
105:
106: // adjust the position of the gap
107:
108: void edit_buffer::move_gap(buf_offset pos)
109: {
110: if (pos < size1())
111: gap_left (pos);
112: else if (pos > size1())
113: gap_right (pos);
114: }
115:
116: void edit_buffer::gap_left (int pos)
117: {
118: register buf_char *to, *from;
119: register int i;
120: int new_s1;
121:
122: i = size1();
123: from = gap_start();
124: to = from + gap_size();
125: new_s1 = size1();
126:
127: /* Now copy the characters. To move the gap down,
128: copy characters up. */
129:
130: for (;;)
131: {
132: /* I gets number of characters left to copy. */
133: i = new_s1 - pos;
134: if (i == 0)
135: break;
136: #if 0
137: /* If a quit is requested, stop copying now.
138: Change POS to be where we have actually moved the gap to. */
139: if (QUITP)
140: {
141: pos = new_s1;
142: break;
143: }
144: #endif
145: /* Move at most 32000 chars before checking again for a quit. */
146: if (i > 32000)
147: i = 32000;
148: new_s1 -= i;
149: while (--i >= 0)
150: *--to = *--from;
151: }
152:
153: /* Adjust markers, and buffer data structure, to put the gap at POS.
154: POS is where the loop above stopped, which may be what was specified
155: or may be where a quit was detected. */
156: adjust_markers (pos << 1, size1() << 1, gap_size(), data);
157: #ifndef OLD_STDIO
158: _gap_start = data + pos;
159: #else
160: if (gap_start_ptr == &gap_start_normal)
161: gap_start_normal = data + pos;
162: #endif
163: __gap_end_pos = to - data;
164: /* QUIT;*/
165: }
166:
167: void edit_buffer::gap_right (int pos)
168: {
169: register buf_char *to, *from;
170: register int i;
171: int new_s1;
172:
173: i = size1();
174: to = gap_start();
175: from = i + gap_end();
176: new_s1 = i;
177:
178: /* Now copy the characters. To move the gap up,
179: copy characters down. */
180:
181: while (1)
182: {
183: /* I gets number of characters left to copy. */
184: i = pos - new_s1;
185: if (i == 0)
186: break;
187: #if 0
188: /* If a quit is requested, stop copying now.
189: Change POS to be where we have actually moved the gap to. */
190: if (QUITP)
191: {
192: pos = new_s1;
193: break;
194: }
195: #endif
196: /* Move at most 32000 chars before checking again for a quit. */
197: if (i > 32000)
198: i = 32000;
199: new_s1 += i;
200: while (--i >= 0)
201: *to++ = *from++;
202: }
203:
204: adjust_markers ((size1() + gap_size()) << 1, (pos + gap_size()) << 1,
205: - gap_size(), data);
206: #ifndef OLD_STDIO
207: _gap_start = data+pos;
208: #else
209: if (gap_start_ptr == &gap_start_normal)
210: gap_start_normal = data + pos;
211: #endif
212: __gap_end_pos = from - data;
213: /* QUIT;*/
214: }
215:
216: /* make sure that the gap in the current buffer is at least k
217: characters wide */
218:
219: void edit_buffer::make_gap(buf_offset k)
220: {
221: register buf_char *p1, *p2, *lim;
222: buf_char *old_data = data;
223: int s1 = size1();
224:
225: if (gap_size() >= k)
226: return;
227:
228: /* Get more than just enough */
229: if (buf_size > 1000) k += 2000;
230: else k += /*200;*/ 20; // for testing!
231:
232: p1 = (buf_char *) realloc (data, s1 + size2() + k);
233: if (p1 == 0)
234: abort(); /*memory_full ();*/
235:
236: k -= gap_size(); /* Amount of increase. */
237:
238: /* Record new location of text */
239: data = p1;
240:
241: /* Transfer the new free space from the end to the gap
242: by shifting the second segment upward */
243: p2 = data + buf_size;
244: p1 = p2 + k;
245: lim = p2 - size2();
246: while (lim < p2)
247: *--p1 = *--p2;
248:
249: /* Finish updating text location data */
250: __gap_end_pos += k;
251:
252: #ifndef OLD_STDIO
253: _gap_start = data + s1;
254: #else
255: if (gap_start_ptr == &gap_start_normal)
256: gap_start_normal = data + s1;
257: #endif
258:
259: /* adjust markers */
260: adjust_markers (s1 << 1, (buf_size << 1) + 1, k, old_data);
261: buf_size += k;
262: }
263:
264: /* Add `amount' to the position of every marker in the current buffer
265: whose current position is between `from' (exclusive) and `to' (inclusive).
266: Also, any markers past the outside of that interval, in the direction
267: of adjustment, are first moved back to the near end of the interval
268: and then adjusted by `amount'. */
269:
270: void edit_buffer::adjust_markers(register mark_pointer low,
271: register mark_pointer high,
272: int amount, buf_char *old_data)
273: {
274: register struct edit_mark *m;
275: register mark_pointer mpos;
276: /* convert to mark_pointer */
277: amount <<= 1;
278:
279: if (_writer)
280: _writer->disconnect_gap_from_file(this);
281:
282: for (m = mark_list(); m != NULL; m = m->chain)
283: {
284: mpos = m->_pos;
285: if (amount > 0)
286: {
287: if (mpos > high && mpos < high + amount)
288: mpos = high + amount;
289: }
290: else
291: {
292: if (mpos > low + amount && mpos <= low)
293: mpos = low + amount;
294: }
295: if (mpos > low && mpos <= high)
296: mpos += amount;
297: m->_pos = mpos;
298: }
299:
300: // Now adjust files
301: edit_streambuf *file;
302:
303: for (file = files; file != NULL; file = file->next) {
304: mpos = file->current() - old_data;
305: if (amount > 0)
306: {
307: if (mpos > high && mpos < high + amount)
308: mpos = high + amount;
309: }
310: else
311: {
312: if (mpos > low + amount && mpos <= low)
313: mpos = low + amount;
314: }
315: if (mpos > low && mpos <= high)
316: mpos += amount;
317: char* new_pos = data + mpos;
318: file->set_current(new_pos, file->is_reading());
319: }
320: }
321:
322: #if 0
323: stdio_
324: __off == index at start of buffer (need only be valid after seek ? )
325: __buf ==
326:
327: if read/read_delete/overwrite mode:
328: __endp <= min(*gap_start_ptr, edit_string->end->ptr(buffer))
329:
330: if inserting:
331: must have *gap_start_ptr == __bufp && *gap_start_ptr+gap == __endp
332: file->edit_string->end->ptr(buffer) == *gap_start_ptr+end
333: if write_mode:
334: if before gap
335: #endif
336:
337: int edit_streambuf::underflow()
338: {
339: if (!(_mode & ios::in))
340: return EOF;
341: struct edit_buffer *buffer = str->buffer;
342: if (!is_reading()) { // Must switch from put to get mode.
343: disconnect_gap_from_file(buffer);
344: set_current(pptr(), 1);
345: }
346: buf_char *str_end = str->end->ptr(buffer);
347: retry:
348: if (gptr() < egptr()) {
349: return *gptr();
350: }
351: if ((buf_char*)gptr() == str_end)
352: return EOF;
353: if (str_end <= buffer->gap_start()) {
354: setg(eback(), gptr(), str_end);
355: goto retry;
356: }
357: if (gptr() < buffer->gap_start()) {
358: setg(eback(), gptr(), buffer->gap_start());
359: goto retry;
360: }
361: if (gptr() == buffer->gap_start()) {
362: disconnect_gap_from_file(buffer);
363: // fp->__offset += fp->__bufp - fp->__buffer;
364: setg(buffer->gap_end(), buffer->gap_end(), str_end);
365: }
366: else
367: setg(eback(), gptr(), str_end);
368: goto retry;
369: }
370:
371: int edit_streambuf::overflow(int ch)
372: {
373: if (_mode == ios::in)
374: return EOF;
375: struct edit_buffer *buffer = str->buffer;
376: flush_to_buffer(buffer);
377: if (ch == EOF)
378: return 0;
379: if (is_reading()) { // Must switch from get to put mode.
380: set_current(gptr(), 0);
381: }
382: buf_char *str_end = str->end->ptr(buffer);
383: retry:
384: if (pptr() < epptr()) {
385: *pptr() = ch;
386: pbump(1);
387: return (unsigned char)ch;
388: }
389: if ((buf_char*)pptr() == str_end || inserting()) {
390: /* insert instead */
391: if (buffer->_writer)
392: buffer->_writer->flush_to_buffer(); // Redundant?
393: buffer->_writer = NULL;
394: if (pptr() >= buffer->gap_end())
395: buffer->move_gap(pptr() - buffer->gap_size());
396: else
397: buffer->move_gap(pptr());
398: buffer->make_gap(1);
399: setp(buffer->gap_start(), buffer->gap_end());
400: buffer->_writer = this;
401: *pptr() = ch;
402: pbump(1);
403: return (unsigned char)ch;
404: }
405: if (str_end <= buffer->gap_start()) {
406: // Entire string is left of gap.
407: setp(pptr(), str_end);
408: }
409: else if (pptr() < buffer->gap_start()) {
410: // Current pos is left of gap.
411: setp(pptr(), buffer->gap_start());
412: goto retry;
413: }
414: else if (pptr() == buffer->gap_start()) {
415: // Current pos is at start of gap; move to end of gap.
416: // disconnect_gap_from_file(buffer);
417: setp(buffer->gap_end(), str_end);
418: // __offset += __bufp - __buffer;
419: }
420: else {
421: // Otherwise, current pos is right of gap.
422: setp(pptr(), str_end);
423: }
424: goto retry;
425: }
426:
427: void edit_streambuf::set_current(char *new_pos, int reading)
428: {
429: if (reading) {
430: setg(new_pos, new_pos, new_pos);
431: setp(NULL, NULL);
432: }
433: else {
434: setg(NULL, NULL, NULL);
435: setp(new_pos, new_pos);
436: }
437: }
438:
439: // Called by fseek(fp, pos, whence) if fp is bound to a edit_buffer.
440:
441: streampos edit_streambuf::seekoff(streamoff offset, _seek_dir dir,
442: int mode /* =ios::in|ios::out*/)
443: {
444: struct edit_buffer *buffer = str->buffer;
445: disconnect_gap_from_file(buffer);
446: buf_index cur_pos = buffer->tell((buf_char*)current());;
447: buf_index start_pos = buffer->tell(str->start);
448: buf_index end_pos = buffer->tell(str->end);
449: switch (dir) {
450: case ios::beg:
451: offset += start_pos;
452: break;
453: case ios::cur:
454: offset += cur_pos;
455: break;
456: case ios::end:
457: offset += end_pos;
458: break;
459: }
460: if (offset < start_pos || offset > end_pos)
461: return EOF;
462: buf_char *new_pos = buffer->data + offset;
463: buf_char* gap_start = buffer->gap_start();
464: if (new_pos > gap_start) {
465: buf_char* gap_end = buffer->gap_end();
466: new_pos += gap_end - gap_start;
467: if (new_pos >= buffer->data + buffer->buf_size) abort(); // Paranoia.
468: }
469: set_current(new_pos, is_reading());
470: return EOF;
471: }
472:
473: #if 0
474: int buf_seek(void *arg_cookie, fpos_t * pos, int whence)
475: {
476: struct buf_cookie *cookie = arg_cookie;
477: FILE *file = cookie->file;
478: struct edit_buffer *buffer = cookie->str->buffer;
479: buf_char *str_start = cookie->str->start->ptr(buffer);
480: disconnect_gap_from_file(buffer, cookie->file);
481: fpos_t cur_pos, new_pos;
482: if (file->__bufp <= *buffer->gap_start_ptr
483: || str_start >= buffer->__gap_end)
484: cur_pos = str_start - file->__bufp;
485: else
486: cur_pos =
487: (*buffer->gap_start_ptr - str_start) + (file->__bufp - __gap_end);
488: end_pos = ...;
489: switch (whence) {
490: case SEEK_SET:
491: new_pos = *pos;
492: break;
493: case SEEK_CUR:
494: new_pos = cur_pos + *pos;
495: break;
496: case SEEK_END:
497: new_pos = end_pos + *pos;
498: break;
499: }
500: if (new_pos > end_pos) {
501: seek to end_pos;
502: insert_nulls(new_pos - end_pos);
503: return;
504: }
505: if (str_start + new_pos <= *gap_start_ptr &* *gap_start_ptr < end) {
506: __buffer = str_start;
507: __off = 0;
508: __bufp = str_start + new_pos;
509: file->__get_limit =
510: *buffer->gap_start_ptr; /* what if gap_start_ptr == &bufp ??? */
511: } else if () {
512:
513: }
514: *pos = new_pos;
515: }
516: #endif
517:
518: /* Delete characters from `from' up to (but not incl) `to' */
519:
520: void edit_buffer::delete_range (buf_index from, buf_index to)
521: {
522: register int numdel;
523:
524: if ((numdel = to - from) <= 0)
525: return;
526:
527: /* Make sure the gap is somewhere in or next to what we are deleting */
528: if (from > size1())
529: gap_right (from);
530: if (to < size1())
531: gap_left (to);
532:
533: /* Relocate all markers pointing into the new, larger gap
534: to point at the end of the text before the gap. */
535: adjust_markers ((to + gap_size()) << 1, (to + gap_size()) << 1,
536: - numdel - gap_size(), data);
537:
538: __gap_end_pos = to + gap_size();
539: _gap_start = data + from;
540: }
541:
542: void edit_buffer::delete_range(struct edit_mark *start, struct edit_mark *end)
543: {
544: delete_range(tell(start), tell(end));
545: }
546:
547: void buf_delete_chars(struct edit_buffer *buf, struct edit_mark *mark, size_t count)
548: {
549: abort();
550: }
551:
552: edit_streambuf::edit_streambuf(edit_string* bstr, int mode)
553: {
554: _mode = mode;
555: str = bstr;
556: edit_buffer* buffer = bstr->buffer;
557: next = buffer->files;
558: buffer->files = this;
559: char* buf_ptr = bstr->start->ptr(buffer);
560: _inserting = 0;
561: // setb(buf_ptr, buf_ptr, 0);
562: set_current(buf_ptr, !(mode & ios::out+ios::trunc+ios::app));
563: if (_mode & ios::trunc)
564: truncate();
565: if (_mode & ios::ate)
566: seekoff(0, ios::end);
567: }
568:
569: // Called by fclose(fp) if fp is bound to a edit_buffer.
570:
571: #if 0
572: static int buf_close(void *arg)
573: {
574: register struct buf_cookie *cookie = arg;
575: struct edit_buffer *buffer = cookie->str->buffer;
576: struct buf_cookie **ptr;
577: for (ptr = &buffer->files; *ptr != cookie; ptr = &(*ptr)->next) ;
578: *ptr = cookie->next;
579: disconnect_gap_from_file(buffer, cookie->file);
580: free (cookie);
581: return 0;
582: }
583: #endif
584:
585: edit_streambuf::~edit_streambuf()
586: {
587: if (_mode == ios::out)
588: truncate();
589: // Unlink this from list of files associated with bstr->buffer.
590: edit_streambuf **ptr = &str->buffer->files;
591: for (; *ptr != this; ptr = &(*ptr)->next) { }
592: *ptr = next;
593:
594: disconnect_gap_from_file(str->buffer);
595: }
596:
597: edit_buffer::edit_buffer()
598: {
599: buf_size = /*200;*/ 15; /* for testing! */
600: data = (buf_char*)malloc(buf_size);
601: files = NULL;
602: #ifndef OLD_STDIO
603: _gap_start = data;
604: _writer = NULL;
605: #else
606: gap_start_normal = data;
607: gap_start_ptr = &gap_start_normal;
608: #endif
609: __gap_end_pos = buf_size;
610: start_mark.chain = &end_mark;
611: start_mark._pos = 0;
612: end_mark.chain = NULL;
613: end_mark._pos = 2 * buf_size + 1;
614: }
615:
616: // Allocate a new mark, which is adjusted by 'delta' bytes from 'this'.
617: // Restrict new mark to lie within 'str'.
618:
619: edit_mark::edit_mark(struct edit_string *str, long delta)
620: {
621: struct edit_buffer *buf = str->buffer;
622: chain = buf->start_mark.chain;
623: buf->start_mark.chain = this;
624: mark_pointer size1 = buf->size1() << 1;
625: int gap_size = buf->gap_size() << 1;
626: delta <<= 1;
627:
628: // check if new and old marks are opposite sides of gap
629: if (_pos <= size1 && _pos + delta > size1)
630: delta += gap_size;
631: else if (_pos >= size1 + gap_size && _pos + delta < size1 + gap_size)
632: delta -= gap_size;
633:
634: _pos = _pos + delta;
635: if (_pos < str->start->_pos & ~1)
636: _pos = (str->start->_pos & ~ 1) + (_pos & 1);
637: else if (_pos >= str->end->_pos)
638: _pos = (str->end->_pos & ~ 1) + (_pos & 1);
639: }
640:
641: // A (slow) way to find the buffer a mark belongs to.
642:
643: edit_buffer * edit_mark::buffer()
644: {
645: struct edit_mark *mark;
646: for (mark = this; mark->chain != NULL; mark = mark->chain) ;
647: // Assume that the last mark on the chain is the end_mark.
648: return (edit_buffer *)((char*)mark - offsetof(edit_buffer, end_mark));
649: }
650:
651: edit_mark::~edit_mark()
652: {
653: // Must unlink mark from chain of owning buffer
654: struct edit_buffer *buf = buffer();
655: if (this == &buf->start_mark || this == &buf->end_mark) abort();
656: edit_mark **ptr;
657: for (ptr = &buf->start_mark.chain; *ptr != this; ptr = &(*ptr)->chain) ;
658: *ptr = this->chain;
659: }
660:
661: int edit_string::length() const
662: {
663: ptrdiff_t delta = end->ptr(buffer) - start->ptr(buffer);
664: if (end->ptr(buffer) <= buffer->gap_start() ||
665: start->ptr(buffer) >= buffer->gap_end())
666: return delta;
667: return delta - buffer->gap_size();
668: }
669:
670: buf_char * edit_string::copy_bytes(int *lenp) const
671: {
672: char *new_str;
673: int len1, len2;
674: buf_char *start1, *start2;
675: start1 = start->ptr(buffer);
676: if (end->ptr(buffer) <= buffer->gap_start()
677: || start->ptr(buffer) >= buffer->gap_end()) {
678: len1 = end->ptr(buffer) - start1;
679: len2 = 0;
680: start2 = NULL; // To avoid a warning from g++.
681: }
682: else {
683: len1 = buffer->gap_start() - start1;
684: start2 = buffer->gap_end();
685: len2 = end->ptr(buffer) - start2;
686: }
687: new_str = (char*)malloc(len1 + len2 + 1);
688: memcpy(new_str, start1, len1);
689: if (len2 > 0) memcpy(new_str + len1, start2, len2);
690: new_str[len1+len2] = '\0';
691: *lenp = len1+len2;
692: return new_str;
693: }
694:
695: // Replace the buf_chars in 'this' with ones from 'src'.
696: // Equivalent to deleting this, then inserting src, except tries
697: // to leave marks in place: Marks whose offset from the start
698: // of 'this' is less than 'src->length()' will still have the
699: // same offset in 'this' when done.
700:
701: void edit_string::assign(struct edit_string *src)
702: {
703: edit_streambuf dst_file(this, ios::out);
704: if (buffer == src->buffer /*&& ???*/) { /* overly conservative */
705: int src_len;
706: buf_char *new_str;
707: new_str = src->copy_bytes(&src_len);
708: dst_file.sputn(new_str, src_len);
709: free (new_str);
710: } else {
711: edit_streambuf src_file(src, ios::in);
712: for ( ; ; ) {
713: int ch = src_file.sbumpc();
714: if (ch == EOF) break;
715: dst_file.sputc(ch);
716: }
717: }
718: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.