src/index.c

   1 /*
   2  * Source file:
   3  *      index.c
   4  */
   5
   6 #include "config.h"
   7
   8 #if TM_IN_SYS_TIME
   9 # include <sys/time.h>
  10 #else
  11 # include <time.h>
  12 #endif
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <unistd.h>
  20
  21 #include "trueprint.h"
  22 #include "main.h"
  23 #include "headers.h"
  24 #include "postscript.h"
  25 #include "debug.h"
  26 #include "utils.h"
  27
  28 #include "index.h"
  29
  30 /*
  31  * Public part
  32  */
  33
  34 /*
  35  * Private part
  36  */
  37 #define LINE            0
  38 #define INPUT_END       1
  39 #define BLOCK_SIZE 1000
  40
  41 typedef struct {
  42   char  name[SYMBOL_LEN];
  43   long  name_start_char;
  44   long  name_end_char;
  45   long  page_number;
  46   long  end_page;
  47   boolean changed;
  48   char  *filename;
  49 } function_entry;
  50
  51 typedef struct {
  52   long  starting_page;
  53   long  ending_page;
  54   char  *name;
  55   time_t modified;
  56 } file_entry;
  57
  58 typedef struct {
  59   boolean changed;
  60 } page_entry;
  61
  62 static void dot_fill(char string[]);
  63 static int compare(const void *, const void *);
  64 static short print_index_line(int print_bold);
  65
  66 static size_t   max_function_name_length = 0;
  67 static size_t   max_file_name_length = 0;
  68
  69 static unsigned short   no_of_functions=0;
  70 static unsigned int     function_list_size = 0;
  71 static unsigned int     file_list_size = 0;
  72 static unsigned int     page_list_size = 0;
  73 static function_entry   *functions = NULL;
  74 static function_entry   *sorted_functions = NULL;
  75 static file_entry       *files = NULL;
  76 static page_entry       *pages = NULL;
  77
  78 static boolean          current_function_changed = FALSE;
  79
  80 static void grow_array(void *list_ptr_ptr, unsigned int *, size_t);
  81
  82 /*****************************************************************************
  83  * Function:
  84  *      setup_index
  85  */
  86 void
  87 setup_index(void)
  88 {
  89   max_function_name_length = 0;
  90   max_file_name_length = 0;
  91
  92   no_of_functions=0;
  93   function_list_size = 0;
  94   file_list_size = 0;
  95   page_list_size = 0;
  96   functions = NULL;
  97   sorted_functions = NULL;
  98   files = NULL;
  99   pages = NULL;
 100
 101   current_function_changed = FALSE;
 102 }
 103
 104 /*****************************************************************************
 105  * Function:
 106  *      grow_array
 107  */
 108 static void
 109 grow_array(void *list_ptr_ptr, unsigned int *list_size_ptr, size_t list_entry_size)
 110
 111 {
 112   size_t        size_needed;
 113
 114   *list_size_ptr += BLOCK_SIZE;
 115
 116   size_needed = *list_size_ptr * list_entry_size;
 117
 118   dm('i',3,"index.c:grow_array() Growing array by %d bytes\n", size_needed);
 119
 120   if (*(void **)list_ptr_ptr == NULL)
 121     *(void **)list_ptr_ptr = xmalloc(size_needed);
 122   else
 123     *(void **)list_ptr_ptr = xrealloc(*(void **)list_ptr_ptr, size_needed);
 124 }
 125
 126 /*****************************************************************************
 127  * Function:
 128  *      page_has_changed
 129  *
 130  * Flag this page and function as containing a change
 131  */
 132 void
 133 page_has_changed(long this_page_number)
 134
 135 {
 136   if (pass == 1) return;
 137
 138   while (this_page_number >= page_list_size)
 139     grow_array(&pages, &page_list_size, sizeof(page_entry));
 140
 141   current_function_changed = TRUE;
 142   pages[this_page_number].changed = TRUE;
 143 }
 144
 145 /*****************************************************************************
 146  * Function:
 147  *      add_file
 148  *
 149  * Remembers the starting page and other info for the named file.
 150  */
 151 void
 152 add_file(char *filename, unsigned int this_file_number, long this_file_page_number)
 153
 154 {
 155   size_t length = strlen(filename);
 156   struct stat stat_buffer;
 157
 158   if (this_file_number >= file_list_size)
 159     grow_array(&files, &file_list_size, sizeof(file_entry));
 160
 161   files[this_file_number].starting_page = this_file_page_number;
 162   files[this_file_number].name = strdup(filename);
 163
 164   if (strcmp(filename,"-") != 0) {
 165     if (stat(filename,&stat_buffer) == -1) {
 166       perror(CMD_NAME ": cannot stat file");
 167       exit(1);
 168     }
 169
 170     files[this_file_number].modified = stat_buffer.st_mtime;
 171   } else {
 172     files[this_file_number].modified = 0;
 173   }
 174
 175   if (length > max_file_name_length)
 176     max_file_name_length = length;
 177 }
 178
 179 /*****************************************************************************
 180  * Function:
 181  *      end_file
 182  *
 183  * Remembers the ending page for the named file.
 184  */
 185 void
 186 end_file(unsigned int this_file_number, long this_file_page_number)
 187
 188 {
 189   if (this_file_number >= file_list_size)
 190     grow_array(&files, &file_list_size, sizeof(file_entry));
 191
 192   files[this_file_number].ending_page = this_file_page_number;
 193 }
 194
 195 /*****************************************************************************
 196  * Function:
 197  *      get_file_last_page
 198  *
 199  * Return the last page number for a file
 200  */
 201 long
 202 get_file_last_page(unsigned int this_file_number)
 203
 204 {
 205   return files[this_file_number].ending_page;
 206 }
 207
 208 /*****************************************************************************
 209  * Function:
 210  *      get_file_first_page
 211  *
 212  * Return the first page number for a file
 213  */
 214 long
 215 get_file_first_page(unsigned int this_file_number)
 216
 217 {
 218   return files[this_file_number].starting_page;
 219 }
 220
 221 /*****************************************************************************
 222  * Function:
 223  *      get_file_modified_time
 224  *
 225  * Return the struct time_t containing the last modified time of the file
 226  */
 227 struct tm *
 228 get_file_modified_time(unsigned int this_file_number)
 229
 230 {
 231   if (files[this_file_number].modified == 0)
 232     return NULL;
 233
 234   return localtime(&files[this_file_number].modified);
 235 }
 236
 237 /*****************************************************************************
 238  * Function:
 239  *      add_function.
 240  *
 241  * Remembers the start and end characters, the page number and the filename
 242  * for the named function.
 243  */
 244 void
 245 add_function(char *name, long start, long end, long page, char *filename)
 246
 247 {
 248   size_t length = strlen(name);
 249   if (pass == 1) return;
 250
 251   dm('i',2,"index.c:add_function() Adding %s, page %ld filename %s\n",
 252      name,page,filename);
 253
 254   if (no_of_functions == function_list_size)
 255     grow_array(&functions, &function_list_size, sizeof(function_entry));
 256
 257   strcpy(functions[no_of_functions].name, name);
 258   functions[no_of_functions].name_start_char = start;
 259   functions[no_of_functions].name_end_char = end;
 260   functions[no_of_functions].page_number = page;
 261   functions[no_of_functions].filename = filename;
 262   if (length > max_function_name_length)
 263     max_function_name_length = length;
 264   current_function_changed = FALSE;
 265 }
 266
 267 /*****************************************************************************
 268  * Function:
 269  *      end_function
 270  *
 271  * Remembers the end page for the current function, and gets ready for
 272  * information on the next function.
 273  */
 274 void
 275 end_function(long page)
 276
 277 {
 278   if (pass == 1) return;
 279
 280   dm('i',2,"index.c:end_function() Ending function on page %ld\n",page);
 281
 282   functions[no_of_functions].changed = current_function_changed;
 283   functions[no_of_functions++].end_page = page;
 284 }
 285
 286 /*****************************************************************************
 287  * Function:
 288  *      get_function_name_posn
 289  *
 290  * Looks at current_char and returns whether this character starts a
 291  * function name, ends a function name, or does neither.
 292  */
 293 char_status
 294 get_function_name_posn(long current_char, char_status current_status)
 295
 296 {
 297   static unsigned short current_function=0;
 298
 299   if (pass==0) return(current_status);
 300
 301   /* If there were no functions simply return CHAR */
 302   if (no_of_functions == 0) return (current_status);
 303
 304   if ((current_char >= functions[current_function].name_start_char)
 305       && (current_char <= functions[current_function].name_end_char))
 306     {
 307       if (current_char == functions[current_function].name_end_char)
 308         current_function += 1;
 309       dm('i',5,"index.c:get_function_name_posn() Returning TRUE for char posn %ld\n", current_char);
 310       return(CHAR_BOLD);
 311     }
 312
 313   return(current_status);
 314 }
 315
 316 /*****************************************************************************
 317  * Function:
 318  *      get_function_name
 319  *
 320  * Get the current function name for the specified page.
 321  */
 322 char *
 323 get_function_name(long page)
 324
 325 {
 326   unsigned short        current_function=0;
 327   static char   dummy_return[] = "";
 328
 329   dm('i',4,"Index: Searching for function name for page %ld\n",page);
 330
 331   if ((pass==0) || (no_of_functions == 0)) return(dummy_return);
 332
 333   for (;;)
 334     {
 335       if (page < functions[current_function].page_number)
 336         return(dummy_return);
 337       if (page <= functions[current_function].end_page)
 338         {
 339           dm('i',4,"Index: Function name for page %ld = %s\n",page,functions[current_function].name);
 340           return(functions[current_function].name);
 341         }
 342       if (current_function >= no_of_functions-1)
 343         return(dummy_return);
 344       current_function += 1;
 345     }
 346 }
 347
 348 /*****************************************************************************
 349  * Function:
 350  *      get_file_name
 351  *
 352  * Get the appropriate file name
 353  */
 354
 355 char *
 356 file_name(int file_number)
 357
 358 {
 359   return files[file_number].name;
 360 }
 361
 362 /*****************************************************************************
 363  * Function:
 364  *      function_changed
 365  *
 366  * Has the current function changed?
 367  */
 368 boolean
 369 function_changed(long page)
 370
 371 {
 372   static unsigned short current_function=0;
 373
 374   if (pass==0) return(FALSE);
 375   if (no_of_functions == 0) return(FALSE);
 376   for (;;)
 377     {
 378       if (page < functions[current_function].page_number)
 379         return(FALSE);
 380       if (page <= functions[current_function].end_page)
 381         return(functions[current_function].changed);
 382       if (current_function >= no_of_functions-1)
 383         return(FALSE);
 384       current_function += 1;
 385     }
 386 }
 387
 388 /*****************************************************************************
 389  * Function:
 390  *      page_changed
 391  *
 392  * Has the current page changed?
 393  */
 394 boolean
 395 page_changed(long page)
 396
 397 {
 398   if (pass == 0) return FALSE;
 399   if (page > page_list_size) return FALSE;
 400
 401   return pages[page].changed;
 402 }
 403
 404 /*****************************************************************************
 405  * Function:
 406  *      dot_fill
 407  *
 408  * Take a string and fill in the middle set of spaces with dots.
 409  */
 410 void
 411 dot_fill(char string[])
 412
 413 {
 414   short string_index= 0;
 415
 416   /* Find the end of the first set of spaces */
 417   while (string[string_index] == ' ') string_index += 1;
 418   /* Find the start of the second set of spaces */
 419   while (string[string_index] != ' ') string_index += 1;
 420   /* Change spaces to dots */
 421   while (string[string_index] == ' ')
 422     string[string_index++] = '.';
 423 }
 424
 425 /*****************************************************************************
 426  * Function:
 427  *      compare
 428  *
 429  * Compares two function entries, used by qsort().
 430  * Looks at name first, then start char.
 431  */
 432 int
 433 compare(const void *p1, const void *p2)
 434
 435 {
 436   int r;
 437   r = strcmp(((function_entry *)p1)->name,((function_entry *)p2)->name);
 438   if (r == 0)
 439     {
 440       if (((function_entry *)p1)->name_start_char > ((function_entry *)p2)->name_start_char)
 441         r = 1;
 442       else
 443         if (((function_entry *)p1)->name_start_char < ((function_entry *)p2)->name_start_char)
 444           r = -1;
 445         else
 446           r = 0;
 447     }
 448   return r;
 449 }
 450
 451 /*****************************************************************************
 452  * Function:
 453  *      sort_function_names
 454  *
 455  * Sort the array of function records into alphabetical order into the
 456  * array sorted_functions[].
 457  */
 458 void
 459 sort_function_names(void)
 460
 461 {
 462   unsigned short every_function;
 463
 464   size_t size_needed = function_list_size * sizeof(function_entry);
 465
 466   if (function_list_size == 0) return;
 467
 468   sorted_functions = xmalloc(size_needed);
 469
 470   for (every_function=0;every_function<no_of_functions;every_function++)
 471     sorted_functions[every_function] = functions[every_function];
 472   qsort((char *)sorted_functions,(int)no_of_functions,sizeof(function_entry),compare);
 473 }
 474
 475 /*****************************************************************************
 476  * Function:
 477  *      print_index
 478  *
 479  * Print out the contents of sorted_functions in order on a page or pages.
 480  */
 481 void
 482 print_index(void)
 483
 484 {
 485   unsigned short function_idx=0;
 486   long index_page_number=0;
 487   short output_line_number;
 488   boolean reached_end_of_sheet;
 489
 490   /*
 491    * If there is nothing to print, then print nothing...
 492    */
 493   if (no_of_functions == 0) return;
 494
 495   /*
 496    * For every page...
 497    */
 498   do
 499     {
 500       index_page_number += 1;
 501
 502       /*
 503        * ...print the header...
 504        */
 505       print_index_header(index_page_number);
 506
 507       output_line_number = 0;
 508
 509       /*
 510        * ...print the index a line at a time...
 511        */
 512       while ((output_line_number < page_length)
 513              && (function_idx < no_of_functions))
 514         {
 515
 516           char  output_line[INPUT_LINE_LEN];
 517
 518           /*
 519            * Every second line has dots in it...
 520            */
 521           if ((function_idx & 1) == 1)
 522             {
 523               sprintf(output_line,"          %-24s %4ld  (%s)",
 524                             sorted_functions[function_idx].name,
 525                             sorted_functions[function_idx].page_number,
 526                             sorted_functions[function_idx].filename);
 527               dot_fill(output_line);
 528               printf("Lpt(%s) show Nl\n",output_line);
 529             }
 530           else
 531             {
 532               sprintf(output_line,"          %-24s %4ld  (%s)\n",
 533                             sorted_functions[function_idx].name,
 534                             sorted_functions[function_idx].page_number,
 535                             sorted_functions[function_idx].filename);
 536               printf("Lpt(%s) show Nl\n",output_line);
 537             }
 538           output_line_number += 1;
 539           function_idx += 1;
 540         }
 541
 542       /*
 543        * ...and print the footer
 544        */
 545       reached_end_of_sheet = PS_endpage(TRUE);
 546
 547     } while (function_idx < no_of_functions);
 548
 549   /*
 550    * Print blank pages until the last page printed was the last page
 551    * on a physical sheet.
 552    */
 553   while (!reached_end_of_sheet)
 554     {
 555       index_page_number += 1;
 556       print_index_header(index_page_number);
 557       reached_end_of_sheet = PS_endpage(TRUE);
 558     }
 559 }
 560
 561 /*****************************************************************************
 562  * Function:
 563  *      print_index_line
 564  *
 565  * Prints out a line of the file index, which is either a filename or
 566  * a function name within the current file.
 567  */
 568 short
 569 print_index_line(int print_bold)
 570
 571 {
 572   static unsigned int   current_file = 0;
 573   static unsigned short function_idx = 0;
 574   static boolean          first_call = TRUE;
 575
 576   /*
 577    * If we haven't started printing out functions for a file
 578    * then we have to print out the filename first and we
 579    * print it in bold.  This will only happen on the first
 580    * call to print_index_line().
 581    */
 582   if (first_call)
 583     {
 584       printf("Lpt(    %-24s %5ld) BF setfont show CF setfont Nl\n",
 585                    files[current_file].name,
 586                    files[current_file].starting_page);
 587       first_call = FALSE;
 588       return(LINE);
 589     }
 590
 591   /*
 592    * OK, so we need to print out a function name.  Find the next
 593    * function name belonging to the current file in the sorted
 594    * array of functions.
 595    */
 596   while (function_idx != no_of_functions)
 597     {
 598       if (strcmp(files[current_file].name, sorted_functions[function_idx].filename) != 0)
 599         {
 600           /* if no match and not reached end continue with the next function name */
 601           function_idx += 1;
 602           continue;
 603         }
 604       else
 605         break;
 606     }
 607
 608   /*
 609    * If this comparison is true then we didn't find any more functions for this file.
 610    */
 611   if (function_idx == no_of_functions)
 612     {
 613       /* If reached end of last file return */
 614       if (++current_file >= no_of_files) return(INPUT_END);
 615       /*
 616        * else reached end of this file - print the filename of the next file in
 617        * bold and set up for starting printing function names for this title
 618        */
 619       printf("Lpt(    %-24s %5ld) BF setfont show CF setfont Nl\n",
 620                    files[current_file].name,
 621                    files[current_file].starting_page);
 622       function_idx = 0;
 623       return(LINE);
 624     }
 625
 626   /*
 627    * If "print_bold" then fill in with dots while printing out
 628    * function details.
 629    */
 630   if (print_bold)
 631     {
 632       char      string[INPUT_LINE_LEN];
 633
 634       sprintf(string,"          %-24s %4ld",
 635                     sorted_functions[function_idx].name,
 636                     sorted_functions[function_idx].page_number);
 637       dot_fill(string);
 638
 639       printf("Lpt(%s) show Nl\n",string);
 640     }
 641   else
 642     {
 643       printf("Lpt(          %-24s %4ld) show Nl\n",
 644                    sorted_functions[function_idx].name,
 645                    sorted_functions[function_idx].page_number);
 646     }
 647   function_idx += 1;
 648   return(LINE);
 649 }
 650
 651 /*****************************************************************************
 652  * Function:
 653  *      print_out_file_index
 654  *
 655  * Print out the contents of sorted_functions in order per file.
 656  */
 657 void
 658 print_out_file_index(void)
 659
 660 {
 661   long index_page_number=0;
 662   short output_line_number;
 663   short retval = LINE;
 664   boolean reached_end_of_sheet;
 665
 666   /*
 667    * For every page...
 668    */
 669   do
 670     {
 671       index_page_number += 1;
 672
 673       /*
 674        * ...print the header...
 675        */
 676       print_file_header(index_page_number);
 677
 678       output_line_number = 0;
 679
 680       /*
 681        * ...print all the lines, every second one with dots...
 682        */
 683       while (output_line_number < page_length)
 684         {
 685           PUTS("          ");
 686           if ((retval = print_index_line(output_line_number &1))
 687               == INPUT_END) break;
 688           output_line_number += 1;
 689         }
 690
 691       /*
 692        * ...and print the footer...
 693        */
 694       reached_end_of_sheet = PS_endpage(TRUE);
 695
 696     } while (retval == LINE);
 697
 698   /*
 699    * Print blank pages until the last page printed was the last page
 700    * on a physical sheet.
 701    */
 702   while (!reached_end_of_sheet)
 703     {
 704       index_page_number += 1;
 705       print_file_header(index_page_number);
 706       reached_end_of_sheet = PS_endpage(TRUE);
 707     }
 708 }