![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[first]](../icons/first.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /*
2 Editor text keep buffer.
3
4 Copyright (C) 2013-2024
5 Free Software Foundation, Inc.
6
7 Written by:
8 Andrew Borodin <aborodin@vmail.ru> 2013
9
10 This file is part of the Midnight Commander.
11
12 The Midnight Commander is free software: you can redistribute it
13 and/or modify it under the terms of the GNU General Public License as
14 published by the Free Software Foundation, either version 3 of the License,
15 or (at your option) any later version.
16
17 The Midnight Commander is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 */
25
26 /** \file
27 * \brief Source: editor text keep buffer.
28 * \author Andrew Borodin
29 * \date 2013
30 */
31
32 #include <config.h>
33
34 #include <ctype.h> /* isdigit() */
35 #include <stdlib.h>
36 #include <string.h>
37 #include <sys/types.h>
38
39 #include "lib/global.h"
40
41 #include "lib/vfs/vfs.h"
42
43 #include "edit-impl.h"
44 #include "editbuffer.h"
45
46 /* --------------------------------------------------------------------------------------------- */
47 /*-
48 *
49 * here's a quick sketch of the layout: (don't run this through indent.)
50 *
51 * |
52 * \0\0\0\0\0m e _ f i l e . \nf i n . \n|T h i s _ i s _ s o\0\0\0\0\0\0\0\0\0
53 * ______________________________________|______________________________________
54 * |
55 * ... | b2[2] | b2[1] | b2[0] | b1[0] | b1[1] | b1[2] | ...
56 * |-> |-> |-> |-> |-> |-> |
57 * |
58 * _<------------------------->|<----------------->_
59 * curs2 | curs1
60 * ^ | ^
61 * | ^|^ |
62 * cursor ||| cursor
63 * |||
64 * file end|||file beginning
65 * |
66 * |
67 *
68 * _
69 * This_is_some_file
70 * fin.
71 *
72 *
73 * This is called a "gap buffer".
74 * See also:
75 * http://en.wikipedia.org/wiki/Gap_buffer
76 * http://stackoverflow.com/questions/4199694/data-structure-for-text-editor
77 */
78
79 /*** global variables ****************************************************************************/
80
81 /*** file scope macro definitions ****************************************************************/
82
83 /*
84 * The editor keeps data in two arrays of buffers.
85 * All buffers have the same size, which must be a power of 2.
86 */
87
88 /* Configurable: log2 of the buffer size in bytes */
89 #ifndef S_EDIT_BUF_SIZE
90 #define S_EDIT_BUF_SIZE 16
91 #endif
92
93 /* Size of the buffer */
94 #define EDIT_BUF_SIZE (((off_t) 1) << S_EDIT_BUF_SIZE)
95
96 /* Buffer mask (used to find cursor position relative to the buffer) */
97 #define M_EDIT_BUF_SIZE (EDIT_BUF_SIZE - 1)
98
99 /*** file scope type declarations ****************************************************************/
100
101 /*** forward declarations (file scope functions) *************************************************/
102
103 /*** file scope variables ************************************************************************/
104
105 /* --------------------------------------------------------------------------------------------- */
106 /*** file scope functions ************************************************************************/
107 /* --------------------------------------------------------------------------------------------- */
108 /**
109 * Get pointer to byte at specified index
110 *
111 * @param buf pointer to editor buffer
112 * @param byte_index byte index
113 *
114 * @return NULL if byte_index is negative or larger than file size; pointer to byte otherwise.
115 */
116 static char *
117 edit_buffer_get_byte_ptr (const edit_buffer_t *buf, off_t byte_index)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
118 {
119 void *b;
120
121 if (byte_index >= (buf->curs1 + buf->curs2) || byte_index < 0)
122 return NULL;
123
124 if (byte_index >= buf->curs1)
125 {
126 off_t p;
127
128 p = buf->curs1 + buf->curs2 - byte_index - 1;
129 b = g_ptr_array_index (buf->b2, p >> S_EDIT_BUF_SIZE);
130 return (char *) b + EDIT_BUF_SIZE - 1 - (p & M_EDIT_BUF_SIZE);
131 }
132
133 b = g_ptr_array_index (buf->b1, byte_index >> S_EDIT_BUF_SIZE);
134 return (char *) b + (byte_index & M_EDIT_BUF_SIZE);
135 }
136
137 /* --------------------------------------------------------------------------------------------- */
138 /*** public functions ****************************************************************************/
139 /* --------------------------------------------------------------------------------------------- */
140 /**
141 * Initialize editor buffers.
142 *
143 * @param buf pointer to editor buffer
144 */
145
146 void
147 edit_buffer_init (edit_buffer_t *buf, off_t size)
/* ![[previous]](../icons/left.png)
*/
148 {
149 buf->b1 = g_ptr_array_new_full (32, g_free);
150 buf->b2 = g_ptr_array_new_full (32, g_free);
151
152 buf->curs1 = 0;
153 buf->curs2 = 0;
154
155 buf->size = size;
156 buf->lines = 0;
157 }
158
159 /* --------------------------------------------------------------------------------------------- */
160 /**
161 * Clean editor buffers.
162 *
163 * @param buf pointer to editor buffer
164 */
165
166 void
167 edit_buffer_clean (edit_buffer_t *buf)
/* */
168 {
169 if (buf->b1 != NULL)
170 g_ptr_array_free (buf->b1, TRUE);
171
172 if (buf->b2 != NULL)
173 g_ptr_array_free (buf->b2, TRUE);
174 }
175
176 /* --------------------------------------------------------------------------------------------- */
177 /**
178 * Get byte at specified index
179 *
180 * @param buf pointer to editor buffer
181 * @param byte_index byte index
182 *
183 * @return '\n' if byte_index is negative or larger than file size; byte at byte_index otherwise.
184 */
185
186 int
187 edit_buffer_get_byte (const edit_buffer_t *buf, off_t byte_index)
/* */
188 {
189 char *p;
190
191 p = edit_buffer_get_byte_ptr (buf, byte_index);
192
193 return (p != NULL) ? *(unsigned char *) p : '\n';
194 }
195
196 /* --------------------------------------------------------------------------------------------- */
197
198 #ifdef HAVE_CHARSET
199 /**
200 * Get utf-8 symbol at specified index
201 *
202 * @param buf pointer to editor buffer
203 * @param byte_index byte index
204 * @param char_length length of returned symbol
205 *
206 * @return '\n' if byte_index is negative or larger than file size;
207 * 0 if utf-8 symbol at specified index is invalid;
208 * utf-8 symbol otherwise
209 */
210
211 int
212 edit_buffer_get_utf (const edit_buffer_t *buf, off_t byte_index, int *char_length)
/* */
213 {
214 gchar *str = NULL;
215 gunichar res;
216 gunichar ch;
217 gchar *next_ch = NULL;
218
219 if (byte_index >= (buf->curs1 + buf->curs2) || byte_index < 0)
220 {
221 *char_length = 0;
222 return '\n';
223 }
224
225 str = edit_buffer_get_byte_ptr (buf, byte_index);
226 if (str == NULL)
227 {
228 *char_length = 0;
229 return 0;
230 }
231
232 res = g_utf8_get_char_validated (str, -1);
233 if (res == (gunichar) (-2) || res == (gunichar) (-1))
234 {
235 /* Retry with explicit bytes to make sure it's not a buffer boundary */
236 size_t i;
237 gchar utf8_buf[UTF8_CHAR_LEN + 1];
238
239 for (i = 0; i < UTF8_CHAR_LEN; i++)
240 utf8_buf[i] = edit_buffer_get_byte (buf, byte_index + i);
241 utf8_buf[i] = '\0';
242 res = g_utf8_get_char_validated (utf8_buf, -1);
243 }
244
245 if (res == (gunichar) (-2) || res == (gunichar) (-1))
246 {
247 ch = *str;
248 *char_length = 0;
249 }
250 else
251 {
252 ch = res;
253 /* Calculate UTF-8 char length */
254 next_ch = g_utf8_next_char (str);
255 *char_length = next_ch - str;
256 }
257
258 return (int) ch;
259 }
260
261 /* --------------------------------------------------------------------------------------------- */
262 /**
263 * Get utf-8 symbol before specified index
264 *
265 * @param buf pointer to editor buffer
266 * @param byte_index byte index
267 * @param char_length length of returned symbol
268 *
269 * @return 0 if byte_index is negative or larger than file size;
270 * 1-byte value before specified index if utf-8 symbol before specified index is invalid;
271 * utf-8 symbol otherwise
272 */
273
274 int
275 edit_buffer_get_prev_utf (const edit_buffer_t *buf, off_t byte_index, int *char_length)
/* */
276 {
277 size_t i;
278 gchar utf8_buf[3 * UTF8_CHAR_LEN + 1];
279 gchar *str;
280 gchar *cursor_buf_ptr;
281 gunichar res;
282
283 if (byte_index > (buf->curs1 + buf->curs2) || byte_index <= 0)
284 {
285 *char_length = 0;
286 return 0;
287 }
288
289 for (i = 0; i < (3 * UTF8_CHAR_LEN); i++)
290 utf8_buf[i] = edit_buffer_get_byte (buf, byte_index + i - (2 * UTF8_CHAR_LEN));
291 utf8_buf[i] = '\0';
292
293 cursor_buf_ptr = utf8_buf + (2 * UTF8_CHAR_LEN);
294 str = g_utf8_find_prev_char (utf8_buf, cursor_buf_ptr);
295
296 if (str == NULL || g_utf8_next_char (str) != cursor_buf_ptr)
297 {
298 *char_length = 1;
299 return *(cursor_buf_ptr - 1);
300 }
301
302 res = g_utf8_get_char_validated (str, -1);
303 if (res == (gunichar) (-2) || res == (gunichar) (-1))
304 {
305 *char_length = 1;
306 return *(cursor_buf_ptr - 1);
307 }
308
309 *char_length = cursor_buf_ptr - str;
310 return (int) res;
311 }
312 #endif /* HAVE_CHARSET */
313
314 /* --------------------------------------------------------------------------------------------- */
315 /**
316 * Count lines in editor buffer.
317 *
318 * @param buf editor buffer
319 * @param first start byte offset
320 * @param last finish byte offset
321 *
322 * @return line numbers between "first" and "last" bytes
323 */
324
325 long
326 edit_buffer_count_lines (const edit_buffer_t *buf, off_t first, off_t last)
/* */
327 {
328 long lines = 0;
329
330 first = MAX (first, 0);
331 last = MIN (last, buf->size);
332
333 while (first < last)
334 if (edit_buffer_get_byte (buf, first++) == '\n')
335 lines++;
336
337 return lines;
338 }
339
340 /* --------------------------------------------------------------------------------------------- */
341 /**
342 * Get "begin-of-line" offset of line contained specified byte offset
343 *
344 * @param buf editor buffer
345 * @param current byte offset
346 *
347 * @return index of first char of line
348 */
349
350 off_t
351 edit_buffer_get_bol (const edit_buffer_t *buf, off_t current)
/* */
352 {
353 if (current <= 0)
354 return 0;
355
356 for (; edit_buffer_get_byte (buf, current - 1) != '\n'; current--)
357 ;
358
359 return current;
360 }
361
362 /* --------------------------------------------------------------------------------------------- */
363 /**
364 * Get "end-of-line" offset of line contained specified byte offset
365 *
366 * @param buf editor buffer
367 * @param current byte offset
368 *
369 * @return index of last char of line + 1
370 */
371
372 off_t
373 edit_buffer_get_eol (const edit_buffer_t *buf, off_t current)
/* */
374 {
375 if (current >= buf->size)
376 return buf->size;
377
378 for (; edit_buffer_get_byte (buf, current) != '\n'; current++)
379 ;
380
381 return current;
382 }
383
384 /* --------------------------------------------------------------------------------------------- */
385 /**
386 * Get word from specified offset.
387 *
388 * @param buf editor buffer
389 * @param current start_pos offset
390 * @param start actual start word ofset
391 * @param cut
392 *
393 * @return word as newly allocated object
394 */
395
396 GString *
397 edit_buffer_get_word_from_pos (const edit_buffer_t *buf, off_t start_pos, off_t *start, gsize *cut)
/* */
398 {
399 off_t word_start;
400 gsize cut_len = 0;
401 GString *match_expr;
402 int c1, c2;
403
404 for (word_start = start_pos; word_start != 0; word_start--, cut_len++)
405 {
406 c1 = edit_buffer_get_byte (buf, word_start);
407 c2 = edit_buffer_get_byte (buf, word_start - 1);
408
409 if (is_break_char (c1) != is_break_char (c2) || c1 == '\n' || c2 == '\n')
410 break;
411 }
412
413 match_expr = g_string_sized_new (16);
414
415 do
416 {
417 c1 = edit_buffer_get_byte (buf, word_start + match_expr->len);
418 c2 = edit_buffer_get_byte (buf, word_start + match_expr->len + 1);
419 g_string_append_c (match_expr, c1);
420 }
421 while (!(is_break_char (c1) != is_break_char (c2) || c1 == '\n' || c2 == '\n'));
422
423 *start = word_start;
424 *cut = cut_len;
425
426 return match_expr;
427 }
428
429 /* --------------------------------------------------------------------------------------------- */
430 /**
431 * Find first character of current word
432 *
433 * @param buf editor buffer
434 * @param word_start position of first character of current word
435 * @param word_len length of current word
436 *
437 * @return TRUE if first character of word is found and this character is not 1) a digit and
438 * 2) a begin of file, FALSE otherwise
439 */
440
441 gboolean
442 edit_buffer_find_word_start (const edit_buffer_t *buf, off_t *word_start, gsize *word_len)
/* */
443 {
444 int c;
445 off_t i;
446
447 /* return if at begin of file */
448 if (buf->curs1 <= 0)
449 return FALSE;
450
451 c = edit_buffer_get_previous_byte (buf);
452 /* return if not at end or in word */
453 if (is_break_char (c))
454 return FALSE;
455
456 /* search start of word */
457 for (i = 1;; i++)
458 {
459 int last;
460
461 last = c;
462 c = edit_buffer_get_byte (buf, buf->curs1 - i - 1);
463
464 if (is_break_char (c))
465 {
466 /* return if word starts with digit */
467 if (isdigit (last))
468 return FALSE;
469
470 break;
471 }
472 }
473
474 /* success */
475 *word_start = buf->curs1 - i; /* start found */
476 *word_len = (gsize) i;
477
478 return TRUE;
479 }
480
481 /* --------------------------------------------------------------------------------------------- */
482 /**
483 * Basic low level single character buffer alterations and movements at the cursor: insert character
484 * at the cursor position and move right.
485 *
486 * @param buf pointer to editor buffer
487 * @param c character to insert
488 */
489
490 void
491 edit_buffer_insert (edit_buffer_t *buf, int c)
/* */
492 {
493 void *b;
494 off_t i;
495
496 i = buf->curs1 & M_EDIT_BUF_SIZE;
497
498 /* add a new buffer if we've reached the end of the last one */
499 if (i == 0)
500 g_ptr_array_add (buf->b1, g_malloc0 (EDIT_BUF_SIZE));
501
502 /* perform the insertion */
503 b = g_ptr_array_index (buf->b1, buf->curs1 >> S_EDIT_BUF_SIZE);
504 *((unsigned char *) b + i) = (unsigned char) c;
505
506 /* update cursor position */
507 buf->curs1++;
508
509 /* update file length */
510 buf->size++;
511 }
512
513 /* --------------------------------------------------------------------------------------------- */
514 /**
515 * Basic low level single character buffer alterations and movements at the cursor: insert character
516 * at the cursor position and move left.
517 *
518 * @param buf pointer to editor buffer
519 * @param c character to insert
520 */
521
522 void
523 edit_buffer_insert_ahead (edit_buffer_t *buf, int c)
/* */
524 {
525 void *b;
526 off_t i;
527
528 i = buf->curs2 & M_EDIT_BUF_SIZE;
529
530 /* add a new buffer if we've reached the end of the last one */
531 if (i == 0)
532 g_ptr_array_add (buf->b2, g_malloc0 (EDIT_BUF_SIZE));
533
534 /* perform the insertion */
535 b = g_ptr_array_index (buf->b2, buf->curs2 >> S_EDIT_BUF_SIZE);
536 *((unsigned char *) b + EDIT_BUF_SIZE - 1 - i) = (unsigned char) c;
537
538 /* update cursor position */
539 buf->curs2++;
540
541 /* update file length */
542 buf->size++;
543 }
544
545 /* --------------------------------------------------------------------------------------------- */
546 /**
547 * Basic low level single character buffer alterations and movements at the cursor: delete character
548 * at the cursor position.
549 *
550 * @param buf pointer to editor buffer
551 * @param c character to insert
552 */
553
554 int
555 edit_buffer_delete (edit_buffer_t *buf)
/* */
556 {
557 void *b;
558 unsigned char c;
559 off_t prev;
560 off_t i;
561
562 prev = buf->curs2 - 1;
563
564 b = g_ptr_array_index (buf->b2, prev >> S_EDIT_BUF_SIZE);
565 i = prev & M_EDIT_BUF_SIZE;
566 c = *((unsigned char *) b + EDIT_BUF_SIZE - 1 - i);
567
568 if (i == 0)
569 {
570 guint j;
571
572 j = buf->b2->len - 1;
573 b = g_ptr_array_index (buf->b2, j);
574 g_ptr_array_remove_index (buf->b2, j);
575 }
576
577 buf->curs2 = prev;
578
579 /* update file length */
580 buf->size--;
581
582 return c;
583 }
584
585 /* --------------------------------------------------------------------------------------------- */
586 /**
587 * Basic low level single character buffer alterations and movements at the cursor: delete character
588 * before the cursor position and move left.
589 *
590 * @param buf pointer to editor buffer
591 * @param c character to insert
592 */
593
594 int
595 edit_buffer_backspace (edit_buffer_t *buf)
/* */
596 {
597 void *b;
598 unsigned char c;
599 off_t prev;
600 off_t i;
601
602 prev = buf->curs1 - 1;
603
604 b = g_ptr_array_index (buf->b1, prev >> S_EDIT_BUF_SIZE);
605 i = prev & M_EDIT_BUF_SIZE;
606 c = *((unsigned char *) b + i);
607
608 if (i == 0)
609 {
610 guint j;
611
612 j = buf->b1->len - 1;
613 b = g_ptr_array_index (buf->b1, j);
614 g_ptr_array_remove_index (buf->b1, j);
615 }
616
617 buf->curs1 = prev;
618
619 /* update file length */
620 buf->size--;
621
622 return c;
623 }
624
625 /* --------------------------------------------------------------------------------------------- */
626 /**
627 * Calculate forward offset with specified number of lines.
628 *
629 * @param buf editor buffer
630 * @param current current offset
631 * @param lines number of lines to move forward
632 * @param upto offset to count lines between current and upto.
633 *
634 * @return If lines is zero returns the count of lines from current to upto.
635 * If upto is zero returns offset of lines forward current.
636 * Else returns forward offset with specified number of lines
637 */
638
639 off_t
640 edit_buffer_get_forward_offset (const edit_buffer_t *buf, off_t current, long lines, off_t upto)
/* */
641 {
642 if (upto != 0)
643 return (off_t) edit_buffer_count_lines (buf, current, upto);
644
645 lines = MAX (lines, 0);
646
647 while (lines-- != 0)
648 {
649 long next;
650
651 next = edit_buffer_get_eol (buf, current) + 1;
652 if (next > buf->size)
653 break;
654 current = next;
655 }
656
657 return current;
658 }
659
660 /* --------------------------------------------------------------------------------------------- */
661 /**
662 * Calculate backward offset with specified number of lines.
663 *
664 * @param buf editor buffer
665 * @param current current offset
666 * @param lines number of lines to move backward
667 *
668 * @return backward offset with specified number of lines.
669 */
670
671 off_t
672 edit_buffer_get_backward_offset (const edit_buffer_t *buf, off_t current, long lines)
/* */
673 {
674 lines = MAX (lines, 0);
675 current = edit_buffer_get_bol (buf, current);
676
677 while (lines-- != 0 && current != 0)
678 current = edit_buffer_get_bol (buf, current - 1);
679
680 return current;
681 }
682
683 /* --------------------------------------------------------------------------------------------- */
684 /**
685 * Load file into editor buffer
686 *
687 * @param buf pointer to editor buffer
688 * @param fd file descriptor
689 * @param size file size
690 *
691 * @return number of read bytes
692 */
693
694 off_t
695 edit_buffer_read_file (edit_buffer_t *buf, int fd, off_t size,
/* */
696 edit_buffer_read_file_status_msg_t *sm, gboolean *aborted)
697 {
698 off_t ret = 0;
699 off_t i, j;
700 off_t data_size;
701 void *b;
702 status_msg_t *s = STATUS_MSG (sm);
703 unsigned short update_cnt = 0;
704
705 *aborted = FALSE;
706
707 buf->lines = 0;
708 buf->curs2 = size;
709 i = buf->curs2 >> S_EDIT_BUF_SIZE;
710
711 /* fill last part of b2 */
712 data_size = buf->curs2 & M_EDIT_BUF_SIZE;
713 if (data_size != 0)
714 {
715 b = g_malloc0 (EDIT_BUF_SIZE);
716 g_ptr_array_add (buf->b2, b);
717 b = (char *) b + EDIT_BUF_SIZE - data_size;
718 ret = mc_read (fd, b, data_size);
719
720 /* count lines */
721 for (j = 0; j < ret; j++)
722 if (*((char *) b + j) == '\n')
723 buf->lines++;
724
725 if (ret < 0 || ret != data_size)
726 return ret;
727 }
728
729 /* fulfill other parts of b2 from end to begin */
730 data_size = EDIT_BUF_SIZE;
731 for (--i; i >= 0; i--)
732 {
733 off_t sz;
734
735 b = g_malloc0 (data_size);
736 g_ptr_array_add (buf->b2, b);
737 sz = mc_read (fd, b, data_size);
738 if (sz >= 0)
739 ret += sz;
740
741 /* count lines */
742 for (j = 0; j < sz; j++)
743 if (*((char *) b + j) == '\n')
744 buf->lines++;
745
746 if (s != NULL && s->update != NULL)
747 {
748 update_cnt = (update_cnt + 1) & 0xf;
749 if (update_cnt == 0)
750 {
751 /* FIXME: overcare */
752 if (sm->buf == NULL)
753 sm->buf = buf;
754
755 sm->loaded = ret;
756 if (s->update (s) == B_CANCEL)
757 {
758 *aborted = TRUE;
759 return (-1);
760 }
761 }
762 }
763
764 if (sz != data_size)
765 break;
766 }
767
768 /* reverse buffer */
769 for (i = 0; i < (off_t) buf->b2->len / 2; i++)
770 {
771 void **b1, **b2;
772
773 b1 = &g_ptr_array_index (buf->b2, i);
774 b2 = &g_ptr_array_index (buf->b2, buf->b2->len - 1 - i);
775
776 b = *b1;
777 *b1 = *b2;
778 *b2 = b;
779
780 if (s != NULL && s->update != NULL)
781 {
782 update_cnt = (update_cnt + 1) & 0xf;
783 if (update_cnt == 0)
784 {
785 sm->loaded = ret;
786 if (s->update (s) == B_CANCEL)
787 {
788 *aborted = TRUE;
789 return (-1);
790 }
791 }
792 }
793 }
794
795 return ret;
796 }
797
798 /* --------------------------------------------------------------------------------------------- */
799 /**
800 * Write editor buffer content to file
801 *
802 * @param buf pointer to editor buffer
803 * @param fd file descriptor
804 *
805 * @return number of written bytes
806 */
807
808 off_t
809 edit_buffer_write_file (edit_buffer_t *buf, int fd)
/* */
810 {
811 off_t ret = 0;
812 off_t i;
813 off_t data_size, sz;
814 void *b;
815
816 /* write all fulfilled parts of b1 from begin to end */
817 if (buf->b1->len != 0)
818 {
819 data_size = EDIT_BUF_SIZE;
820 for (i = 0; i < (off_t) buf->b1->len - 1; i++)
821 {
822 b = g_ptr_array_index (buf->b1, i);
823 sz = mc_write (fd, b, data_size);
824 if (sz >= 0)
825 ret += sz;
826 else if (i == 0)
827 ret = sz;
828 if (sz != data_size)
829 return ret;
830 }
831
832 /* write last partially filled part of b1 */
833 data_size = ((buf->curs1 - 1) & M_EDIT_BUF_SIZE) + 1;
834 b = g_ptr_array_index (buf->b1, i);
835 sz = mc_write (fd, b, data_size);
836 if (sz >= 0)
837 ret += sz;
838 if (sz != data_size)
839 return ret;
840 }
841
842 /* write b2 from end to begin, if b2 contains some data */
843 if (buf->b2->len != 0)
844 {
845 /* write last partially filled part of b2 */
846 i = buf->b2->len - 1;
847 b = g_ptr_array_index (buf->b2, i);
848 data_size = ((buf->curs2 - 1) & M_EDIT_BUF_SIZE) + 1;
849 sz = mc_write (fd, (char *) b + EDIT_BUF_SIZE - data_size, data_size);
850 if (sz >= 0)
851 ret += sz;
852
853 if (sz == data_size)
854 {
855 /* write other fulfilled parts of b2 from end to begin */
856 data_size = EDIT_BUF_SIZE;
857 while (--i >= 0)
858 {
859 b = g_ptr_array_index (buf->b2, i);
860 sz = mc_write (fd, b, data_size);
861 if (sz >= 0)
862 ret += sz;
863 if (sz != data_size)
864 break;
865 }
866 }
867 }
868
869 return ret;
870 }
871
872 /* --------------------------------------------------------------------------------------------- */
873 /**
874 * Calculate percentage of specified character offset
875 *
876 * @param buf pointer to editor buffer
877 * @param p character offset
878 *
879 * @return percentage of specified character offset
880 */
881
882 int
883 edit_buffer_calc_percent (const edit_buffer_t *buf, off_t offset)
/* ![[last]](../icons/n_last.png)
*/
884 {
885 int percent;
886
887 if (buf->size == 0)
888 percent = 0;
889 else if (offset >= buf->size)
890 percent = 100;
891 else if (offset > (INT_MAX / 100))
892 percent = offset / (buf->size / 100);
893 else
894 percent = offset * 100 / buf->size;
895
896 return percent;
897 }
898
899 /* --------------------------------------------------------------------------------------------- */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/