src/gtx/textcb.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * Implementation of the gator circular buffer package for its scrollable
  12  * text object.
  13  *
  14  *------------------------------------------------------------------------*/
  15
  16 #include <afsconfig.h>
  17 #include <afs/param.h>
  18
  19 #include <roken.h>
  20
  21 #include "gtxtextcb.h"          /*Module interface */
  22
  23 static int gator_textcb_debug;  /*Is debugging output turned on? */
  24
  25 /*------------------------------------------------------------------------
  26  * gator_textcb_Init
  27  *
  28  * Description:
  29  *      Initialize the text circular buffer package.
  30  *
  31  * Arguments:
  32  *      a_debug : Should debugging output be turned on?
  33  *
  34  * Returns:
  35  *      Zero if successful,
  36  *      Error value otherwise.
  37  *
  38  * Environment:
  39  *      MUST BE THE FIRST ROUTINE CALLED FROM THIS PACKAGE.
  40  *
  41  * Side Effects:
  42  *      Just remembers if debugging output should be generated.
  43  *------------------------------------------------------------------------*/
  44
  45 int
  46 gator_textcb_Init(int a_debug)
  47 {                               /*gator_textcb_Init */
  48
  49     static int initd;           /*Have we been called already? */
  50     static char rn[] = "gator_textcb_Init";     /*Routine name */
  51
  52     if (initd) {
  53         fprintf(stderr,
  54                 "[%s] Initialization routine called multiple times!!\n", rn);
  55         return (0);
  56     } else
  57         initd = 1;
  58
  59     gator_textcb_debug = a_debug;
  60     return (0);
  61
  62 }                               /*gator_textcb_Init */
  63
  64 /*------------------------------------------------------------------------
  65  * gator_textcb_Create
  66  *
  67  * Description:
  68  *      Create a new circular buffer.
  69  *
  70  * Arguments:
  71  *      int a_maxEntriesStored : How many entries should it have?
  72  *      int a_maxCharsPerEntry : Max chars in each entry.
  73  *
  74  * Returns:
  75  *      Ptr to the fully-initialized circular buffer hdr if successful,
  76  *      Null pointer otherwise.
  77  *
  78  * Environment:
  79  *      Makes sure the lock structure is properly initialized.
  80  *
  81  * Side Effects:
  82  *      As advertised; space is allocated for the circ buff.
  83  *------------------------------------------------------------------------*/
  84
  85 struct gator_textcb_hdr *
  86 gator_textcb_Create(int a_maxEntriesStored, int a_maxCharsPerEntry)
  87 {                               /*gator_textcb_Create */
  88
  89     static char rn[] = "gator_textcb_Create";   /*Routine name */
  90     char *newBuff;              /*Ptr to new text buffer */
  91     struct gator_textcb_entry *newEntries;      /*Ptr to new text entries */
  92     struct gator_textcb_hdr *newHdr;    /*Ptr to new text hdr */
  93     int bytesToAllocate;        /*Num bytes to allocate */
  94     int numBuffBytes;           /*Num bytes in text buffer */
  95     int curr_ent_num;           /*Current entry number */
  96     struct gator_textcb_entry *curr_ent;        /*Ptr to current entry */
  97     char *curr_buff;            /*Ptr to current buff pos */
  98     int curr_inv;               /*Current inversion idx */
  99     char *blankLine;            /*Ptr to blank line */
 100     int i;                      /*Loop variable */
 101
 102     /*
 103      * Start off by allocating the text buffer itself.  Don't forget we
 104      * need to allocate one more character per line, to make sure we can
 105      * always null-terminate them.  We also need to allocate the blank
 106      * line buffer.
 107      */
 108     numBuffBytes = bytesToAllocate =
 109         a_maxEntriesStored * (a_maxCharsPerEntry + 1);
 110     if (gator_textcb_debug)
 111         fprintf(stderr, "[%s] Allocating %d bytes for the text buffer\n", rn,
 112                 bytesToAllocate);
 113     newBuff = calloc(1, bytesToAllocate);
 114     if (newBuff == NULL) {
 115         fprintf(stderr,
 116                 "[%s] Can't allocate %d bytes for text buffer; errno is %d\n",
 117                 rn, bytesToAllocate, errno);
 118         return ((struct gator_textcb_hdr *)0);
 119     } else if (gator_textcb_debug)
 120         fprintf(stderr, "[%s] Text buffer allocated at %p\n", rn, newBuff);
 121     blankLine = malloc(a_maxCharsPerEntry + 1);
 122     if (blankLine == NULL) {
 123         fprintf(stderr,
 124                 "[%s] Can't allocate %d bytes for blank line buffer; errno is %d\n",
 125                 rn, a_maxCharsPerEntry + 1, errno);
 126         free(newBuff);
 127         return ((struct gator_textcb_hdr *)0);
 128     }
 129
 130     /*
 131      * Next, allocate the entry array.
 132      */
 133     bytesToAllocate = a_maxEntriesStored * sizeof(struct gator_textcb_entry);
 134     if (gator_textcb_debug)
 135         fprintf(stderr,
 136                 "[%s] Allocating %d bytes for the %d text entry array items\n",
 137                 rn, bytesToAllocate, a_maxEntriesStored);
 138     newEntries = malloc(bytesToAllocate);
 139     if (newEntries == (struct gator_textcb_entry *)0) {
 140         fprintf(stderr,
 141                 "[%s] Can't allocate %d bytes for the %d-member text entry array; errno is %d\n",
 142                 rn, bytesToAllocate, a_maxEntriesStored, errno);
 143         free(newBuff);
 144         free(blankLine);
 145         return ((struct gator_textcb_hdr *)0);
 146     } else if (gator_textcb_debug)
 147         fprintf(stderr, "[%s] Text buffer entry array allocated at %p\n",
 148                 rn, newEntries);
 149
 150     /*
 151      * Finish off by allocating the text circular buffer header.
 152      */
 153     bytesToAllocate = sizeof(struct gator_textcb_hdr);
 154     if (gator_textcb_debug)
 155         fprintf(stderr,
 156                 "[%s] Allocating %d bytes for the text circular buffer header\n",
 157                 rn, bytesToAllocate);
 158     newHdr = malloc(bytesToAllocate);
 159     if (newHdr == (struct gator_textcb_hdr *)0) {
 160         fprintf(stderr,
 161                 "[%s] Can't allocate %d bytes for text circular buffer header; errno is %d\n",
 162                 rn, bytesToAllocate, errno);
 163         free(newBuff);
 164         free(blankLine);
 165         free(newEntries);
 166         return ((struct gator_textcb_hdr *)0);
 167     } else if (gator_textcb_debug)
 168         fprintf(stderr,
 169                 "[%s] Text circular buffer header allocated at %p\n", rn,
 170                 newHdr);
 171
 172     /*
 173      * Now, just initialize all the pieces and plug them in.
 174      */
 175     if (gator_textcb_debug)
 176         fprintf(stderr, "[%s] Initializing blank line buffer at %p\n", rn,
 177                 blankLine);
 178     for (i = 0; i < a_maxCharsPerEntry; i++)
 179         *(blankLine + i) = ' ';
 180     *(blankLine + a_maxCharsPerEntry) = '\0';
 181
 182     /*
 183      * Initialize each buffer entry.
 184      */
 185     for (curr_ent_num = 0, curr_buff = newBuff, curr_ent = newEntries;
 186          curr_ent_num < a_maxEntriesStored;
 187          curr_ent++, curr_ent_num++, curr_buff += (a_maxCharsPerEntry + 1)) {
 188         if (gator_textcb_debug)
 189             fprintf(stderr,
 190                     "[%s] Initializing buffer entry %d; its text buffer address is %p\n",
 191                     rn, curr_ent_num, curr_buff);
 192         curr_ent->ID = 0;
 193         curr_ent->highlight = 0;
 194         curr_ent->numInversions = 0;
 195         curr_ent->charsUsed = 0;
 196         curr_ent->textp = curr_buff;
 197         memcpy(curr_ent->textp, blankLine, a_maxCharsPerEntry + 1);
 198         for (curr_inv = 0; curr_inv < GATOR_TEXTCB_MAXINVERSIONS; curr_inv++)
 199             curr_ent->inversion[curr_inv] = 0;
 200
 201     }                           /*Init each buffer entry */
 202
 203     if (gator_textcb_debug)
 204         fprintf(stderr, "[%s] Filling in circ buff header at %p\n", rn,
 205                 newHdr);
 206     Lock_Init(&(newHdr->cbLock));
 207     newHdr->maxEntriesStored = a_maxEntriesStored;
 208     newHdr->maxCharsPerEntry = a_maxCharsPerEntry;
 209     newHdr->currEnt = 0;
 210     newHdr->currEntIdx = 0;
 211     newHdr->oldestEnt = 0;
 212     newHdr->oldestEntIdx = 0;
 213     newHdr->entry = newEntries;
 214     newHdr->blankLine = blankLine;
 215
 216     /*
 217      * Finally, return the location of the new header.
 218      */
 219     return (newHdr);
 220
 221 }                               /*gator_textcb_Create */
 222
 223 /*------------------------------------------------------------------------
 224  * bumpCB
 225  *
 226  * Description:
 227  *      Move down to the next circular buffer entry.
 228  *
 229  * Arguments:
 230  *      struct gator_textcb_hdr *a_cbhdr : Circ buff header to bump.
 231  *
 232  * Returns:
 233  *      Ptr to the newest current entry.
 234  *
 235  * Environment:
 236  *      Nothing interesting.
 237  *
 238  * Side Effects:
 239  *      As advertised.
 240  *------------------------------------------------------------------------*/
 241
 242 static struct gator_textcb_entry *
 243 bumpEntry(struct gator_textcb_hdr *a_cbhdr)
 244
 245 {                               /*bumpEntry */
 246
 247     static char rn[] = "bumpEntry";     /*Routine name */
 248     struct gator_textcb_entry *curr_ent;        /*Ptr to current entry */
 249     int inv;                    /*Inversion number */
 250
 251     /*
 252      * Bump the total number of writes, and don't forget to advance
 253      * the oldest entry, if appropriate.
 254      */
 255     if (gator_textcb_debug)
 256         fprintf(stderr,
 257                 "[%s]: Bumping entry for circular buffer at %p; current values: currEnt=%d (idx %d), oldestEnt=%d (idx %d), maxEntriesStored=%d\n",
 258                 rn, a_cbhdr, a_cbhdr->currEnt, a_cbhdr->currEntIdx,
 259                 a_cbhdr->oldestEnt, a_cbhdr->oldestEntIdx,
 260                 a_cbhdr->maxEntriesStored);
 261
 262     a_cbhdr->currEnt++;
 263     if (++(a_cbhdr->currEntIdx) >= a_cbhdr->maxEntriesStored)
 264         a_cbhdr->currEntIdx = 0;
 265     curr_ent = a_cbhdr->entry + a_cbhdr->currEntIdx;
 266
 267     if (gator_textcb_debug)
 268         fprintf(stderr, "[%s] Zeroing entry %d (idx %d) at %p\n", rn,
 269                 a_cbhdr->currEnt, a_cbhdr->currEntIdx, curr_ent);
 270
 271     curr_ent->ID = a_cbhdr->currEnt;
 272     curr_ent->highlight = 0;
 273     curr_ent->numInversions = 0;
 274     curr_ent->charsUsed = 0;
 275     /*
 276      * Copy over a blank line into the one we're initializing.  We
 277      * copy over the trailing null, too.
 278      */
 279     memcpy(curr_ent->textp, a_cbhdr->blankLine,
 280            a_cbhdr->maxCharsPerEntry + 1);
 281     for (inv = 0; inv < GATOR_TEXTCB_MAXINVERSIONS; inv++)
 282         curr_ent->inversion[inv] = 0;
 283
 284     /*
 285      * If we've already stated circulating in the buffer, remember to
 286      * bump the oldest entry info too.
 287      */
 288     if (a_cbhdr->currEnt >= a_cbhdr->maxEntriesStored) {
 289         if (gator_textcb_debug)
 290             fprintf(stderr,
 291                     "[%s]: Advancing oldest entry number & index; was entry %d, index %d, now ",
 292                     rn, a_cbhdr->oldestEnt, a_cbhdr->oldestEntIdx);
 293         a_cbhdr->oldestEnt++;
 294         if (++(a_cbhdr->oldestEntIdx) >= a_cbhdr->maxEntriesStored)
 295             a_cbhdr->oldestEntIdx = 0;
 296         if (gator_textcb_debug)
 297             fprintf(stderr, "entry %d, index %d\n", a_cbhdr->oldestEnt,
 298                     a_cbhdr->oldestEntIdx);
 299     }
 300
 301     /*Bump oldest entry info */
 302     /*
 303      * Finally, return the address of the newest current entry.
 304      */
 305     return (curr_ent);
 306
 307 }                               /*bumpEntry */
 308
 309 /*------------------------------------------------------------------------
 310  * gator_textcb_Write
 311  *
 312  * Description:
 313  *      Write the given string to the text circular buffer.  Line
 314  *      breaks are caused either by overflowing the current text
 315  *      line or via explicit '\n's.
 316  *
 317  * Arguments:
 318  *      struct gator_textcb_hdr *a_cbhdr : Ptr to circ buff hdr.
 319  *      char *a_textToWrite              : Ptr to text to insert.
 320  *      int a_numChars                   : Number of chars to write.
 321  *      int a_highlight                  : Use highlighting?
 322  *      int a_skip;                      : Force a skip to the next line?
 323  *
 324  * Returns:
 325  *      Zero if successful,
 326  *      Error value otherwise.
 327  *
 328  * Environment:
 329  *      Circular buffer is consistent upon entry, namely the first and
 330  *      last entry pointers are legal.
 331  *
 332  * Side Effects:
 333  *      As advertised.
 334  *------------------------------------------------------------------------*/
 335
 336 int
 337 gator_textcb_Write(struct gator_textcb_hdr *a_cbhdr, char *a_textToWrite,
 338                    int a_numChars, int a_highlight, int a_skip)
 339 {                               /*gator_textcb_Write */
 340
 341     static char rn[] = "gator_textcb_Write";    /*Routine name */
 342     struct gator_textcb_entry *curr_ent;        /*Ptr to current text entry */
 343     int curr_ent_idx;           /*Index of current entry */
 344     int max_chars;              /*Max chars per entry */
 345     int chars_to_copy;          /*Num chars to copy in */
 346     int effective_highlight;    /*Tmp highlight value */
 347     char *dest;                 /*Destination of char copy */
 348
 349     /*
 350      * Make sure we haven't been passed a bogus buffer, and lock it
 351      * before we start.
 352      */
 353     if (a_cbhdr == (struct gator_textcb_hdr *)0) {
 354         fprintf(stderr,
 355                 "[%s]: Null pointer passed in for circ buff header!!  Aborting write operation.\n",
 356                 rn);
 357         return (-1);
 358     }
 359     ObtainWriteLock(&(a_cbhdr->cbLock));
 360
 361     curr_ent_idx = a_cbhdr->currEntIdx;
 362     curr_ent = (a_cbhdr->entry) + curr_ent_idx;
 363     max_chars = a_cbhdr->maxCharsPerEntry;
 364     effective_highlight = curr_ent->highlight;
 365     if (curr_ent->numInversions % 2)
 366         effective_highlight = (effective_highlight ? 0 : 1);
 367     if (gator_textcb_debug)
 368         fprintf(stderr,
 369                 "[%s]: Current entry: %d (at index %d, keeping %d max), effective highlight: %d, located at %p\n",
 370                 rn, a_cbhdr->currEnt, curr_ent_idx, a_cbhdr->maxEntriesStored,
 371                 effective_highlight, curr_ent);
 372
 373     while (a_numChars > 0) {
 374         /*
 375          * There are still characters to stuff into our circular buffer.
 376          */
 377         if (gator_textcb_debug)
 378             fprintf(stderr,
 379                     "[%s]: Top of write loop: %d char(s) left to write.\n",
 380                     rn, a_numChars);
 381
 382         if (curr_ent->charsUsed >= max_chars) {
 383             /*
 384              * Bump the entry in the given circular buffer.
 385              */
 386             if (gator_textcb_debug)
 387                 fprintf(stderr,
 388                         "[%s]: Entry %d at index %d full, advancing to next one.\n",
 389                         rn, a_cbhdr->currEnt, curr_ent_idx);
 390             curr_ent = bumpEntry(a_cbhdr);
 391             curr_ent_idx = a_cbhdr->currEntIdx;
 392             if (gator_textcb_debug)
 393                 fprintf(stderr,
 394                         "[%s] New CB entry info: currEnt=%d (idx %d), oldestEnt=%d (idx %d), curr entry ptr is %p\n",
 395                         rn, a_cbhdr->currEnt, a_cbhdr->currEntIdx,
 396                         a_cbhdr->oldestEnt, a_cbhdr->oldestEntIdx, curr_ent);
 397         }
 398
 399         /*Bump current entry */
 400         /*
 401          * At this point, the current entry has room for at least one more
 402          * character, and we have at least one more character to write.
 403          * Insert as much from the user text as possible.
 404          */
 405         chars_to_copy = max_chars - curr_ent->charsUsed;
 406         if (a_numChars < chars_to_copy)
 407             chars_to_copy = a_numChars;
 408         dest = curr_ent->textp + curr_ent->charsUsed;
 409         if (gator_textcb_debug)
 410             fprintf(stderr,
 411                     "[%s]: Copying %d char(s) into current entry at %p (entry buffer starts at %p)\n",
 412                     rn, chars_to_copy, dest, curr_ent->textp);
 413
 414         /*
 415          * Handle highlighting and inversions.
 416          */
 417         if (curr_ent->charsUsed == 0) {
 418             /*
 419              * No chars yet, so this sets the highlight field.
 420              */
 421             effective_highlight = curr_ent->highlight = a_highlight;
 422         } else if (effective_highlight != a_highlight) {
 423             /*
 424              * We need a new inversion, if there's room.
 425              */
 426             if (gator_textcb_debug)
 427                 fprintf(stderr,
 428                         "[%s]: Highlight mismatch, recording inversion at char loc %d\n",
 429                         rn, curr_ent->charsUsed);
 430             if (curr_ent->numInversions < GATOR_TEXTCB_MAXINVERSIONS) {
 431                 effective_highlight = a_highlight;
 432                 curr_ent->inversion[curr_ent->numInversions] =
 433                     curr_ent->charsUsed;
 434                 curr_ent->numInversions++;
 435             } else if (gator_textcb_debug)
 436                 fprintf(stderr, "[%s]: Out of inversions!!\n", rn);
 437         }
 438
 439         /*Handle inversion */
 440         /*
 441          * Move the string chunk into its place in the buffer, bump the
 442          * number of chars used in the current entry.
 443          */
 444         strncpy(dest, a_textToWrite, chars_to_copy);
 445         curr_ent->charsUsed += chars_to_copy;
 446         a_textToWrite += chars_to_copy;
 447         a_numChars -= chars_to_copy;
 448
 449     }                           /*while (a_numChars > 0) */
 450
 451     /*
 452      * All characters have been copied in.  Handle the case where we've
 453      * been asked to skip to the next entry, even if there's still room
 454      * in the current one.
 455      */
 456     if (a_skip) {
 457         if (gator_textcb_debug)
 458             fprintf(stderr, "[%s] Handling request to skip to next entry\n",
 459                     rn);
 460         if (curr_ent->charsUsed > 0)
 461             curr_ent = bumpEntry(a_cbhdr);
 462         else if (gator_textcb_debug)
 463             fprintf(stderr,
 464                     "[%s] Not skipping, we're already on a fresh entry\n",
 465                     rn);
 466     }
 467
 468     /*Skip to the next entry */
 469     /*
 470      * We can now unlock the CB and return successfully.
 471      */
 472     ReleaseWriteLock(&(a_cbhdr->cbLock));
 473     return (0);
 474
 475 }                               /*gator_textcb_Write */
 476
 477 /*------------------------------------------------------------------------
 478  * gator_textcb_BlankLine
 479  *
 480  * Description:
 481  *      Write out some number of blank lines to the given circular
 482  *      buffer.
 483  *
 484  * Arguments:
 485  *      struct gator_textcb_hdr *a_cbhdr : Ptr to circ buff hdr.
 486  *      int *a_numBlanks                 : Num. blank lines to write.
 487  *
 488  * Returns:
 489  *      Zero if successful,
 490  *      Error value otherwise.
 491  *
 492  * Environment:
 493  *      Circular buffer is consistent upon entry, namely the first and
 494  *      last entry pointers are legal.
 495  *
 496  * Side Effects:
 497  *      As advertised.
 498  *------------------------------------------------------------------------*/
 499
 500 int
 501 gator_textcb_BlankLine(struct gator_textcb_hdr *a_cbhdr,
 502                        int a_numBlanks)
 503 {                               /*gator_textcb_BlankLine */
 504
 505     static char rn[] = "gator_textcb_BlankLine";        /*Routine name */
 506
 507     if (gator_textcb_debug)
 508         fprintf(stderr, "[%s] Putting out %d blank lines to the CB at %p\n",
 509                 rn, a_numBlanks, a_cbhdr);
 510
 511     if (a_cbhdr == (struct gator_textcb_hdr *)0) {
 512         if (gator_textcb_debug)
 513             fprintf(stderr, "[%s] Null pointer passed for CB hdr!!\n", rn);
 514         return (-1);
 515     }
 516
 517     while (a_numBlanks > 0) {
 518         /*
 519          * The bumpEntry routine returns a struct gator_textcb_entry
 520          * pointer, but we don't need it here, so we don't assign it.
 521          */
 522         bumpEntry(a_cbhdr);
 523         a_numBlanks--;
 524     }
 525
 526     /*
 527      * Return happily and successfully.
 528      */
 529     return (0);
 530
 531 }                               /*gator_textcb_Write */
 532
 533 /*------------------------------------------------------------------------
 534  * gator_textcb_Delete
 535  *
 536  * Description:
 537  *      Delete the storage used by the given circular buffer, including
 538  *      the header itself.
 539  *
 540  * Arguments:
 541  *      struct gator_textcb_hdr *a_cbhdr : Ptr to the header of the
 542  *                                              circ buffer to reap.
 543  *
 544  * Returns:
 545  *      Zero if successful,
 546  *      Error value otherwise.
 547  *
 548  * Environment:
 549  *      We write-lock the buffer before deleting it, which is slightly
 550  *      silly, since it will stop existing after we're done.  At least
 551  *      we'll make sure nobody is actively writing to it while it's
 552  *      being deleted.
 553  *
 554  * Side Effects:
 555  *      As advertised.
 556  *------------------------------------------------------------------------*/
 557
 558 int
 559 gator_textcb_Delete(struct gator_textcb_hdr *a_cbhdr)
 560 {                               /*gator_textcb_Delete */
 561
 562     static char rn[] = "gator_textcb_Delete";   /*Routine name */
 563
 564     if (gator_textcb_debug)
 565         fprintf(stderr, "[%s]: Deleting text circular buffer at %p\n", rn,
 566                 a_cbhdr);
 567     ObtainWriteLock(&(a_cbhdr->cbLock));
 568
 569     /*
 570      * The beginning of the text buffer itself is pointed to by the
 571      * first text entry.
 572      */
 573     if (gator_textcb_debug)
 574         fprintf(stderr,
 575                 "[%s]: Freeing text buffer proper at %p (%d bytes)\n", rn,
 576                 a_cbhdr->entry[0].textp,
 577                 (a_cbhdr->maxEntriesStored * a_cbhdr->maxCharsPerEntry));
 578     free(a_cbhdr->entry[0].textp);
 579     a_cbhdr->entry[0].textp = NULL;
 580
 581     if (gator_textcb_debug)
 582         fprintf(stderr, "[%s]: Freeing text entry array at %p (%" AFS_SIZET_FMT " bytes)\n",
 583                 rn, a_cbhdr->entry,
 584                 (a_cbhdr->maxEntriesStored *
 585                  sizeof(struct gator_textcb_entry)));
 586     free(a_cbhdr->entry);
 587     a_cbhdr->entry = (struct gator_textcb_entry *)0;
 588     free(a_cbhdr->blankLine);
 589     a_cbhdr->blankLine = NULL;
 590
 591     /*
 592      * Release the write lock on it, then free the header itself.
 593      */
 594     ReleaseWriteLock(&(a_cbhdr->cbLock));
 595     if (gator_textcb_debug)
 596         fprintf(stderr, "[%s] Freeing cicular buffer header at %p\n", rn,
 597                 a_cbhdr);
 598     free(a_cbhdr);
 599     return (0);
 600
 601 }                               /*gator_textcb_Delete */