components/x11/libXaw5/src/AsciiSrc.c

   1 /* $XConsortium: AsciiSrc.c,v 1.66 95/01/16 20:10:20 kaleb Exp $ */
   2
   3 /*
   4
   5 Copyright (c) 1989, 1994  X Consortium
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a copy
   8 of this software and associated documentation files (the "Software"), to deal
   9 in the Software without restriction, including without limitation the rights
  10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 copies of the Software, and to permit persons to whom the Software is
  12 furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice shall be included in
  15 all copies or substantial portions of the Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  20 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24 Except as contained in this notice, the name of the X Consortium shall not be
  25 used in advertising or otherwise to promote the sale, use or other dealings
  26 in this Software without prior written authorization from the X Consortium.
  27
  28 */
  29
  30 /*
  31  * AsciiSrc.c - AsciiSrc object. (For use with the text widget).
  32  *
  33  */
  34
  35 #include <X11/IntrinsicP.h>
  36 #include <stdio.h>
  37 #include <ctype.h>
  38 #include <errno.h>
  39 #include <X11/StringDefs.h>
  40 #include <X11/Xos.h>
  41 #ifndef X_NOT_STDC_ENV
  42 #include <stdlib.h>
  43 #endif
  44 #include <X11/Xfuncs.h>
  45 #include "XawInit.h"
  46 #include "AsciiSrcP.h"
  47 #include <X11/Xmu/Misc.h>
  48 #include <X11/Xmu/CharSet.h>
  49 #include "MultiSrcP.h"
  50
  51
  52 #if (defined(ASCII_STRING) || defined(ASCII_DISK))
  53 #  include "AsciiText.h" /* for Widget Classes. */
  54 #endif
  55
  56
  57 /****************************************************************
  58  *
  59  * Full class record constant
  60  *
  61  ****************************************************************/
  62
  63 /* Private Data */
  64
  65 static int magic_value = MAGIC_VALUE;
  66
  67 #define offset(field) XtOffsetOf(AsciiSrcRec, ascii_src.field)
  68
  69 static XtResource resources[] = {
  70     {XtNstring, XtCString, XtRString, sizeof (char *),
  71        offset(string), XtRString, NULL},
  72     {XtNtype, XtCType, XtRAsciiType, sizeof (XawAsciiType),
  73        offset(type), XtRImmediate, (XtPointer)XawAsciiString},
  74     {XtNdataCompression, XtCDataCompression, XtRBoolean, sizeof (Boolean),
  75        offset(data_compression), XtRImmediate, (XtPointer) TRUE},
  76     {XtNpieceSize, XtCPieceSize, XtRInt, sizeof (XawTextPosition),
  77        offset(piece_size), XtRImmediate, (XtPointer) BUFSIZ},
  78     {XtNcallback, XtCCallback, XtRCallback, sizeof(XtPointer),
  79        offset(callback), XtRCallback, (XtPointer)NULL},
  80     {XtNuseStringInPlace, XtCUseStringInPlace, XtRBoolean, sizeof (Boolean),
  81        offset(use_string_in_place), XtRImmediate, (XtPointer) FALSE},
  82     {XtNlength, XtCLength, XtRInt, sizeof (int),
  83        offset(ascii_length), XtRInt, (XtPointer) &magic_value},
  84
  85 #ifdef ASCII_DISK
  86     {XtNfile, XtCFile, XtRString, sizeof (String),
  87        offset(filename), XtRString, NULL},
  88 #endif /* ASCII_DISK */
  89 };
  90 #undef offset
  91
  92 static XawTextPosition Scan(), Search(), ReadText();
  93 static int ReplaceText();
  94 static Piece * FindPiece(), * AllocNewPiece();
  95 static FILE * InitStringOrFile();
  96 static void FreeAllPieces(), RemovePiece(), BreakPiece(), LoadPieces();
  97 static void RemoveOldStringOrFile(),  CvtStringToAsciiType();
  98 static void ClassInitialize(), Initialize(), Destroy(), GetValuesHook();
  99 static String MyStrncpy(), StorePiecesInString();
 100 static Boolean SetValues(), WriteToFile();
 101 #ifdef X_NOT_STDC_ENV
 102 extern int errno;
 103 #endif
 104
 105 #ifdef X_NOT_POSIX
 106 #define Off_t long
 107 #define Size_t unsigned int
 108 #else
 109 #define Off_t off_t
 110 #define Size_t size_t
 111 #endif
 112
 113 #define superclass              (&textSrcClassRec)
 114 AsciiSrcClassRec asciiSrcClassRec = {
 115   {
 116 /* core_class fields */
 117     /* superclass               */      (WidgetClass) superclass,
 118     /* class_name               */      "AsciiSrc",
 119     /* widget_size              */      sizeof(AsciiSrcRec),
 120     /* class_initialize         */      ClassInitialize,
 121     /* class_part_initialize    */      NULL,
 122     /* class_inited             */      FALSE,
 123     /* initialize               */      Initialize,
 124     /* initialize_hook          */      NULL,
 125     /* realize                  */      NULL,
 126     /* actions                  */      NULL,
 127     /* num_actions              */      0,
 128     /* resources                */      resources,
 129     /* num_resources            */      XtNumber(resources),
 130     /* xrm_class                */      NULLQUARK,
 131     /* compress_motion          */      FALSE,
 132     /* compress_exposure        */      FALSE,
 133     /* compress_enterleave      */      FALSE,
 134     /* visible_interest         */      FALSE,
 135     /* destroy                  */      Destroy,
 136     /* resize                   */      NULL,
 137     /* expose                   */      NULL,
 138     /* set_values               */      SetValues,
 139     /* set_values_hook          */      NULL,
 140     /* set_values_almost        */      NULL,
 141     /* get_values_hook          */      GetValuesHook,
 142     /* accept_focus             */      NULL,
 143     /* version                  */      XtVersion,
 144     /* callback_private         */      NULL,
 145     /* tm_table                 */      NULL,
 146     /* query_geometry           */      NULL,
 147     /* display_accelerator      */      NULL,
 148     /* extension                */      NULL
 149   },
 150 /* textSrc_class fields */
 151   {
 152     /* Read                     */      ReadText,
 153     /* Replace                  */      ReplaceText,
 154     /* Scan                     */      Scan,
 155     /* Search                   */      Search,
 156     /* SetSelection             */      XtInheritSetSelection,
 157     /* ConvertSelection         */      XtInheritConvertSelection
 158   },
 159 /* asciiSrc_class fields */
 160   {
 161     /* Keep the compiler happy */       '\0'
 162   }
 163 };
 164
 165 WidgetClass asciiSrcObjectClass = (WidgetClass)&asciiSrcClassRec;
 166
 167 /************************************************************
 168  *
 169  * Semi-Public Interfaces.
 170  *
 171  ************************************************************/
 172
 173 /*      Function Name: ClassInitialize
 174  *      Description: Class Initialize routine, called only once.
 175  *      Arguments: none.
 176  *      Returns: none.
 177  */
 178
 179 static void
 180 ClassInitialize()
 181 {
 182   XawInitializeWidgetSet();
 183   XtAddConverter( XtRString, XtRAsciiType, CvtStringToAsciiType,
 184                  NULL, (Cardinal) 0);
 185 }
 186
 187 /*      Function Name: Initialize
 188  *      Description: Initializes the simple menu widget
 189  *      Arguments: request - the widget requested by the argument list.
 190  *                 new     - the new widget with both resource and non
 191  *                           resource values.
 192  *      Returns: none.
 193  */
 194
 195 /* ARGSUSED */
 196 static void
 197 Initialize(request, new, args, num_args)
 198 Widget request, new;
 199 ArgList args;
 200 Cardinal *num_args;
 201 {
 202   AsciiSrcObject src = (AsciiSrcObject) new;
 203   FILE * file;
 204
 205 /*
 206  * Set correct flags (override resources) depending upon widget class.
 207  */
 208
 209   src->text_src.text_format = XawFmt8Bit;       /* data format. */
 210
 211 #ifdef ASCII_DISK
 212   if (XtIsSubclass(XtParent(new), asciiDiskWidgetClass)) {
 213     src->ascii_src.type = XawAsciiFile;
 214     src->ascii_src.string = src->ascii_src.filename;
 215   }
 216 #endif
 217
 218 #ifdef ASCII_STRING
 219   if (XtIsSubclass(XtParent(new), asciiStringWidgetClass)) {
 220     src->ascii_src.use_string_in_place = TRUE;
 221     src->ascii_src.type = XawAsciiString;
 222   }
 223 #endif
 224
 225   src->ascii_src.changes = FALSE;
 226   src->ascii_src.allocated_string = FALSE;
 227
 228   file = InitStringOrFile(src, src->ascii_src.type == XawAsciiFile);
 229   LoadPieces(src, file, NULL);
 230
 231   if (file != NULL) fclose(file);
 232 }
 233
 234 /*      Function Name: ReadText
 235  *      Description: This function reads the source.
 236  *      Arguments: w - the AsciiSource widget.
 237  *                 pos - position of the text to retreive.
 238  * RETURNED        text - text block that will contain returned text.
 239  *                 length - maximum number of characters to read.
 240  *      Returns: The number of characters read into the buffer.
 241  */
 242
 243 static XawTextPosition
 244 ReadText(w, pos, text, length)
 245 Widget w;
 246 XawTextPosition pos;
 247 XawTextBlock *text;
 248 int length;
 249 {
 250   AsciiSrcObject src = (AsciiSrcObject) w;
 251   XawTextPosition count, start;
 252   Piece * piece = FindPiece(src, pos, &start);
 253
 254   text->firstPos = pos;
 255   text->ptr = piece->text + (pos - start);
 256   count = piece->used - (pos - start);
 257   text->length = (length > (int)count) ? count : length;
 258   return(pos + text->length);
 259 }
 260
 261 /*      Function Name: ReplaceText.
 262  *      Description: Replaces a block of text with new text.
 263  *      Arguments: w - the AsciiSource widget.
 264  *                 startPos, endPos - ends of text that will be removed.
 265  *                 text - new text to be inserted into buffer at startPos.
 266  *      Returns: XawEditError or XawEditDone.
 267  */
 268
 269 /*ARGSUSED*/
 270 static int
 271 ReplaceText (w, startPos, endPos, text)
 272 Widget w;
 273 XawTextPosition startPos, endPos;
 274 XawTextBlock *text;
 275 {
 276   AsciiSrcObject src = (AsciiSrcObject) w;
 277   Piece *start_piece, *end_piece, *temp_piece;
 278   XawTextPosition start_first, end_first;
 279   int length, firstPos;
 280
 281 /*
 282  * Editing a read only source is not allowed.
 283  */
 284
 285   if (src->text_src.edit_mode == XawtextRead)
 286     return(XawEditError);
 287
 288   start_piece = FindPiece(src, startPos, &start_first);
 289   end_piece = FindPiece(src, endPos, &end_first);
 290
 291   src->ascii_src.changes = TRUE; /* We have changed the buffer. */
 292
 293 /*
 294  * Remove Old Stuff.
 295  */
 296
 297   if (start_piece != end_piece) {
 298     temp_piece = start_piece->next;
 299
 300 /*
 301  * If empty and not the only piece then remove it.
 302  */
 303
 304     if ( ((start_piece->used = startPos - start_first) == 0) &&
 305          !((start_piece->next == NULL) && (start_piece->prev == NULL)) )
 306       RemovePiece(src, start_piece);
 307
 308     while (temp_piece != end_piece) {
 309       temp_piece = temp_piece->next;
 310       RemovePiece(src, temp_piece->prev);
 311     }
 312     end_piece->used -= endPos - end_first;
 313     if (end_piece->used != 0)
 314       MyStrncpy(end_piece->text, (end_piece->text + endPos - end_first),
 315                 (int) end_piece->used);
 316   }
 317   else {                        /* We are fully in one piece. */
 318     if ( (start_piece->used -= endPos - startPos) == 0) {
 319       if ( !((start_piece->next == NULL) && (start_piece->prev == NULL)) )
 320         RemovePiece(src, start_piece);
 321     }
 322     else {
 323       MyStrncpy(start_piece->text + (startPos - start_first),
 324                 start_piece->text + (endPos - start_first),
 325                 (int) (start_piece->used - (startPos - start_first)) );
 326       if ( src->ascii_src.use_string_in_place &&
 327            ((src->ascii_src.length - (endPos - startPos)) <
 328             (src->ascii_src.piece_size - 1)) )
 329         start_piece->text[src->ascii_src.length - (endPos - startPos)] = '\0';
 330     }
 331   }
 332
 333   src->ascii_src.length += -(endPos - startPos) + text->length;
 334
 335   if ( text->length != 0) {
 336
 337     /*
 338      * Put in the New Stuff.
 339      */
 340
 341     start_piece = FindPiece(src, startPos, &start_first);
 342
 343     length = text->length;
 344     firstPos = text->firstPos;
 345
 346     while (length > 0) {
 347       char * ptr;
 348       int fill;
 349
 350       if (src->ascii_src.use_string_in_place) {
 351         if (start_piece->used == (src->ascii_src.piece_size - 1)) {
 352           /*
 353            * If we are in ascii string emulation mode. Then the
 354            *  string is not allowed to grow.
 355            */
 356           start_piece->used = src->ascii_src.length =
 357                                                  src->ascii_src.piece_size - 1;
 358           start_piece->text[src->ascii_src.length] = '\0';
 359           return(XawEditError);
 360         }
 361       }
 362
 363
 364       if (start_piece->used == src->ascii_src.piece_size) {
 365         BreakPiece(src, start_piece);
 366         start_piece = FindPiece(src, startPos, &start_first);
 367       }
 368
 369       fill = Min((int)(src->ascii_src.piece_size - start_piece->used), length);
 370
 371       ptr = start_piece->text + (startPos - start_first);
 372       MyStrncpy(ptr + fill, ptr,
 373                 (int) start_piece->used - (startPos - start_first));
 374       strncpy(ptr, text->ptr + firstPos, fill);
 375
 376       startPos += fill;
 377       firstPos += fill;
 378       start_piece->used += fill;
 379       length -= fill;
 380     }
 381   }
 382
 383   if (src->ascii_src.use_string_in_place)
 384     start_piece->text[start_piece->used] = '\0';
 385
 386   XtCallCallbacks(w, XtNcallback, NULL); /* Call callbacks, we have changed
 387                                             the buffer. */
 388
 389   return(XawEditDone);
 390 }
 391
 392 /*      Function Name: Scan
 393  *      Description: Scans the text source for the number and type
 394  *                   of item specified.
 395  *      Arguments: w - the AsciiSource widget.
 396  *                 position - the position to start scanning.
 397  *                 type - type of thing to scan for.
 398  *                 dir - direction to scan.
 399  *                 count - which occurance if this thing to search for.
 400  *                 include - whether or not to include the character found in
 401  *                           the position that is returned.
 402  *      Returns: the position of the item found.
 403  *
 404  * Note: While there are only 'n' characters in the file there are n+1
 405  *       possible cursor positions (one before the first character and
 406  *       one after the last character.
 407  */
 408
 409 static
 410 XawTextPosition
 411 Scan (w, position, type, dir, count, include)
 412 Widget                w;
 413 XawTextPosition       position;
 414 XawTextScanType       type;
 415 XawTextScanDirection  dir;
 416 int                   count;
 417 Boolean               include;
 418 {
 419   AsciiSrcObject src = (AsciiSrcObject) w;
 420   int inc;
 421   Piece* piece;
 422   XawTextPosition first, first_eol_position;
 423   char* ptr;
 424
 425   if (type == XawstAll) {       /* Optomize this common case. */
 426     if (dir == XawsdRight)
 427       return(src->ascii_src.length);
 428     return(0);                  /* else. */
 429   }
 430
 431   if (position > src->ascii_src.length)
 432     position = src->ascii_src.length;
 433
 434   if ( dir == XawsdRight ) {
 435     if (position == src->ascii_src.length)
 436 /*
 437  * Scanning right from src->ascii_src.length???
 438  */
 439       return(src->ascii_src.length);
 440     inc = 1;
 441   }
 442   else {
 443     if (position == 0)
 444       return(0);                /* Scanning left from 0??? */
 445     inc = -1;
 446     position--;
 447   }
 448
 449   piece = FindPiece(src, position, &first);
 450
 451 /*
 452  * If the buffer is empty then return 0.
 453  */
 454
 455   if ( piece->used == 0 ) return(0);
 456
 457   ptr = (position - first) + piece->text;
 458
 459   switch (type) {
 460   case XawstEOL:
 461   case XawstParagraph:
 462   case XawstWhiteSpace:
 463     for ( ; count > 0 ; count-- ) {
 464       Boolean non_space = FALSE, first_eol = TRUE;
 465       /* CONSTCOND */
 466       while (TRUE) {
 467         unsigned char c = *ptr;
 468
 469         ptr += inc;
 470         position += inc;
 471
 472         if (type == XawstWhiteSpace) {
 473           if (isspace(c)) {
 474             if (non_space)
 475               break;
 476           }
 477           else
 478             non_space = TRUE;
 479         }
 480         else if (type == XawstEOL) {
 481           if (c == '\n') break;
 482         }
 483         else { /* XawstParagraph */
 484           if (first_eol) {
 485             if (c == '\n') {
 486               first_eol_position = position;
 487               first_eol = FALSE;
 488             }
 489           }
 490           else
 491             if ( c == '\n')
 492               break;
 493             else if ( !isspace(c) )
 494               first_eol = TRUE;
 495         }
 496
 497
 498         if ( ptr < piece->text ) {
 499           piece = piece->prev;
 500           if (piece == NULL)    /* Begining of text. */
 501             return(0);
 502           ptr = piece->text + piece->used - 1;
 503         }
 504         else if ( ptr >= (piece->text + piece->used) ) {
 505           piece = piece->next;
 506           if (piece == NULL)    /* End of text. */
 507             return(src->ascii_src.length);
 508           ptr = piece->text;
 509         }
 510       }
 511     }
 512     if (!include) {
 513       if ( type == XawstParagraph)
 514         position = first_eol_position;
 515       position -= inc;
 516     }
 517     break;
 518   case XawstPositions:
 519     position += count * inc;
 520     break;
 521 /*  case XawstAll:              ---- handled in special code above */
 522   }
 523
 524   if ( dir == XawsdLeft )
 525     position++;
 526
 527   if (position >= src->ascii_src.length)
 528     return(src->ascii_src.length);
 529   if (position < 0)
 530     return(0);
 531
 532   return(position);
 533 }
 534
 535 /*      Function Name: Search
 536  *      Description: Searchs the text source for the text block passed
 537  *      Arguments: w - the AsciiSource Widget.
 538  *                 position - the position to start scanning.
 539  *                 dir - direction to scan.
 540  *                 text - the text block to search for.
 541  *      Returns: the position of the item found.
 542  */
 543
 544 static XawTextPosition
 545 Search(w, position, dir, text)
 546 Widget                w;
 547 XawTextPosition       position;
 548 XawTextScanDirection  dir;
 549 XawTextBlock *        text;
 550 {
 551   AsciiSrcObject src = (AsciiSrcObject) w;
 552   int inc, count = 0;
 553   char * ptr;
 554   Piece * piece;
 555   char * buf;
 556   XawTextPosition first;
 557
 558   if ( dir == XawsdRight )
 559     inc = 1;
 560   else {
 561     inc = -1;
 562     if (position == 0)
 563       return(XawTextSearchError);       /* scanning left from 0??? */
 564     position--;
 565   }
 566
 567   buf = XtMalloc((unsigned)sizeof(unsigned char) * text->length);
 568   strncpy(buf, (text->ptr + text->firstPos), text->length);
 569   piece = FindPiece(src, position, &first);
 570   ptr = (position - first) + piece->text;
 571
 572   /* CONSTCOND */
 573   while (TRUE) {
 574     if (*ptr == ((dir == XawsdRight) ? *(buf + count)
 575                                      : *(buf + text->length - count - 1)) ) {
 576       if (count == (text->length - 1))
 577         break;
 578       else
 579         count++;
 580     }
 581     else {
 582       if (count != 0) {
 583         position -=inc * count;
 584         ptr -= inc * count;
 585       }
 586       count = 0;
 587     }
 588
 589     ptr += inc;
 590     position += inc;
 591
 592     while ( ptr < piece->text ) {
 593       piece = piece->prev;
 594       if (piece == NULL) {      /* Begining of text. */
 595         XtFree(buf);
 596         return(XawTextSearchError);
 597       }
 598       ptr = piece->text + piece->used - 1;
 599     }
 600
 601     while ( ptr >= (piece->text + piece->used) ) {
 602       piece = piece->next;
 603       if (piece == NULL) {      /* End of text. */
 604         XtFree(buf);
 605         return(XawTextSearchError);
 606       }
 607       ptr = piece->text;
 608     }
 609   }
 610
 611   XtFree(buf);
 612   if (dir == XawsdLeft)
 613     return(position);
 614   return(position - (text->length - 1));
 615 }
 616
 617 /*      Function Name: SetValues
 618  *      Description: Sets the values for the AsciiSource.
 619  *      Arguments: current - current state of the widget.
 620  *                 request - what was requested.
 621  *                 new - what the widget will become.
 622  *      Returns: True if redisplay is needed.
 623  */
 624
 625 /* ARGSUSED */
 626 static Boolean
 627 SetValues(current, request, new, args, num_args)
 628 Widget current, request, new;
 629 ArgList args;
 630 Cardinal * num_args;
 631 {
 632   AsciiSrcObject src =      (AsciiSrcObject) new;
 633   AsciiSrcObject old_src = (AsciiSrcObject) current;
 634   Boolean total_reset = FALSE, string_set = FALSE;
 635   FILE * file;
 636   int i;
 637
 638   if ( old_src->ascii_src.use_string_in_place !=
 639        src->ascii_src.use_string_in_place ) {
 640       XtAppWarning( XtWidgetToApplicationContext(new),
 641            "AsciiSrc: The XtNuseStringInPlace resource may not be changed.");
 642        src->ascii_src.use_string_in_place =
 643            old_src->ascii_src.use_string_in_place;
 644   }
 645
 646   for (i = 0; i < *num_args ; i++ )
 647       if (streq(args[i].name, XtNstring)) {
 648           string_set = TRUE;
 649           break;
 650       }
 651
 652   if ( string_set || (old_src->ascii_src.type != src->ascii_src.type) ) {
 653     RemoveOldStringOrFile(old_src, string_set); /* remove old info. */
 654     file = InitStringOrFile(src, string_set);   /* Init new info. */
 655     LoadPieces(src, file, NULL);    /* load new info into internal buffers. */
 656     if (file != NULL) fclose(file);
 657     XawTextSetSource( XtParent(new), new, 0);   /* Tell text widget
 658                                                    what happened. */
 659     total_reset = TRUE;
 660   }
 661
 662   if ( old_src->ascii_src.ascii_length != src->ascii_src.ascii_length )
 663       src->ascii_src.piece_size = src->ascii_src.ascii_length;
 664
 665   if ( !total_reset &&
 666       (old_src->ascii_src.piece_size != src->ascii_src.piece_size) ) {
 667       String string = StorePiecesInString(old_src);
 668       FreeAllPieces(old_src);
 669       LoadPieces(src, NULL, string);
 670       XtFree(string);
 671   }
 672
 673   return(FALSE);
 674 }
 675
 676 /*      Function Name: GetValuesHook
 677  *      Description: This is a get values hook routine that sets the
 678  *                   values specific to the ascii source.
 679  *      Arguments: w - the AsciiSource Widget.
 680  *                 args - the argument list.
 681  *                 num_args - the number of args.
 682  *      Returns: none.
 683  */
 684
 685 static void
 686 GetValuesHook(w, args, num_args)
 687 Widget w;
 688 ArgList args;
 689 Cardinal * num_args;
 690 {
 691   AsciiSrcObject src = (AsciiSrcObject) w;
 692   int i;
 693
 694   if (src->ascii_src.type == XawAsciiString) {
 695     for (i = 0; i < *num_args ; i++ )
 696       if (streq(args[i].name, XtNstring)) {
 697           if (src->ascii_src.use_string_in_place) {
 698               *((char **) args[i].value) = src->ascii_src.first_piece->text;
 699           }
 700           else {
 701               if (XawAsciiSave(w))      /* If save sucessful. */
 702                   *((char **) args[i].value) = src->ascii_src.string;
 703           }
 704         break;
 705       }
 706   }
 707 }
 708
 709 /*      Function Name: Destroy
 710  *      Description: Destroys an ascii source (frees all data)
 711  *      Arguments: src - the Ascii source Widget to free.
 712  *      Returns: none.
 713  */
 714
 715 static void
 716 Destroy (w)
 717 Widget w;
 718 {
 719   RemoveOldStringOrFile((AsciiSrcObject) w, True);
 720 }
 721
 722 /************************************************************
 723  *
 724  * Public routines
 725  *
 726  ************************************************************/
 727
 728 /*      Function Name: XawAsciiSourceFreeString
 729  *      Description: Frees the string returned by a get values call
 730  *                   on the string when the source is of type string.
 731  *      Arguments: w - the AsciiSrc widget.
 732  *      Returns: none.
 733  */
 734
 735 void
 736 #if NeedFunctionPrototypes
 737 XawAsciiSourceFreeString(Widget w)
 738 #else
 739 XawAsciiSourceFreeString(w)
 740 Widget w;
 741 #endif
 742 {
 743   AsciiSrcObject src = (AsciiSrcObject) w;
 744
 745   /* If the src is really a multi, call the multi routine.*/
 746
 747   if ( XtIsSubclass( w, multiSrcObjectClass ) ) {
 748       _XawMultiSourceFreeString( w );
 749       return;
 750   }
 751
 752   else if ( !XtIsSubclass( w, asciiSrcObjectClass ) ) {
 753       XtErrorMsg("bad argument", "asciiSource", "XawError",
 754             "XawAsciiSourceFreeString's parameter must be an asciiSrc or multiSrc.",
 755              NULL, NULL);
 756   }
 757
 758   if (src->ascii_src.allocated_string && src->ascii_src.type != XawAsciiFile) {
 759     src->ascii_src.allocated_string = FALSE;
 760     XtFree(src->ascii_src.string);
 761     src->ascii_src.string = NULL;
 762   }
 763 }
 764
 765 /*      Function Name: XawAsciiSave
 766  *      Description: Saves all the pieces into a file or string as required.
 767  *      Arguments: w - the asciiSrc Widget.
 768  *      Returns: TRUE if the save was successful.
 769  */
 770 Bool
 771 #if NeedFunctionPrototypes
 772 XawAsciiSave(Widget w)
 773 #else
 774 XawAsciiSave(w)
 775 Widget w;
 776 #endif
 777 {
 778   AsciiSrcObject src = (AsciiSrcObject) w;
 779
 780   /* If the src is really a multi, call the multi save. */
 781
 782   if ( XtIsSubclass( w, multiSrcObjectClass ) )
 783       return( _XawMultiSave( w ) );
 784
 785   else if ( !XtIsSubclass( w, asciiSrcObjectClass ) ) {
 786         XtErrorMsg("bad argument", "asciiSource", "XawError",
 787                 "XawAsciiSave's parameter must be an asciiSrc or multiSrc.",
 788                    NULL, NULL);
 789   }
 790
 791 /*
 792  * If using the string in place then there is no need to play games
 793  * to get the internal info into a readable string.
 794  */
 795
 796   if (src->ascii_src.use_string_in_place)
 797     return(TRUE);
 798
 799   if (src->ascii_src.type == XawAsciiFile) {
 800     char * string;
 801
 802     if (!src->ascii_src.changes)                /* No changes to save. */
 803       return(TRUE);
 804
 805     string = StorePiecesInString(src);
 806
 807     if (WriteToFile(string, src->ascii_src.string) == FALSE) {
 808       XtFree(string);
 809       return(FALSE);
 810     }
 811     XtFree(string);
 812   }
 813   else {
 814     if (src->ascii_src.allocated_string == TRUE)
 815       XtFree(src->ascii_src.string);
 816     else
 817       src->ascii_src.allocated_string = TRUE;
 818
 819     src->ascii_src.string = StorePiecesInString(src);
 820   }
 821   src->ascii_src.changes = FALSE;
 822   return(TRUE);
 823 }
 824
 825 /*      Function Name: XawAsciiSaveAsFile
 826  *      Description: Save the current buffer as a file.
 827  *      Arguments: w - the AsciiSrc widget.
 828  *                 name - name of the file to save this file into.
 829  *      Returns: True if the save was sucessful.
 830  */
 831 Bool
 832 #if NeedFunctionPrototypes
 833 XawAsciiSaveAsFile(Widget w, _Xconst char* name)
 834 #else
 835 XawAsciiSaveAsFile(w, name)
 836 Widget w;
 837 String name;
 838 #endif
 839 {
 840   AsciiSrcObject src = (AsciiSrcObject) w;
 841   String string;
 842   Boolean ret;
 843
 844   /* If the src is really a multi, call the multi save. - */
 845
 846   if ( XtIsSubclass( w, multiSrcObjectClass ) )
 847       return( _XawMultiSaveAsFile( w, name ) );
 848
 849   else if ( !XtIsSubclass( w, asciiSrcObjectClass ) ) {
 850         XtErrorMsg("bad argument", "asciiSource", "XawError",
 851                 "XawAsciiSaveAsFile's 1st parameter must be an asciiSrc or multiSrc.",
 852                    NULL, NULL);
 853   }
 854
 855   string = StorePiecesInString(src);
 856
 857   ret = WriteToFile(string, name);
 858   XtFree(string);
 859   return(ret);
 860 }
 861
 862 /*      Function Name: XawAsciiSourceChanged
 863  *      Description: Returns true if the source has changed since last saved.
 864  *      Arguments: w - the ascii source widget.
 865  *      Returns: a Boolean (see description).
 866  */
 867
 868 Bool
 869 #if NeedFunctionPrototypes
 870 XawAsciiSourceChanged(Widget w)
 871 #else
 872 XawAsciiSourceChanged(w)
 873 Widget w;
 874 #endif
 875 {
 876   if ( XtIsSubclass( w, multiSrcObjectClass ) )
 877       return( ( (MultiSrcObject) w )->multi_src.changes );
 878
 879   if ( XtIsSubclass( w, asciiSrcObjectClass ) )
 880       return( ( (AsciiSrcObject) w)->ascii_src.changes );
 881
 882   XtErrorMsg("bad argument", "asciiSource", "XawError",
 883                 "XawAsciiSourceChanged parameter must be an asciiSrc or multiSrc.",
 884                    NULL, NULL);
 885
 886   return( True ); /* for gcc -Wall */
 887 }
 888
 889 /************************************************************
 890  *
 891  * Private Functions.
 892  *
 893  ************************************************************/
 894
 895 static void
 896 RemoveOldStringOrFile(src, checkString)
 897 AsciiSrcObject src;
 898 Boolean checkString;
 899 {
 900   FreeAllPieces(src);
 901
 902   if (checkString && src->ascii_src.allocated_string) {
 903     XtFree(src->ascii_src.string);
 904     src->ascii_src.allocated_string = False;
 905     src->ascii_src.string = NULL;
 906   }
 907 }
 908
 909 /*      Function Name: WriteToFile
 910  *      Description: Write the string specified to the begining of the file
 911  *                   specified.
 912  *      Arguments: string - string to write.
 913  *                 name - the name of the file
 914  *      Returns: returns TRUE if sucessful, FALSE otherwise.
 915  */
 916
 917 static Boolean
 918 WriteToFile(string, name)
 919 String string, name;
 920 {
 921   int fd;
 922
 923   if ( ((fd = creat(name, 0666)) == -1 ) ||
 924        (write(fd, string, sizeof(unsigned char) * strlen(string)) == -1) )
 925     return(FALSE);
 926
 927   if ( close(fd) == -1 )
 928     return(FALSE);
 929
 930   return(TRUE);
 931 }
 932
 933 /*      Function Name: StorePiecesInString
 934  *      Description: store the pieces in memory into a standard ascii string.
 935  *      Arguments: data - the ascii pointer data.
 936  *      Returns: none.
 937  */
 938
 939 static String
 940 StorePiecesInString(src)
 941 AsciiSrcObject src;
 942 {
 943   String string;
 944   XawTextPosition first;
 945   Piece * piece;
 946
 947   string = XtMalloc((unsigned) sizeof(unsigned char) *
 948                     src->ascii_src.length + 1);
 949
 950   for (first = 0, piece = src->ascii_src.first_piece ; piece != NULL;
 951        first += piece->used, piece = piece->next)
 952     strncpy(string + first, piece->text, piece->used);
 953
 954   string[src->ascii_src.length] = '\0'; /* NULL terminate this sucker. */
 955
 956 /*
 957  * This will refill all pieces to capacity.
 958  */
 959
 960   if (src->ascii_src.data_compression) {
 961     FreeAllPieces(src);
 962     LoadPieces(src, NULL, string);
 963   }
 964
 965   return(string);
 966 }
 967
 968 /*      Function Name: InitStringOrFile.
 969  *      Description: Initializes the string or file.
 970  *      Arguments: src - the AsciiSource.
 971  *      Returns: none - May exit though.
 972  */
 973
 974 static FILE *
 975 InitStringOrFile(src, newString)
 976 AsciiSrcObject src;
 977 Boolean newString;
 978 {
 979     char * open_mode;
 980     FILE * file;
 981     char fileName[TMPSIZ];
 982
 983     if (src->ascii_src.type == XawAsciiString) {
 984
 985         if (src->ascii_src.string == NULL)
 986             src->ascii_src.length = 0;
 987
 988         else if (! src->ascii_src.use_string_in_place) {
 989             src->ascii_src.string = XtNewString(src->ascii_src.string);
 990             src->ascii_src.allocated_string = True;
 991             src->ascii_src.length = strlen(src->ascii_src.string);
 992         }
 993
 994         if (src->ascii_src.use_string_in_place) {
 995             src->ascii_src.length = strlen(src->ascii_src.string);
 996             /* In case the length resource is incorrectly set */
 997             if (src->ascii_src.length > (long)src->ascii_src.ascii_length)
 998                 src->ascii_src.ascii_length = src->ascii_src.length;
 999
1000             if (src->ascii_src.ascii_length == MAGIC_VALUE)
1001                 src->ascii_src.piece_size = src->ascii_src.length;
1002             else
1003                 src->ascii_src.piece_size = src->ascii_src.ascii_length + 1;
1004         }
1005
1006         return(NULL);
1007     }
1008
1009 /*
1010  * type is XawAsciiFile.
1011  */
1012
1013     src->ascii_src.is_tempfile = FALSE;
1014
1015     switch (src->text_src.edit_mode) {
1016     case XawtextRead:
1017         if (src->ascii_src.string == NULL)
1018             XtErrorMsg("NoFile", "asciiSourceCreate", "XawError",
1019                      "Creating a read only disk widget and no file specified.",
1020                        NULL, 0);
1021         open_mode = "r";
1022         break;
1023     case XawtextAppend:
1024     case XawtextEdit:
1025         if (src->ascii_src.string == NULL) {
1026             src->ascii_src.string = fileName;
1027             (void) tmpnam(src->ascii_src.string);
1028             src->ascii_src.is_tempfile = TRUE;
1029             open_mode = "w";
1030         } else
1031             open_mode = "r+";
1032         break;
1033     default:
1034         XtErrorMsg("badMode", "asciiSourceCreate", "XawError",
1035                 "Bad editMode for ascii source; must be Read, Append or Edit.",
1036                    NULL, NULL);
1037     }
1038
1039     /* Allocate new memory for the temp filename, because it is held in
1040      * a stack variable, not static memory.  This widget does not need
1041      * to keep the private state field is_tempfile -- it is only accessed
1042      * in this routine, and its former setting is unused.
1043      */
1044     if (newString || src->ascii_src.is_tempfile) {
1045         src->ascii_src.string = XtNewString(src->ascii_src.string);
1046         src->ascii_src.allocated_string = TRUE;
1047     }
1048
1049     if (!src->ascii_src.is_tempfile) {
1050         if ((file = fopen(src->ascii_src.string, open_mode)) != 0) {
1051             (void) fseek(file, (Off_t)0, 2);
1052             src->ascii_src.length = (XawTextPosition) ftell(file);
1053             return file;
1054         } else {
1055             String params[2];
1056             Cardinal num_params = 2;
1057
1058             params[0] = src->ascii_src.string;
1059             params[1] = strerror(errno);
1060             XtAppWarningMsg(XtWidgetToApplicationContext((Widget)src),
1061                             "openError", "asciiSourceCreate", "XawWarning",
1062                             "Cannot open file %s; %s", params, &num_params);
1063         }
1064     }
1065     src->ascii_src.length = 0;
1066     return((FILE *)NULL);
1067 }
1068
1069 static void
1070 LoadPieces(src, file, string)
1071 AsciiSrcObject src;
1072 FILE * file;
1073 char * string;
1074 {
1075   char *local_str, *ptr;
1076   Piece * piece = NULL;
1077   XawTextPosition left;
1078
1079   if (string == NULL) {
1080     if (src->ascii_src.type == XawAsciiFile) {
1081       local_str = XtMalloc((unsigned) (src->ascii_src.length + 1)
1082                            * sizeof(unsigned char));
1083       if (src->ascii_src.length != 0) {
1084         fseek(file, (Off_t)0, 0);
1085         src->ascii_src.length = fread(local_str, (Size_t)sizeof(unsigned char),
1086                                       (Size_t)src->ascii_src.length, file);
1087         if (src->ascii_src.length <= 0)
1088           XtErrorMsg("readError", "asciiSourceCreate", "XawError",
1089                      "fread returned error.", NULL, NULL);
1090       }
1091       local_str[src->ascii_src.length] = '\0';
1092     }
1093     else
1094       local_str = src->ascii_src.string;
1095   }
1096   else
1097     local_str = string;
1098
1099   if (src->ascii_src.use_string_in_place) {
1100     piece = AllocNewPiece(src, piece);
1101     piece->used = Min(src->ascii_src.length, src->ascii_src.piece_size);
1102     piece->text = src->ascii_src.string;
1103     return;
1104   }
1105
1106   ptr = local_str;
1107   left = src->ascii_src.length;
1108
1109   do {
1110     piece = AllocNewPiece(src, piece);
1111
1112     piece->text = XtMalloc((unsigned)src->ascii_src.piece_size
1113                            * sizeof(unsigned char));
1114     piece->used = Min(left, src->ascii_src.piece_size);
1115     if (piece->used != 0)
1116       strncpy(piece->text, ptr, piece->used);
1117
1118     left -= piece->used;
1119     ptr += piece->used;
1120   } while (left > 0);
1121
1122   if ( (src->ascii_src.type == XawAsciiFile) && (string == NULL) )
1123     XtFree(local_str);
1124 }
1125
1126 /*      Function Name: AllocNewPiece
1127  *      Description: Allocates a new piece of memory.
1128  *      Arguments: src - The AsciiSrc Widget.
1129  *                 prev - the piece just before this one, or NULL.
1130  *      Returns: the allocated piece.
1131  */
1132
1133 static Piece *
1134 AllocNewPiece(src, prev)
1135 AsciiSrcObject src;
1136 Piece * prev;
1137 {
1138   Piece * piece = XtNew(Piece);
1139
1140   if (prev == NULL) {
1141     src->ascii_src.first_piece = piece;
1142     piece->next = NULL;
1143   }
1144   else {
1145     if (prev->next != NULL)
1146       (prev->next)->prev = piece;
1147     piece->next = prev->next;
1148     prev->next = piece;
1149   }
1150
1151   piece->prev = prev;
1152
1153   return(piece);
1154 }
1155
1156 /*      Function Name: FreeAllPieces
1157  *      Description: Frees all the pieces
1158  *      Arguments: src - The AsciiSrc Widget.
1159  *      Returns: none.
1160  */
1161
1162 static void
1163 FreeAllPieces(src)
1164 AsciiSrcObject src;
1165 {
1166   Piece * next, * first = src->ascii_src.first_piece;
1167
1168   if (first->prev != NULL)
1169     (void) printf("Xaw AsciiSrc Object: possible memory leak in FreeAllPieces().\n");
1170
1171   for ( ; first != NULL ; first = next ) {
1172     next = first->next;
1173     RemovePiece(src, first);
1174   }
1175 }
1176
1177 /*      Function Name: RemovePiece
1178  *      Description: Removes a piece from the list.
1179  *      Arguments:
1180  *                 piece - the piece to remove.
1181  *      Returns: none.
1182  */
1183
1184 static void
1185 RemovePiece(src, piece)
1186 AsciiSrcObject src;
1187 Piece * piece;
1188 {
1189   if (piece->prev == NULL)
1190     src->ascii_src.first_piece = piece->next;
1191   else
1192     (piece->prev)->next = piece->next;
1193
1194   if (piece->next != NULL)
1195     (piece->next)->prev = piece->prev;
1196
1197   if (!src->ascii_src.use_string_in_place)
1198     XtFree(piece->text);
1199
1200   XtFree((char *)piece);
1201 }
1202
1203 /*      Function Name: FindPiece
1204  *      Description: Finds the piece containing the position indicated.
1205  *      Arguments: src - The AsciiSrc Widget.
1206  *                 position - the position that we are searching for.
1207  * RETURNED        first - the position of the first character in this piece.
1208  *      Returns: piece - the piece that contains this position.
1209  */
1210
1211 static Piece *
1212 FindPiece(src, position, first)
1213 AsciiSrcObject src;
1214 XawTextPosition position, *first;
1215 {
1216   Piece * old_piece, * piece = src->ascii_src.first_piece;
1217   XawTextPosition temp;
1218
1219   for ( temp = 0 ; piece != NULL ; temp += piece->used, piece = piece->next ) {
1220     *first = temp;
1221     old_piece = piece;
1222
1223     if ((temp + piece->used) > position)
1224       return(piece);
1225   }
1226   return(old_piece);      /* if we run off the end the return the last piece */
1227 }
1228
1229 /*      Function Name: MyStrncpy
1230  *      Description: Just like string copy, but slower and will always
1231  *                   work on overlapping strings.
1232  *      Arguments: (same as strncpy) - s1, s2 - strings to copy (2->1).
1233  *                  n - the number of chars to copy.
1234  *      Returns: s1.
1235  */
1236
1237 static String
1238 MyStrncpy(s1, s2, n)
1239 char * s1, * s2;
1240 int n;
1241 {
1242   char buf[256];
1243   char* temp;
1244
1245   if (n == 0) return s1;
1246
1247   if (n < sizeof buf) temp = buf;
1248   else temp = XtMalloc((unsigned)sizeof(unsigned char) * n);
1249
1250   strncpy(temp, s2, n);         /* Saber has a bug that causes it to generate*/
1251   strncpy(s1, temp, n);         /* a bogus warning message here (CDP 6/32/89)*/
1252   if (temp != buf) XtFree(temp);
1253   return s1;
1254 }
1255
1256 /*      Function Name: BreakPiece
1257  *      Description: Breaks a full piece into two new pieces.
1258  *      Arguments: src - The AsciiSrc Widget.
1259  *                 piece - the piece to break.
1260  *      Returns: none.
1261  */
1262
1263 #define HALF_PIECE (src->ascii_src.piece_size/2)
1264
1265 static void
1266 BreakPiece(src, piece)
1267 AsciiSrcObject src;
1268 Piece * piece;
1269 {
1270   Piece * new = AllocNewPiece(src, piece);
1271
1272   new->text = XtMalloc(src->ascii_src.piece_size * sizeof(unsigned char));
1273   strncpy(new->text, piece->text + HALF_PIECE,
1274           src->ascii_src.piece_size - HALF_PIECE);
1275   piece->used = HALF_PIECE;
1276   new->used = src->ascii_src.piece_size - HALF_PIECE;
1277 }
1278
1279 /* ARGSUSED */
1280 static void
1281 CvtStringToAsciiType(args, num_args, fromVal, toVal)
1282 XrmValuePtr     args;           /* unused */
1283 Cardinal        *num_args;      /* unused */
1284 XrmValuePtr     fromVal;
1285 XrmValuePtr     toVal;
1286 {
1287   static XawAsciiType type;
1288   static XrmQuark  XtQEstring = NULLQUARK;
1289   static XrmQuark  XtQEfile;
1290   XrmQuark q;
1291   char lowerName[40];
1292
1293   if (XtQEstring == NULLQUARK) {
1294     XtQEstring = XrmPermStringToQuark(XtEstring);
1295     XtQEfile   = XrmPermStringToQuark(XtEfile);
1296   }
1297
1298   if (strlen ((char*)fromVal->addr) < sizeof lowerName) {
1299     XmuCopyISOLatin1Lowered(lowerName, (char *) fromVal->addr);
1300     q = XrmStringToQuark(lowerName);
1301
1302     if (q == XtQEstring)     type = XawAsciiString;
1303     else if (q == XtQEfile)  type = XawAsciiFile;
1304     else {
1305       toVal->size = 0;
1306       toVal->addr = NULL;
1307       return;
1308     }
1309     toVal->size = sizeof type;
1310     toVal->addr = (XPointer) &type;
1311     return;
1312   }
1313   toVal->size = 0;
1314   toVal->addr = NULL;
1315 }
1316
1317 #if (defined(ASCII_STRING) || defined(ASCII_DISK))
1318 #  include <X11/Xaw/Cardinals.h>
1319 #endif
1320
1321 #ifdef ASCII_STRING
1322 /************************************************************
1323  *
1324  * Compatability functions.
1325  *
1326  ************************************************************/
1327
1328 /*      Function Name: AsciiStringSourceCreate
1329  *      Description: Creates a string source.
1330  *      Arguments: parent - the widget that will own this source.
1331  *                 args, num_args - the argument list.
1332  *      Returns: a pointer to the new text source.
1333  */
1334
1335 Widget
1336 XawStringSourceCreate(parent, args, num_args)
1337 Widget parent;
1338 ArgList args;
1339 Cardinal num_args;
1340 {
1341   XawTextSource src;
1342   ArgList ascii_args;
1343   Arg temp[2];
1344
1345   XtSetArg(temp[0], XtNtype, XawAsciiString);
1346   XtSetArg(temp[1], XtNuseStringInPlace, TRUE);
1347   ascii_args = XtMergeArgLists(temp, TWO, args, num_args);
1348
1349   src = XtCreateWidget("genericAsciiString", asciiSrcObjectClass, parent,
1350                        ascii_args, num_args + TWO);
1351   XtFree((char *)ascii_args);
1352   return(src);
1353 }
1354
1355 /*
1356  * This is hacked up to try to emulate old functionality, it
1357  * may not work, as I have not old code to test it on.
1358  *
1359  * Chris D. Peterson  8/31/89.
1360  */
1361
1362 void
1363 XawTextSetLastPos (w, lastPos)
1364 Widget w;
1365 XawTextPosition lastPos;
1366 {
1367   AsciiSrcObject src = (AsciiSrcObject) XawTextGetSource(w);
1368
1369   src->ascii_src.piece_size = lastPos;
1370 }
1371 #endif /* ASCII_STRING */
1372
1373 #ifdef ASCII_DISK
1374 /*      Function Name: AsciiDiskSourceCreate
1375  *      Description: Creates a disk source.
1376  *      Arguments: parent - the widget that will own this source.
1377  *                 args, num_args - the argument list.
1378  *      Returns: a pointer to the new text source.
1379  */
1380
1381 Widget
1382 XawDiskSourceCreate(parent, args, num_args)
1383 Widget parent;
1384 ArgList args;
1385 Cardinal num_args;
1386 {
1387   XawTextSource src;
1388   ArgList ascii_args;
1389   Arg temp[1];
1390   int i;
1391
1392   XtSetArg(temp[0], XtNtype, XawAsciiFile);
1393   ascii_args = XtMergeArgLists(temp, ONE, args, num_args);
1394   num_args++;
1395
1396   for (i = 0; i < num_args; i++)
1397     if (streq(ascii_args[i].name, XtNfile) ||
1398                   streq(ascii_args[i].name, XtCFile))
1399       ascii_args[i].name = XtNstring;
1400
1401   src = XtCreateWidget("genericAsciiDisk", asciiSrcObjectClass, parent,
1402                        ascii_args, num_args);
1403   XtFree((char *)ascii_args);
1404   return(src);
1405 }
1406 #endif /* ASCII_DISK */