Debian Codegraph @

src/AsciiSrc.c

raw
1 /*
2
3 Copyright 1989, 1994, 1998 The Open Group
4
5 Permission to use, copy, modify, distribute, and sell this software and its
6 documentation for any purpose is hereby granted without fee, provided that
7 the above copyright notice appear in all copies and that both that
8 copyright notice and this permission notice appear in supporting
9 documentation.
10
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21 Except as contained in this notice, the name of The Open Group shall not be
22 used in advertising or otherwise to promote the sale, use or other dealings
23 in this Software without prior written authorization from The Open Group.
24
25 */
26
27 /*
28 * AsciiSrc.c - AsciiSrc object. (For use with the text widget).
29 *
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include <config.h>
34 #endif
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <ctype.h>
38 #include <errno.h>
39 #include <X11/IntrinsicP.h>
40 #include <X11/StringDefs.h>
41 #include <X11/Xos.h>
42 #include <X11/Xfuncs.h>
43 #include <X11/Xmu/CharSet.h>
44 #include <X11/Xmu/Misc.h>
45 #include <X11/Xaw/XawInit.h>
46 #include <X11/Xaw/AsciiSrcP.h>
47 #include <X11/Xaw/MultiSrcP.h>
48 #ifndef OLDXAW
49 #include <X11/Xaw/TextSinkP.h>
50 #include <X11/Xaw/AsciiSinkP.h>
51 #endif
52 #include "Private.h"
53
54 #include <sys/types.h>
55 #include <sys/stat.h>
56 #include <fcntl.h>
57
58 #ifndef O_CLOEXEC
59 #define O_CLOEXEC 0
60 #endif
61
62 #if (defined(ASCII_STRING) || defined(ASCII_DISK))
63 #include <X11/Xaw/AsciiText.h> /* for Widget Classes */
64 #endif
65
66 #define MAGIC_VALUE ((XawTextPosition)-1)
67 #define streq(a, b) (strcmp((a), (b)) == 0)
68
69 /*
70 * Class Methods
71 */
72 static void XawAsciiSrcClassInitialize(void);
73 static void XawAsciiSrcDestroy(Widget);
74 static void XawAsciiSrcGetValuesHook(Widget, ArgList, Cardinal*);
75 static void XawAsciiSrcInitialize(Widget, Widget, ArgList, Cardinal*);
76 static Boolean XawAsciiSrcSetValues(Widget, Widget, Widget,
77 ArgList, Cardinal*);
78 static XawTextPosition ReadText(Widget, XawTextPosition, XawTextBlock*, int);
79 static int ReplaceText(Widget, XawTextPosition, XawTextPosition,
80 XawTextBlock*);
81 static XawTextPosition Scan(Widget, XawTextPosition, XawTextScanType,
82 XawTextScanDirection, int, Bool);
83 static XawTextPosition Search(Widget, XawTextPosition, XawTextScanDirection,
84 XawTextBlock*);
85
86 /*
87 * Prototypes
88 */
89 static Piece *AllocNewPiece(AsciiSrcObject, Piece*);
90 static void BreakPiece(AsciiSrcObject, Piece*);
91 static Boolean CvtAsciiTypeToString(Display*, XrmValuePtr, Cardinal*,
92 XrmValuePtr, XrmValuePtr, XtPointer*);
93 static void CvtStringToAsciiType(XrmValuePtr, Cardinal*,
94 XrmValuePtr, XrmValuePtr);
95 static Piece *FindPiece(AsciiSrcObject, XawTextPosition, XawTextPosition*);
96 static void FreeAllPieces(AsciiSrcObject);
97 static FILE *InitStringOrFile(AsciiSrcObject, Bool);
98 static void LoadPieces(AsciiSrcObject, FILE*, char*);
99 static void RemoveOldStringOrFile(AsciiSrcObject, Bool);
100 static void RemovePiece(AsciiSrcObject, Piece*);
101 static char * StorePiecesInString(AsciiSrcObject);
102 static Bool WriteToFile(String, String, unsigned);
103 static Bool WritePiecesToFile(AsciiSrcObject, String);
104 static void GetDefaultPieceSize(Widget, int, XrmValue*);
105
106 /*
107 * More Prototypes
108 */
109 #ifdef ASCII_DISK
110 Widget XawAsciiDiskSourceCreate(Widget, ArgList, Cardinal);
111 #endif
112 #ifdef ASCII_STRING
113 Widget XawStringSourceCreate(Widget, ArgList, Cardinal);
114 void XawTextSetLastPos(Widget, XawTextPosition);
115 #endif
116
117 /*
118 * Initialization
119 */
120 #define offset(field) XtOffsetOf(AsciiSrcRec, ascii_src.field)
121 static XtResource resources[] = {
122 {
123 XtNstring,
124 XtCString,
125 XtRString,
126 sizeof(char*),
127 offset(string),
128 XtRString,
129 NULL
130 },
131 {
132 XtNtype,
133 XtCType,
134 XtRAsciiType,
135 sizeof(XawAsciiType),
136 offset(type),
137 XtRImmediate,
138 (XtPointer)XawAsciiString
139 },
140 {
141 XtNdataCompression,
142 XtCDataCompression,
143 XtRBoolean,
144 sizeof(Boolean),
145 offset(data_compression),
146 XtRImmediate,
147 (XtPointer)True
148 },
149 {
150 XtNpieceSize,
151 XtCPieceSize,
152 XtRInt,
153 sizeof(XawTextPosition),
154 offset(piece_size),
155 XtRCallProc,
156 (XtPointer)GetDefaultPieceSize
157 },
158 #ifdef OLDXAW
159 {
160 XtNcallback,
161 XtCCallback,
162 XtRCallback,
163 sizeof(XtPointer),
164 offset(callback),
165 XtRCallback,
166 (XtPointer)NULL
167 },
168 #endif
169 {
170 XtNuseStringInPlace,
171 XtCUseStringInPlace,
172 XtRBoolean,
173 sizeof(Boolean),
174 offset(use_string_in_place),
175 XtRImmediate,
176 (XtPointer)False
177 },
178 {
179 XtNlength,
180 XtCLength,
181 XtRInt,
182 sizeof(int),
183 offset(ascii_length),
184 XtRImmediate,
185 (XtPointer)MAGIC_VALUE
186 },
187 #ifdef ASCII_DISK
188 {
189 XtNfile,
190 XtCFile,
191 XtRString,
192 sizeof(String),
193 offset(filename),
194 XtRString,
195 NULL
196 },
197 #endif /* ASCII_DISK */
198 };
199 #undef offset
200
201
202 #define Superclass (&textSrcClassRec)
203 AsciiSrcClassRec asciiSrcClassRec = {
204 /* object */
205 {
206 (WidgetClass)Superclass, /* superclass */
207 "AsciiSrc", /* class_name */
208 sizeof(AsciiSrcRec), /* widget_size */
209 XawAsciiSrcClassInitialize, /* class_initialize */
210 NULL, /* class_part_initialize */
211 False, /* class_inited */
212 XawAsciiSrcInitialize, /* initialize */
213 NULL, /* initialize_hook */
214 NULL, /* realize */
215 NULL, /* actions */
216 0, /* num_actions */
217 resources, /* resources */
218 XtNumber(resources), /* num_resources */
219 NULLQUARK, /* xrm_class */
220 False, /* compress_motion */
221 False, /* compress_exposure */
222 False, /* compress_enterleave */
223 False, /* visible_interest */
224 XawAsciiSrcDestroy, /* destroy */
225 NULL, /* resize */
226 NULL, /* expose */
227 XawAsciiSrcSetValues, /* set_values */
228 NULL, /* set_values_hook */
229 NULL, /* set_values_almost */
230 XawAsciiSrcGetValuesHook, /* get_values_hook */
231 NULL, /* accept_focus */
232 XtVersion, /* version */
233 NULL, /* callback_private */
234 NULL, /* tm_table */
235 NULL, /* query_geometry */
236 NULL, /* display_accelerator */
237 NULL, /* extension */
238 },
239 /* text_src */
240 {
241 ReadText, /* Read */
242 ReplaceText, /* Replace */
243 Scan, /* Scan */
244 Search, /* Search */
245 XtInheritSetSelection, /* SetSelection */
246 XtInheritConvertSelection, /* ConvertSelection */
247 #ifndef OLDXAW
248 NULL,
249 #endif
250 },
251 /* ascii_src */
252 {
253 NULL, /* extension */
254 },
255 };
256
257 WidgetClass asciiSrcObjectClass = (WidgetClass)&asciiSrcClassRec;
258
259 static XrmQuark Qstring, Qfile;
260
261 /*
262 * Implementation
263 */
264 /*
265 * Function:
266 * XawAsciiSrcClassInitialize()
267 *
268 * Description:
269 * Initializes the asciiSrcObjectClass and install the converters for
270 * AsciiType <-> String.
271 */
272 static void
273 XawAsciiSrcClassInitialize(void)
274 {
275 XawInitializeWidgetSet();
276 Qstring = XrmPermStringToQuark(XtEstring);
277 Qfile = XrmPermStringToQuark(XtEfile);
278 XtAddConverter(XtRString, XtRAsciiType, CvtStringToAsciiType, NULL, 0);
279 XtSetTypeConverter(XtRAsciiType, XtRString, CvtAsciiTypeToString,
280 NULL, 0, XtCacheNone, NULL);
281 }
282
283 /*
284 * Function:
285 * XawAsciiSrcInitialize
286 *
287 * Parameters:
288 * request - widget requested by the argument list
289 * cnew - new widget with both resource and non resource values
290 * args - (unused)
291 * num_args - (unused)
292 *
293 * Description:
294 * Initializes the ascii src object.
295 */
296 /*ARGSUSED*/
297 static void
298 XawAsciiSrcInitialize(Widget request _X_UNUSED, Widget cnew,
299 ArgList args _X_UNUSED, Cardinal *num_args _X_UNUSED)
300 {
301 AsciiSrcObject src = (AsciiSrcObject)cnew;
302 FILE *file;
303
304 /*
305 * Set correct flags (override resources) depending upon widget class
306 */
307 src->text_src.text_format = (XrmQuark)XawFmt8Bit;
308
309 #ifdef ASCII_DISK
310 if (XtIsSubclass(XtParent(cnew), asciiDiskWidgetClass)) {
311 src->ascii_src.type = XawAsciiFile;
312 src->ascii_src.string = src->ascii_src.filename;
313 }
314 #endif
315
316 #ifdef ASCII_STRING
317 if (XtIsSubclass(XtParent(cnew), asciiStringWidgetClass)) {
318 src->ascii_src.use_string_in_place = True;
319 src->ascii_src.type = XawAsciiString;
320 }
321 #endif
322
323 #ifdef OLDXAW
324 src->ascii_src.changes = False;
325 #else
326 src->text_src.changed = False;
327 #endif
328 src->ascii_src.allocated_string = False;
329
330 if (src->ascii_src.use_string_in_place && src->ascii_src.string == NULL)
331 src->ascii_src.use_string_in_place = False;
332
333 file = InitStringOrFile(src, src->ascii_src.type == XawAsciiFile);
334 LoadPieces(src, file, NULL);
335
336 if (file != NULL)
337 fclose(file);
338 }
339
340 /*
341 * Function:
342 * ReadText
343 *
344 * Parameters:
345 * w - AsciiSource widget
346 * pos - position of the text to retrieve.
347 * text - text block that will contain returned text
348 * length - maximum number of characters to read
349 *
350 * Description:
351 * This function reads the source.
352 *
353 * Returns:
354 * The character position following the retrieved text.
355 */
356 static XawTextPosition
357 ReadText(Widget w, XawTextPosition pos, XawTextBlock *text, int length)
358 {
359 AsciiSrcObject src = (AsciiSrcObject)w;
360 XawTextPosition count, start;
361 Piece *piece;
362 #ifndef OLDXAW
363 XawTextAnchor *anchor;
364 XawTextEntity *entity;
365 XawTextPosition offset, end = pos + length;
366 Bool state;
367
368 end = XawMin(end, src->ascii_src.length);
369 while ((state = XawTextSourceAnchorAndEntity(w, pos, &anchor, &entity)) &&
370 (entity->flags & XAW_TENTF_HIDE))
371 pos = anchor->position + entity->offset + entity->length;
372 if (state == False ||
373 !(entity->flags & XAW_TENTF_REPLACE)) {
374 while (entity) {
375 offset = anchor->position + entity->offset;
376 if (offset >= end)
377 break;
378 if (offset > pos &&
379 (entity->flags & (XAW_TENTF_HIDE | XAW_TENTF_REPLACE))) {
380 end = XawMin(end, offset);
381 break;
382 }
383 if ((entity = entity->next) == NULL &&
384 (anchor = XawTextSourceNextAnchor(w, anchor)) != NULL)
385 entity = anchor->entities;
386 }
387 }
388 else if (state && (entity->flags & XAW_TENTF_REPLACE) && pos < end) {
389 XawTextBlock *block = (XawTextBlock*)entity->data;
390
391 offset = anchor->position + entity->offset;
392 end = XawMin(end, offset + block->length);
393 if ((length = (int)(end - pos)) < 0)
394 length = 0;
395 text->length = length;
396 text->format = XawFmt8Bit;
397 if (length == 0) {
398 text->firstPos = (int)(end = (offset + entity->length));
399 text->ptr = (char*)"";
400 }
401 else {
402 text->firstPos = (int)pos;
403 text->ptr = block->ptr + (pos - offset);
404 if (pos + length < offset + block->length)
405 end = pos + length; /* there is data left to be read */
406 else
407 end = offset + entity->length;
408 }
409
410 return (end);
411 }
412
413 if ((length = (int)(end - pos)) < 0)
414 length = 0;
415 #endif
416
417 piece = FindPiece(src, pos, &start);
418 text->firstPos = (int)pos;
419 text->ptr = piece->text + (pos - start);
420 count = piece->used - (pos - start);
421 text->length = (int)(Max(0, (length > count) ? count : length));
422 text->format = XawFmt8Bit;
423
424 return (pos + text->length);
425 }
426
427 /*
428 * Function:
429 * ReplaceText
430 *
431 * Parameters:
432 * w - AsciiSource object
433 * startPos - ends of text that will be replaced
434 * endPos - ""
435 * text - new text to be inserted into buffer at startPos
436 *
437 * Description:
438 * Replaces a block of text with new text.
439 *
440 * Returns:
441 * XawEditDone on success, XawEditError otherwise
442 */
443 /*ARGSUSED*/
444 static int
445 ReplaceText(Widget w, XawTextPosition startPos, XawTextPosition endPos,
446 XawTextBlock *text)
447 {
448 AsciiSrcObject src = (AsciiSrcObject)w;
449 Piece *start_piece, *end_piece, *temp_piece;
450 XawTextPosition start_first, end_first;
451 int length, firstPos;
452
453 /*
454 * Editing a read only source is not allowed
455 */
456 if (src->text_src.edit_mode == XawtextRead)
457 return (XawEditError);
458
459 if ((start_piece = FindPiece(src, startPos, &start_first)) == NULL)
460 return XawEditError;
461 if ((end_piece = FindPiece(src, endPos, &end_first)) == NULL)
462 return XawEditError;
463
464 #ifndef OLDXAW
465 /*
466 * This is a big hack, but I can't think about a clever way to know
467 * if the character being moved forward has a negative lbearing.
468 *
469 */
470 if (start_piece->used) {
471 int i;
472
473 for (i = 0; i < (int)src->text_src.num_text; i++) {
474 int line;
475 TextWidget ctx = (TextWidget)src->text_src.text[i];
476
477 for (line = 0; line < ctx->text.lt.lines; line++)
478 if (startPos < ctx->text.lt.info[line + 1].position)
479 break;
480 if (i < ctx->text.lt.lines &&
481 startPos > ctx->text.lt.info[i].position) {
482 AsciiSinkObject sink = (AsciiSinkObject)ctx->text.sink;
483 XawTextAnchor *anchor;
484 XawTextEntity *entity;
485 XawTextProperty *property;
486 XFontStruct *font;
487
488 if (XawTextSourceAnchorAndEntity(w, startPos, &anchor, &entity) &&
489 (property = XawTextSinkGetProperty(ctx->text.sink,
490 entity->property)) != NULL &&
491 (property->mask & XAW_TPROP_FONT))
492 font = property->font;
493 else
494 font = sink->ascii_sink.font;
495
496 if (font->min_bounds.lbearing < 0) {
497 int lbearing = font->min_bounds.lbearing;
498 unsigned char c = *(unsigned char*)
499 (start_piece->text + (startPos - start_first));
500
501 if (c == '\t' || c == '\n')
502 c = ' ';
503 else if ((c & 0177) < XawSP || c == 0177) {
504 if (sink->ascii_sink.display_nonprinting)
505 c = (unsigned char)(c > 0177 ? '\\' : c + '^');
506 else
507 c = ' ';
508 }
509 if (font->per_char &&
510 (c >= font->min_char_or_byte2 && c <= font->max_char_or_byte2))
511 lbearing = font->per_char[c - font->min_char_or_byte2].lbearing;
512 if (lbearing < 0)
513 _XawTextNeedsUpdating(ctx, startPos - 1, startPos);
514 }
515 }
516 }
517 }
518
519
520 #endif
521
522 /*
523 * Remove Old Stuff
524 */
525 if (start_piece != end_piece) {
526 if ((temp_piece = start_piece->next) == NULL)
527 return XawEditError;
528
529 /*
530 * If empty and not the only piece then remove it.
531 */
532 if (((start_piece->used = startPos - start_first) == 0)
533 && !(start_piece->next == NULL && start_piece->prev == NULL))
534 RemovePiece(src, start_piece);
535
536 while (temp_piece != end_piece) {
537 temp_piece = temp_piece->next;
538 RemovePiece(src, temp_piece->prev);
539 }
540
541 end_piece->used -= endPos - end_first;
542 if (end_piece->used != 0)
543 memmove(end_piece->text, end_piece->text + endPos - end_first,
544 (unsigned)end_piece->used);
545 }
546 else { /* We are fully in one piece */
547 if ((start_piece->used -= endPos - startPos) == 0) {
548 if (!(start_piece->next == NULL && start_piece->prev == NULL))
549 RemovePiece(src, start_piece);
550 }
551 else {
552 memmove(start_piece->text + (startPos - start_first),
553 start_piece->text + (endPos - start_first),
554 (unsigned)(start_piece->used - (startPos - start_first)));
555 if (src->ascii_src.use_string_in_place
556 && src->ascii_src.length - (endPos - startPos)
557 < src->ascii_src.piece_size - 1)
558 start_piece->text[src->ascii_src.length - (endPos - startPos)] =
559 '\0';
560 }
561 }
562
563 src->ascii_src.length += -(endPos - startPos) + text->length;
564
565 if ( text->length != 0) {
566 /*
567 * Put in the New Stuff
568 */
569 start_piece = FindPiece(src, startPos, &start_first);
570
571 length = text->length;
572 firstPos = text->firstPos;
573
574 while (length > 0) {
575 char *ptr;
576 int fill;
577
578 if (src->ascii_src.use_string_in_place) {
579 if (start_piece->used == src->ascii_src.piece_size - 1) {
580 /*
581 * If we are in ascii string emulation mode. Then the
582 * string is not allowed to grow
583 */
584 start_piece->used = src->ascii_src.length =
585 src->ascii_src.piece_size - 1;
586 start_piece->text[src->ascii_src.length] = '\0';
587 return (XawEditError);
588 }
589 }
590
591 if (start_piece->used == src->ascii_src.piece_size) {
592 BreakPiece(src, start_piece);
593 start_piece = FindPiece(src, startPos, &start_first);
594 }
595
596 fill = Min((int)(src->ascii_src.piece_size - start_piece->used),
597 length);
598
599 ptr = start_piece->text + (startPos - start_first);
600 memmove(ptr + fill, ptr,
601 (unsigned)(start_piece->used - (startPos - start_first)));
602 memcpy(ptr, text->ptr + firstPos, (unsigned)fill);
603
604 startPos += fill;
605 firstPos += fill;
606 start_piece->used += fill;
607 length -= fill;
608 }
609 }
610
611 if (src->ascii_src.use_string_in_place)
612 start_piece->text[start_piece->used] = '\0';
613
614 #ifdef OLDXAW
615 src->ascii_src.changes = True;
616 XtCallCallbacks(w, XtNcallback, NULL);
617 #endif
618
619 return (XawEditDone);
620 }
621
622 /*
623 * Function:
624 * Scan
625 *
626 * Parameters:
627 * w - AsciiSource object
628 * position - position to start scanning
629 * type - type of thing to scan for
630 * dir - direction to scan
631 * count - which occurrence if this thing to search for.
632 * include - whether or not to include the character found in
633 * the position that is returned
634 *
635 * Description:
636 * Scans the text source for the number and type of item specified.
637 *
638 * Returns:
639 * The position of the item found
640 *
641 * Note:
642 * While there are only 'n' characters in the file there are n+1
643 * possible cursor positions (one before the first character and
644 * one after the last character
645 */
646 static XawTextPosition
647 Scan(Widget w, register XawTextPosition position, XawTextScanType type,
648 XawTextScanDirection dir, int count, Bool include)
649 {
650 AsciiSrcObject src = (AsciiSrcObject)w;
651 Piece *piece;
652 XawTextPosition first, first_eol_position = 0;
653 register char *ptr, *lim;
654 register int cnt = count;
655 register unsigned char c;
656
657 if (dir == XawsdLeft) {
658 if (position <= 0)
659 return (0);
660 --position;
661 }
662 else if (position >= src->ascii_src.length)
663 return (src->ascii_src.length);
664
665 piece = FindPiece(src, position, &first);
666 if (piece->used == 0)
667 return (0);
668
669 ptr = (position - first) + piece->text;
670
671 if (dir == XawsdRight) {
672 lim = piece->text + piece->used;
673 switch (type) {
674 case XawstEOL:
675 case XawstParagraph:
676 case XawstWhiteSpace:
677 case XawstAlphaNumeric:
678 for (; cnt > 0; cnt--) {
679 Bool non_space = False, first_eol = True;
680
681 /*CONSTCOND*/
682 while (True) {
683 if (ptr >= lim) {
684 piece = piece->next;
685 if (piece == NULL) /* End of text */
686 return (src->ascii_src.length);
687 ptr = piece->text;
688 lim = piece->text + piece->used;
689 }
690
691 c = (unsigned char)*ptr++;
692 ++position;
693
694 if (type == XawstEOL) {
695 if (c == '\n')
696 break;
697 }
698 else if (type == XawstAlphaNumeric) {
699 if (!isalnum(c)) {
700 if (non_space)
701 break;
702 }
703 else
704 non_space = True;
705 }
706 else if (type == XawstWhiteSpace) {
707 if (isspace(c)) {
708 if (non_space)
709 break;
710 }
711 else
712 non_space = True;
713 }
714 else { /* XawstParagraph */
715 if (first_eol) {
716 if (c == '\n') {
717 first_eol_position = position;
718 first_eol = False;
719 }
720 }
721 else if (c == '\n')
722 break;
723 else if (!isspace(c))
724 first_eol = True;
725 }
726 }
727 }
728 break;
729 case XawstPositions:
730 position += count;
731 return (position < src->ascii_src.length ?
732 position : src->ascii_src.length);
733 case XawstAll:
734 return (src->ascii_src.length);
735 default:
736 break;
737 }
738 if (!include) {
739 if (type == XawstParagraph)
740 position = first_eol_position;
741 if (count)
742 --position;
743 }
744 }
745 else {
746 lim = piece->text;
747 switch (type) {
748 case XawstEOL:
749 case XawstParagraph:
750 case XawstWhiteSpace:
751 case XawstAlphaNumeric:
752 for (; cnt > 0; cnt--) {
753 Bool non_space = False, first_eol = True;
754
755 /*CONSTCOND*/
756 while (True) {
757 if (ptr < lim) {
758 piece = piece->prev;
759 if (piece == NULL) /* Beginning of text */
760 return (0);
761 ptr = piece->text + piece->used - 1;
762 lim = piece->text;
763 }
764
765 c = (unsigned char)*ptr--;
766 --position;
767
768 if (type == XawstEOL) {
769 if (c == '\n')
770 break;
771 }
772 else if (type == XawstAlphaNumeric) {
773 if (!isalnum(c)) {
774 if (non_space)
775 break;
776 }
777 else
778 non_space = True;
779 }
780 else if (type == XawstWhiteSpace) {
781 if (isspace(c)) {
782 if (non_space)
783 break;
784 }
785 else
786 non_space = True;
787 }
788 else { /* XawstParagraph */
789 if (first_eol) {
790 if (c == '\n') {
791 first_eol_position = position;
792 first_eol = False;
793 }
794 }
795 else if (c == '\n')
796 break;
797 else if (!isspace(c))
798 first_eol = True;
799 }
800 }
801 }
802 break;
803 case XawstPositions:
804 position -= count - 1;
805 return (position > 0 ? position : 0);
806 case XawstAll:
807 return (0);
808 default:
809 break;
810 }
811 if (!include) {
812 if (type == XawstParagraph)
813 position = first_eol_position;
814 if (count)
815 ++position;
816 }
817 position++;
818 }
819
820 return (position);
821 }
822
823 /*
824 * Function:
825 * Search
826 *
827 * Parameters:
828 * w - AsciiSource object
829 * position - the position to start scanning
830 * dir - direction to scan
831 * text - text block to search for
832 *
833 * Description:
834 * Searches the text source for the text block passed.
835 *
836 * Returns:
837 * The position of the item found
838 */
839 static XawTextPosition
840 Search(Widget w, register XawTextPosition position, XawTextScanDirection dir,
841 XawTextBlock *text)
842 {
843 AsciiSrcObject src = (AsciiSrcObject)w;
844 register int count = 0;
845 register char *ptr, c;
846 char *str;
847 Piece *piece;
848 char *buf;
849 XawTextPosition first;
850 int cnt, case_sensitive;
851
852 if (dir == XawsdLeft) {
853 if (position == 0)
854 return (XawTextSearchError);
855 position--;
856 }
857
858 buf = XtMalloc((unsigned)sizeof(unsigned char) * (unsigned)text->length);
859 memcpy(buf, text->ptr, (unsigned)text->length);
860 piece = FindPiece(src, position, &first);
861 ptr = (position - first) + piece->text;
862 case_sensitive = text->firstPos;
863
864 if (dir == XawsdRight) {
865 str = buf;
866 c = *str;
867 /*CONSTCOND*/
868 while (1) {
869 if (*ptr++ == c
870 || (case_sensitive && isalpha((unsigned char)c) && isalpha((unsigned char)ptr[-1])
871 && toupper((unsigned char)c) == toupper((unsigned char)ptr[-1]))) {
872 if (++count == text->length)
873 break;
874 c = *++str;
875 }
876 else if (count) {
877 ptr -= count;
878 str -= count;
879 position -= count;
880 count = 0;
881 c = *str;
882
883 if (ptr < piece->text) {
884 do {
885 cnt = (int)(piece->text - ptr);
886 piece = piece->prev;
887 if (piece == NULL) {
888 XtFree(buf);
889 return (XawTextSearchError);
890 }
891 ptr = piece->text + piece->used - cnt;
892 } while (ptr < piece->text);
893 }
894 }
895 position++;
896 if (ptr >= (piece->text + piece->used)) {
897 do {
898 cnt = (int)(ptr - (piece->text + piece->used));
899 piece = piece->next;
900 if (piece == NULL) {
901 XtFree(buf);
902 return (XawTextSearchError);
903 }
904 ptr = piece->text + cnt;
905 } while (ptr >= (piece->text + piece->used));
906 }
907 }
908
909 position -= text->length - 1;
910 }
911 else {
912 str = buf + text->length - 1;
913 c = *str;
914 /*CONSTCOND*/
915 while (1) {
916 if (*ptr-- == c
917 || (case_sensitive && isalpha((unsigned char)c) && isalpha((unsigned char)ptr[1])
918 && toupper((unsigned char)c) == toupper((unsigned char)ptr[1]))) {
919 if (++count == text->length)
920 break;
921 c = *--str;
922 }
923 else if (count) {
924 ptr += count;
925 str += count;
926 position += count;
927 count = 0;
928 c = *str;
929
930 if (ptr >= (piece->text + piece->used)) {
931 do {
932 cnt = (int)(ptr - (piece->text + piece->used));
933 piece = piece->next;
934 if (piece == NULL) {
935 XtFree(buf);
936 return (XawTextSearchError);
937 }
938 ptr = piece->text + cnt;
939 } while (ptr >= (piece->text + piece->used));
940 }
941 }
942 position--;
943 if (ptr < piece->text) {
944 do {
945 cnt = (int)(piece->text - ptr);
946 piece = piece->prev;
947 if (piece == NULL) {
948 XtFree(buf);
949 return (XawTextSearchError);
950 }
951 ptr = piece->text + piece->used - cnt;
952 } while (ptr < piece->text);
953 }
954 }
955 }
956
957 XtFree(buf);
958
959 return (position);
960 }
961
962 /*
963 * Function:
964 * XawAsciiSrcSetValues
965 *
966 * Parameters:
967 * current - current state of the widget
968 * request - what was requested
969 * cnew - what the widget will become
970 * args - representation of changed resources
971 * num_args - number of resources that have changed
972 *
973 * Description:
974 * Sets the values for the AsciiSource.
975 *
976 * Returns:
977 * True if redisplay is needed
978 */
979 static Boolean
980 XawAsciiSrcSetValues(Widget current, Widget request _X_UNUSED, Widget cnew,
981 ArgList args, Cardinal *num_args)
982 {
983 AsciiSrcObject src = (AsciiSrcObject)cnew;
984 AsciiSrcObject old_src = (AsciiSrcObject)current;
985 Bool total_reset = False, string_set = False;
986 Cardinal i;
987
988 if (old_src->ascii_src.use_string_in_place
989 != src->ascii_src.use_string_in_place) {
990 XtAppWarning(XtWidgetToApplicationContext(cnew),
991 "AsciiSrc: The XtNuseStringInPlace resource may "
992 "not be changed.");
993 src->ascii_src.use_string_in_place =
994 old_src->ascii_src.use_string_in_place;
995 }
996
997 for (i = 0; i < *num_args ; i++)
998 if (streq(args[i].name, XtNstring)) {
999 string_set = True;
1000 break;
1001 }
1002
1003 if (string_set || (old_src->ascii_src.type != src->ascii_src.type)) {
1004 FILE *file;
1005
1006 RemoveOldStringOrFile(old_src, string_set); /* remove old info */
1007 file = InitStringOrFile(src, string_set); /* Init new info */
1008 LoadPieces(src, file, NULL); /* load new info into internal buffers */
1009 if (file != NULL)
1010 fclose(file);
1011 #ifndef OLDXAW
1012 for (i = 0; i < src->text_src.num_text; i++)
1013 /* Tell text widget what happened */
1014 XawTextSetSource(src->text_src.text[i], cnew, 0);
1015 #else
1016 XawTextSetSource(XtParent(cnew), cnew, 0);
1017 #endif
1018 total_reset = True;
1019 }
1020
1021 if (old_src->ascii_src.ascii_length != src->ascii_src.ascii_length)
1022 src->ascii_src.piece_size = src->ascii_src.ascii_length + 1;
1023
1024 if (!total_reset &&
1025 old_src->ascii_src.piece_size != src->ascii_src.piece_size) {
1026 char * string = StorePiecesInString(old_src);
1027
1028 FreeAllPieces(old_src);
1029 LoadPieces(src, NULL, string);
1030 XtFree(string);
1031 }
1032
1033 return (False);
1034 }
1035
1036 /*
1037 * Function:
1038 * XawAsciiSrcGetValuesHook
1039 *
1040 * Parameters:
1041 * w - AsciiSource Widget
1042 * args - argument list
1043 * num_args - number of args
1044 *
1045 * Description:
1046 * This is a get values hook routine that sets the
1047 * values specific to the ascii source.
1048 */
1049 static void
1050 XawAsciiSrcGetValuesHook(Widget w, ArgList args, Cardinal *num_args)
1051 {
1052 AsciiSrcObject src = (AsciiSrcObject)w;
1053 Cardinal i;
1054
1055 if (src->ascii_src.type == XawAsciiString) {
1056 for (i = 0; i < *num_args ; i++)
1057 if (streq(args[i].name, XtNstring)) {
1058 if (src->ascii_src.use_string_in_place)
1059 *((char **)args[i].value) = src->ascii_src.first_piece->text;
1060 else if (XawAsciiSave(w)) /* If save successful */
1061 *((char **)args[i].value) = src->ascii_src.string;
1062 break;
1063 }
1064 }
1065 }
1066
1067 /*
1068 * Function:
1069 * XawAsciiSrcDestroy
1070 *
1071 * Parameters:
1072 * src - Ascii source object to free
1073 *
1074 * Description:
1075 * Destroys an ascii source (frees all data)
1076 */
1077 static void
1078 XawAsciiSrcDestroy(Widget w)
1079 {
1080 RemoveOldStringOrFile((AsciiSrcObject) w, True);
1081 }
1082
1083 /*
1084 * Public routines
1085 */
1086 /*
1087 * Function:
1088 * XawAsciiSourceFreeString
1089 *
1090 * Parameters:
1091 * w - AsciiSrc widget
1092 *
1093 * Description:
1094 * Frees the string returned by a get values call
1095 * on the string when the source is of type string.
1096 */
1097 void
1098 XawAsciiSourceFreeString(Widget w)
1099 {
1100 AsciiSrcObject src = (AsciiSrcObject)w;
1101
1102 /* If the src is really a multi, call the multi routine */
1103 if (XtIsSubclass(w, multiSrcObjectClass)) {
1104 _XawMultiSourceFreeString(w);
1105 return;
1106 }
1107 else if (!XtIsSubclass(w, asciiSrcObjectClass)) {
1108 XtErrorMsg("bad argument", "asciiSource", "XawError",
1109 "XawAsciiSourceFreeString's parameter must be "
1110 "an asciiSrc or multiSrc.",
1111 NULL, NULL);
1112 }
1113
1114 if (src->ascii_src.allocated_string && src->ascii_src.type != XawAsciiFile) {
1115 src->ascii_src.allocated_string = False;
1116 XtFree(src->ascii_src.string);
1117 src->ascii_src.string = NULL;
1118 }
1119 }
1120
1121 /*
1122 * Function:
1123 * XawAsciiSave
1124 *
1125 * Parameters:
1126 * w - asciiSrc Widget
1127 *
1128 * Description:
1129 * Saves all the pieces into a file or string as required.
1130 *
1131 * Returns:
1132 * True if the save was successful
1133 */
1134 Bool
1135 XawAsciiSave(Widget w)
1136 {
1137 AsciiSrcObject src = (AsciiSrcObject)w;
1138
1139 /* If the src is really a multi, call the multi save */
1140 if (XtIsSubclass(w, multiSrcObjectClass ))
1141 return (_XawMultiSave(w));
1142
1143 else if (!XtIsSubclass(w, asciiSrcObjectClass))
1144 XtErrorMsg("bad argument", "asciiSource", "XawError",
1145 "XawAsciiSave's parameter must be an asciiSrc or multiSrc.",
1146 NULL, NULL);
1147
1148 /*
1149 * If using the string in place then there is no need to play games
1150 * to get the internal info into a readable string.
1151 */
1152 if (src->ascii_src.use_string_in_place)
1153 return (True);
1154
1155 if (src->ascii_src.type == XawAsciiFile) {
1156 #ifdef OLDXAW
1157 if (!src->ascii_src.changes)
1158 #else
1159 if (!src->text_src.changed) /* No changes to save */
1160 #endif
1161 return (True);
1162
1163 if (WritePiecesToFile(src, src->ascii_src.string) == False)
1164 return (False);
1165 }
1166 else {
1167 if (src->ascii_src.allocated_string == True)
1168 XtFree(src->ascii_src.string);
1169 else
1170 src->ascii_src.allocated_string = True;
1171
1172 src->ascii_src.string = StorePiecesInString(src);
1173 }
1174 #ifdef OLDXAW
1175 src->ascii_src.changes = False;
1176 #else
1177 src->text_src.changed = False;
1178 #endif
1179
1180 return (True);
1181 }
1182
1183 /*
1184 * Function:
1185 * XawAsciiSaveAsFile
1186 *
1187 * Arguments:
1188 * w - AsciiSrc widget
1189 * name - name of the file to save this file into
1190 *
1191 * Description:
1192 * Save the current buffer as a file.
1193 *
1194 * Returns:
1195 * True if the save was successful
1196 */
1197 Bool
1198 XawAsciiSaveAsFile(Widget w, _Xconst char *name)
1199 {
1200 AsciiSrcObject src = (AsciiSrcObject)w;
1201 Bool ret;
1202
1203 /* If the src is really a multi, call the multi save */
1204
1205 if (XtIsSubclass( w, multiSrcObjectClass))
1206 return (_XawMultiSaveAsFile(w, name));
1207
1208 else if (!XtIsSubclass(w, asciiSrcObjectClass))
1209 XtErrorMsg("bad argument", "asciiSource", "XawError",
1210 "XawAsciiSaveAsFile's 1st parameter must be an "
1211 "asciiSrc or multiSrc.",
1212 NULL, NULL);
1213
1214 if (src->ascii_src.type == XawAsciiFile)
1215 ret = WritePiecesToFile(src, (String)name);
1216 else {
1217 char * string = StorePiecesInString(src);
1218
1219 ret = WriteToFile(string, (String)name, (unsigned)src->ascii_src.length);
1220 XtFree(string);
1221 }
1222
1223 return (ret);
1224 }
1225
1226 /*
1227 * Function:
1228 * XawAsciiSourceChanged
1229 *
1230 * Parameters:
1231 * w - ascii source widget
1232 *
1233 * Description:
1234 * Returns true if the source has changed since last saved.
1235 *
1236 * Returns:
1237 * A Boolean (see description).
1238 */
1239 Bool
1240 XawAsciiSourceChanged(Widget w)
1241 {
1242 #ifdef OLDXAW
1243 if (XtIsSubclass(w, multiSrcObjectClass))
1244 return (((MultiSrcObject)w)->multi_src.changes);
1245
1246 if (XtIsSubclass(w, asciiSrcObjectClass))
1247 return (((AsciiSrcObject)w)->ascii_src.changes);
1248 #else
1249 if (XtIsSubclass(w, textSrcObjectClass))
1250 return (((TextSrcObject)w)->textSrc.changed);
1251 #endif
1252 XtErrorMsg("bad argument", "asciiSource", "XawError",
1253 "XawAsciiSourceChanged parameter must be an "
1254 "asciiSrc or multiSrc.",
1255 NULL, NULL);
1256
1257 return (True);
1258 }
1259
1260 /*
1261 * Private Functions
1262 */
1263 static void
1264 RemoveOldStringOrFile(AsciiSrcObject src, Bool checkString)
1265 {
1266 FreeAllPieces(src);
1267
1268 if (checkString && src->ascii_src.allocated_string) {
1269 XtFree(src->ascii_src.string);
1270 src->ascii_src.allocated_string = False;
1271 src->ascii_src.string = NULL;
1272 }
1273 }
1274
1275 /*
1276 * Function:
1277 * WriteToFile
1278 *
1279 * Parameters:
1280 * string - string to write
1281 * name - the name of the file
1282 *
1283 * Description:
1284 * Write the string specified to the beginning of the file specified.
1285 *
1286 * Returns:
1287 * returns True if successful, False otherwise
1288 */
1289 static Bool
1290 WriteToFile(String string, String name, unsigned length)
1291 {
1292 int fd;
1293
1294 if ((fd = open(name, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0666)) == -1)
1295 return (False);
1296
1297 if (write(fd, string, length) == -1) {
1298 close(fd);
1299 return (False);
1300 }
1301
1302 if (close(fd) == -1)
1303 return (False);
1304
1305 return (True);
1306 }
1307
1308 /*
1309 * Function:
1310 * WritePiecesToFile
1311 *
1312 * Parameters:
1313 * src - ascii source object
1314 * name - name of the file
1315 *
1316 * Description:
1317 * Almost identical to WriteToFile, but only works for ascii src objects
1318 * of type XawAsciiFile. This function avoids allocating temporary memory,
1319 * what can be useful when editing very large files.
1320 *
1321 * Returns:
1322 * returns True if successful, False otherwise
1323 */
1324 static Bool
1325 WritePiecesToFile(AsciiSrcObject src, String name)
1326 {
1327 Piece *piece;
1328 int fd;
1329
1330 if (src->ascii_src.data_compression) {
1331 piece = src->ascii_src.first_piece;
1332 while (piece) {
1333 int bytes = (int)(src->ascii_src.piece_size - piece->used);
1334 Piece *tmp;
1335
1336 if (bytes > 0 && (tmp = piece->next) != NULL) {
1337 bytes = (int)(XawMin(bytes, tmp->used));
1338 memcpy(piece->text + piece->used, tmp->text, (size_t)bytes);
1339 memmove(tmp->text, tmp->text + bytes, (size_t)(tmp->used - bytes));
1340 piece->used += bytes;
1341 if ((tmp->used -= bytes) == 0) {
1342 RemovePiece(src, tmp);
1343 continue;
1344 }
1345 }
1346 piece = piece->next;
1347 }
1348 }
1349
1350 if ((fd = open(name, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0666)) == -1)
1351 return (False);
1352
1353 for (piece = src->ascii_src.first_piece; piece; piece = piece->next)
1354 if (write(fd, piece->text, (size_t)piece->used) == -1) {
1355 close(fd);
1356 return (False);
1357 }
1358
1359 if (close(fd) == -1)
1360 return (False);
1361
1362 return (True);
1363 }
1364
1365 /*
1366 * Function:
1367 * StorePiecesInString
1368 *
1369 * Parameters:
1370 * data - ascii pointer data
1371 *
1372 * Description:
1373 * Store the pieces in memory into a standard ascii string.
1374 */
1375 static char *
1376 StorePiecesInString(AsciiSrcObject src)
1377 {
1378 char * string;
1379 XawTextPosition first;
1380 Piece *piece;
1381
1382 string = XtMalloc((unsigned)(src->ascii_src.length + 1));
1383
1384 for (first = 0, piece = src->ascii_src.first_piece ; piece != NULL;
1385 first += piece->used, piece = piece->next)
1386 memcpy(string + first, piece->text, (unsigned)piece->used);
1387
1388 string[src->ascii_src.length] = '\0';
1389
1390 /*
1391 * This will refill all pieces to capacity
1392 */
1393 if (src->ascii_src.data_compression) {
1394 FreeAllPieces(src);
1395 LoadPieces(src, NULL, string);
1396 }
1397
1398 return (string);
1399 }
1400
1401 /*
1402 * Function:
1403 * InitStringOrFile
1404 *
1405 * Parameters:
1406 * src - AsciiSource
1407 *
1408 * Description:
1409 * Initializes the string or file.
1410 */
1411 static FILE *
1412 InitStringOrFile(AsciiSrcObject src, Bool newString)
1413 {
1414 mode_t open_mode = 0;
1415 const char *fdopen_mode = NULL;
1416
1417 if (src->ascii_src.type == XawAsciiString) {
1418 if (src->ascii_src.string == NULL)
1419 src->ascii_src.length = 0;
1420
1421 else if (!src->ascii_src.use_string_in_place) {
1422 src->ascii_src.string = XtNewString(src->ascii_src.string);
1423 src->ascii_src.allocated_string = True;
1424 src->ascii_src.length = (XawTextPosition)strlen(src->ascii_src.string);
1425 }
1426
1427 if (src->ascii_src.use_string_in_place) {
1428 if (src->ascii_src.string != NULL)
1429 src->ascii_src.length = (XawTextPosition)strlen(src->ascii_src.string);
1430 /* In case the length resource is incorrectly set */
1431 if (src->ascii_src.length > src->ascii_src.ascii_length)
1432 src->ascii_src.ascii_length = (int)src->ascii_src.length;
1433
1434 if (src->ascii_src.ascii_length == MAGIC_VALUE)
1435 src->ascii_src.piece_size = src->ascii_src.length;
1436 else
1437 src->ascii_src.piece_size = src->ascii_src.ascii_length + 1;
1438 }
1439
1440 return (NULL);
1441 }
1442
1443 /*
1444 * type is XawAsciiFile
1445 */
1446 src->ascii_src.is_tempfile = False;
1447
1448 switch (src->text_src.edit_mode) {
1449 case XawtextRead:
1450 if (src->ascii_src.string == NULL)
1451 XtErrorMsg("NoFile", "asciiSourceCreate", "XawError",
1452 "Creating a read only disk widget and no file specified.",
1453 NULL, NULL);
1454 open_mode = O_RDONLY | O_CLOEXEC;
1455 fdopen_mode = "r";
1456 break;
1457 case XawtextAppend:
1458 case XawtextEdit:
1459 if (src->ascii_src.string == NULL) {
1460 src->ascii_src.string = (char*)"*ascii-src*";
1461 src->ascii_src.is_tempfile = True;
1462 }
1463 else {
1464 /* O_NOFOLLOW was a FreeBSD & Linux extension, now adopted by POSIX */
1465 #ifdef O_NOFOLLOW
1466 open_mode = O_RDWR | O_NOFOLLOW | O_CLOEXEC;
1467 #else
1468 open_mode = O_RDWR; /* unsafe; subject to race conditions */
1469 #endif /* O_NOFOLLOW */
1470 fdopen_mode = "r+";
1471 }
1472 break;
1473 default:
1474 XtErrorMsg("badMode", "asciiSourceCreate", "XawError",
1475 "Bad editMode for ascii source; must be Read, "
1476 "Append or Edit.",
1477 NULL, NULL);
1478 }
1479
1480 /* If is_tempfile, allocate a private copy of the text
1481 * Unlikely to be changed, just to set allocated_string */
1482 if (newString || src->ascii_src.is_tempfile) {
1483 src->ascii_src.string = XtNewString(src->ascii_src.string);
1484 src->ascii_src.allocated_string = True;
1485 }
1486
1487 if (!src->ascii_src.is_tempfile) {
1488 int fd = open(src->ascii_src.string, (int)open_mode, 0666);
1489
1490 if (fd != -1) {
1491 FILE *file = fdopen(fd, fdopen_mode);
1492
1493 if (file != NULL) {
1494 (void)fseek(file, 0, SEEK_END);
1495 src->ascii_src.length = (XawTextPosition)ftell(file);
1496 return (file);
1497 }
1498 else
1499 close(fd);
1500 }
1501 {
1502 String params[2];
1503 Cardinal num_params = 2;
1504
1505 params[0] = src->ascii_src.string;
1506 params[1] = strerror(errno);
1507 XtAppWarningMsg(XtWidgetToApplicationContext((Widget)src),
1508 "openError", "asciiSourceCreate", "XawWarning",
1509 "Cannot open file %s; %s", params, &num_params);
1510 }
1511 }
1512 src->ascii_src.length = 0;
1513 return (NULL);
1514 }
1515
1516 static void
1517 LoadPieces(AsciiSrcObject src, FILE *file, char *string)
1518 {
1519 char *ptr;
1520 Piece *piece = NULL;
1521 XawTextPosition left;
1522
1523 if (string == NULL) {
1524 if (src->ascii_src.type == XawAsciiFile) {
1525 if (src->ascii_src.length != 0) {
1526 left = 0;
1527 fseek(file, 0, SEEK_SET);
1528 while (left < src->ascii_src.length) {
1529 int len;
1530
1531 ptr = XtMalloc((unsigned)src->ascii_src.piece_size);
1532 if ((len = (int)fread(ptr, sizeof(unsigned char),
1533 (size_t)src->ascii_src.piece_size, file)) < 0)
1534 XtErrorMsg("readError", "asciiSourceCreate", "XawError",
1535 "fread returned error.", NULL, NULL);
1536 piece = AllocNewPiece(src, piece);
1537 piece->text = ptr;
1538 piece->used = XawMin(len, src->ascii_src.piece_size);
1539 left += piece->used;
1540 }
1541 }
1542 else {
1543 piece = AllocNewPiece(src, NULL);
1544 piece->text = XtMalloc((unsigned)src->ascii_src.piece_size);
1545 piece->used = 0;
1546 }
1547 return;
1548 }
1549 else
1550 string = src->ascii_src.string;
1551 }
1552
1553 if (src->ascii_src.use_string_in_place) {
1554 piece = AllocNewPiece(src, piece);
1555 piece->used = XawMin(src->ascii_src.length, src->ascii_src.piece_size);
1556 piece->text = src->ascii_src.string;
1557 return;
1558 }
1559
1560 ptr = string;
1561 left = src->ascii_src.length;
1562 do {
1563 piece = AllocNewPiece(src, piece);
1564
1565 piece->text = XtMalloc((unsigned)src->ascii_src.piece_size);
1566 piece->used = XawMin(left, src->ascii_src.piece_size);
1567 if (piece->used != 0)
1568 memcpy(piece->text, ptr, (unsigned)piece->used);
1569
1570 left -= piece->used;
1571 ptr += piece->used;
1572 } while (left > 0);
1573 }
1574
1575 /*
1576 * Function:
1577 * AllocNewPiece
1578 *
1579 * Parameters:
1580 * src - AsciiSrc Widget
1581 * prev - piece just before this one, or NULL
1582 *
1583 * Description:
1584 * Allocates a new piece of memory.
1585 *
1586 * Returns:
1587 * The allocated piece
1588 */
1589 static Piece *
1590 AllocNewPiece(AsciiSrcObject src, Piece *prev)
1591 {
1592 Piece *piece = XtNew(Piece);
1593
1594 if (prev == NULL) {
1595 src->ascii_src.first_piece = piece;
1596 piece->next = NULL;
1597 }
1598 else {
1599 if (prev->next != NULL)
1600 (prev->next)->prev = piece;
1601 piece->next = prev->next;
1602 prev->next = piece;
1603 }
1604
1605 piece->prev = prev;
1606
1607 return (piece);
1608 }
1609
1610 /*
1611 * Function:
1612 * FreeAllPieces
1613 *
1614 * Parameters:
1615 * src - AsciiSrc Widget
1616 *
1617 * Description:
1618 * Frees all the pieces.
1619 */
1620 static void
1621 FreeAllPieces(AsciiSrcObject src)
1622 {
1623 Piece *next, * first = src->ascii_src.first_piece;
1624
1625 #ifdef DEBUG
1626 if (first->prev != NULL)
1627 printf("Xaw AsciiSrc Object: possible memory leak in FreeAllPieces().\n");
1628 #endif
1629
1630 for (; first != NULL ; first = next) {
1631 next = first->next;
1632 RemovePiece(src, first);
1633 }
1634 }
1635
1636 /*
1637 * Function:
1638 * RemovePiece
1639 *
1640 * Parameters:
1641 * piece - piece to remove
1642 *
1643 * Description:
1644 * Removes a piece from the list.
1645 */
1646 static void
1647 RemovePiece(AsciiSrcObject src, Piece *piece)
1648 {
1649 if (piece->prev == NULL)
1650 src->ascii_src.first_piece = piece->next;
1651 else
1652 piece->prev->next = piece->next;
1653
1654 if (piece->next != NULL)
1655 piece->next->prev = piece->prev;
1656
1657 if (!src->ascii_src.use_string_in_place)
1658 XtFree(piece->text);
1659
1660 XtFree((char *)piece);
1661 }
1662
1663 /*
1664 * Function:
1665 * FindPiece
1666 *
1667 * Parameters:
1668 * src - AsciiSrc Widget
1669 * position - position that we are searching for
1670 * first - position of the first character in this piece (return)
1671 *
1672 * Description:
1673 * Finds the piece containing the position indicated.
1674 *
1675 * Returns:
1676 * the piece that contains this position
1677 */
1678 static Piece *
1679 FindPiece(AsciiSrcObject src, XawTextPosition position, XawTextPosition *first)
1680 {
1681 Piece *old_piece, *piece;
1682 XawTextPosition temp;
1683
1684 for (old_piece = NULL, piece = src->ascii_src.first_piece, temp = 0;
1685 piece; old_piece = piece, piece = piece->next)
1686 if ((temp += piece->used) > position) {
1687 *first = temp - piece->used;
1688 return (piece);
1689 }
1690
1691 *first = temp - (old_piece ? old_piece->used : 0);
1692
1693 return (old_piece); /* if we run off the end the return the last piece */
1694 }
1695
1696 /*
1697 * Function:
1698 * BreakPiece
1699 *
1700 * Parameters:
1701 * src - AsciiSrc Widget
1702 * piece - piece to break
1703 *
1704 * Description:
1705 * Breaks a full piece into two new pieces.
1706 */
1707 #define HALF_PIECE (src->ascii_src.piece_size >> 1)
1708 static void
1709 BreakPiece(AsciiSrcObject src, Piece *piece)
1710 {
1711 Piece *cnew = AllocNewPiece(src, piece);
1712
1713 cnew->text = XtMalloc((unsigned)src->ascii_src.piece_size);
1714 memcpy(cnew->text, piece->text + HALF_PIECE,
1715 (unsigned)(src->ascii_src.piece_size - HALF_PIECE));
1716 piece->used = HALF_PIECE;
1717 cnew->used = src->ascii_src.piece_size - HALF_PIECE;
1718 }
1719
1720 /*ARGSUSED*/
1721 static void
1722 CvtStringToAsciiType(XrmValuePtr args _X_UNUSED, Cardinal *num_args _X_UNUSED,
1723 XrmValuePtr fromVal, XrmValuePtr toVal)
1724 {
1725 static XawAsciiType type;
1726 XrmQuark q;
1727 char name[7];
1728
1729 XmuNCopyISOLatin1Lowered(name, (char *)fromVal->addr, sizeof(name));
1730 q = XrmStringToQuark(name);
1731
1732 if (q == Qstring)
1733 type = XawAsciiString;
1734 else if (q == Qfile)
1735 type = XawAsciiFile;
1736 else {
1737 toVal->size = 0;
1738 toVal->addr = NULL;
1739 XtStringConversionWarning((char *)fromVal->addr, XtRAsciiType);
1740 }
1741
1742 toVal->size = sizeof(XawAsciiType);
1743 toVal->addr = (XPointer)&type;
1744 }
1745
1746 /*ARGSUSED*/
1747 static Boolean
1748 CvtAsciiTypeToString(Display *dpy, XrmValuePtr args _X_UNUSED, Cardinal *num_args _X_UNUSED,
1749 XrmValuePtr fromVal, XrmValuePtr toVal,
1750 XtPointer *data _X_UNUSED)
1751 {
1752 static String buffer;
1753 Cardinal size;
1754
1755 switch (*(XawAsciiType *)fromVal->addr) {
1756 case XawAsciiFile:
1757 buffer = XtEfile;
1758 break;
1759 case XawAsciiString:
1760 buffer = XtEstring;
1761 break;
1762 default:
1763 XawTypeToStringWarning(dpy, XtRAsciiType);
1764 toVal->addr = NULL;
1765 toVal->size = 0;
1766 return (False);
1767 }
1768
1769 size = (Cardinal)(strlen(buffer) + 1);
1770 if (toVal->addr != NULL) {
1771 if (toVal->size < size) {
1772 toVal->size = size;
1773 return (False);
1774 }
1775 strcpy((char *)toVal->addr, buffer);
1776 }
1777 else
1778 toVal->addr = (XPointer)buffer;
1779 toVal->size = sizeof(String);
1780
1781 return (True);
1782 }
1783
1784 /*ARGSUSED*/
1785 static void
1786 GetDefaultPieceSize(Widget w _X_UNUSED, int offset _X_UNUSED, XrmValue *value)
1787 {
1788 static XPointer pagesize;
1789
1790 if (pagesize == NULL) {
1791 pagesize = (XPointer)((long)_XawGetPageSize());
1792 if (pagesize < (XPointer)BUFSIZ)
1793 pagesize = (XPointer)BUFSIZ;
1794 }
1795
1796 value->addr = (XPointer)&pagesize;
1797 }
1798
1799 #if (defined(ASCII_STRING) || defined(ASCII_DISK))
1800 # include <X11/Xaw/Cardinals.h>
1801 #endif
1802
1803 #ifdef ASCII_STRING
1804 /*
1805 * Compatibility functions.
1806 */
1807 /*
1808 * Function:
1809 * AsciiStringSourceCreate
1810 *
1811 * Parameters:
1812 * parent - widget that will own this source
1813 * args - the argument list
1814 * num_args - ""
1815 *
1816 * Description:
1817 * Creates a string source.
1818 *
1819 * Returns:
1820 * A pointer to the new text source.
1821 */
1822 Widget
1823 XawStringSourceCreate(Widget parent, ArgList args, Cardinal num_args)
1824 {
1825 XawTextSource src;
1826 ArgList ascii_args;
1827 Arg temp[2];
1828
1829 XtSetArg(temp[0], XtNtype, XawAsciiString);
1830 XtSetArg(temp[1], XtNuseStringInPlace, True);
1831 ascii_args = XtMergeArgLists(temp, TWO, args, num_args);
1832
1833 src = XtCreateWidget("genericAsciiString", asciiSrcObjectClass, parent,
1834 ascii_args, num_args + TWO);
1835 XtFree((char *)ascii_args);
1836
1837 return (src);
1838 }
1839
1840 /*
1841 * This is hacked up to try to emulate old functionality, it
1842 * may not work, as I have not old code to test it on.
1843 *
1844 * Chris D. Peterson 8/31/89.
1845 */
1846 void
1847 XawTextSetLastPos(Widget w, XawTextPosition lastPos)
1848 {
1849 AsciiSrcObject src = (AsciiSrcObject)XawTextGetSource(w);
1850
1851 src->ascii_src.piece_size = lastPos;
1852 }
1853 #endif /* ASCII_STRING */
1854
1855 #ifdef ASCII_DISK
1856 /*
1857 * Function:
1858 * AsciiDiskSourceCreate
1859 *
1860 * Parameters:
1861 * parent - widget that will own this source
1862 * args - argument list
1863 * num_args - ""
1864 *
1865 * Description:
1866 * Creates a disk source.
1867 *
1868 * Returns:
1869 * A pointer to the new text source
1870 */
1871 Widget
1872 XawDiskSourceCreate(Widget parent, ArgList args, Cardinal num_args)
1873 {
1874 XawTextSource src;
1875 ArgList ascii_args;
1876 Arg temp[1];
1877 int i;
1878
1879 XtSetArg(temp[0], XtNtype, XawAsciiFile);
1880 ascii_args = XtMergeArgLists(temp, ONE, args, num_args);
1881 num_args++;
1882
1883 for (i = 0; i < num_args; i++)
1884 if (streq(ascii_args[i].name, XtNfile)
1885 || streq(ascii_args[i].name, XtCFile))
1886 ascii_args[i].name = XtNstring;
1887
1888 src = XtCreateWidget("genericAsciiDisk", asciiSrcObjectClass, parent,
1889 ascii_args, num_args);
1890 XtFree((char *)ascii_args);
1891
1892 return (src);
1893 }
1894 #endif /* ASCII_DISK */