gas/listing.c

   1 /* listing.c - mainting assembly listings
   2    Copyright (C) 1991, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GAS, the GNU Assembler.
   5
   6 GAS is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GAS is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GAS; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19
  20 /*
  21  Contributed by Steve Chamberlain
  22                 sac@cygnus.com
  23
  24
  25  A listing page looks like:
  26
  27  LISTING_HEADER  sourcefilename pagenumber
  28  TITLE LINE
  29  SUBTITLE LINE
  30  linenumber address data  source
  31  linenumber address data  source
  32  linenumber address data  source
  33  linenumber address data  source
  34
  35  If not overridden, the listing commands are:
  36
  37  .title  "stuff"
  38         Put "stuff" onto the title line
  39  .sbttl  "stuff"
  40         Put stuff onto the subtitle line
  41
  42   If these commands come within 10 lines of the top of the page, they
  43   will affect the page they are on, as well as any subsequent page
  44
  45  .eject
  46         Thow a page
  47  .list
  48         Increment the enable listing counter
  49  .nolist
  50         Decrement the enable listing counter
  51
  52  .psize Y[,X]
  53         Set the paper size to X wide and Y high. Setting a psize Y of
  54         zero will suppress form feeds except where demanded by .eject
  55
  56  If the counter goes below zero, listing is suppressed.
  57
  58
  59  Listings are a maintained by read calling various listing_<foo>
  60  functions.  What happens most is that the macro NO_LISTING is not
  61  defined (from the Makefile), then the macro LISTING_NEWLINE expands
  62  into a call to listing_newline.  The call is done from read.c, every
  63  time it sees a newline, and -l is on the command line.
  64
  65  The function listing_newline remembers the frag associated with the
  66  newline, and creates a new frag - note that this is wasteful, but not
  67  a big deal, since listing slows things down a lot anyway.  The
  68  function also rememebers when the filename changes.
  69
  70  When all the input has finished, and gas has had a chance to settle
  71  down, the listing is output. This is done by running down the list of
  72  frag/source file records, and opening the files as needed and printing
  73  out the bytes and chars associated with them.
  74
  75  The only things which the architecture can change about the listing
  76  are defined in these macros:
  77
  78  LISTING_HEADER         The name of the architecture
  79  LISTING_WORD_SIZE      The make of the number of bytes in a word, this determines
  80                         the clumping of the output data. eg a value of
  81                         2 makes words look like 1234 5678, whilst 1
  82                         would make the same value look like 12 34 56
  83                         78
  84  LISTING_LHS_WIDTH      Number of words of above size for the lhs
  85
  86  LISTING_LHS_WIDTH_SECOND   Number of words for the data on the lhs
  87                         for the second line
  88
  89  LISTING_LHS_CONT_LINES Max number of lines to use up for a continutation
  90  LISTING_RHS_WIDTH      Number of chars from the input file to print
  91                         on a line
  92 */
  93
  94 #include "as.h"
  95
  96 #include <obstack.h>
  97 #include "input-file.h"
  98 #include "targ-cpu.h"
  99
 100 char *malloc();
 101
 102 #ifndef NO_LISTING
 103 #ifndef LISTING_HEADER
 104 #define LISTING_HEADER "GAS LISTING"
 105 #endif
 106 #ifndef LISTING_WORD_SIZE
 107 #define LISTING_WORD_SIZE 4
 108 #endif
 109 #ifndef LISTING_LHS_WIDTH
 110 #define LISTING_LHS_WIDTH 1
 111 #endif
 112 #ifndef LISTING_LHS_WIDTH_SECOND
 113 #define LISTING_LHS_WIDTH_SECOND 1
 114 #endif
 115 #ifndef LISTING_RHS_WIDTH
 116 #define LISTING_RHS_WIDTH 100
 117 #endif
 118 #ifndef LISTING_LHS_CONT_LINES
 119 #define LISTING_LHS_CONT_LINES 4
 120 #endif
 121
 122
 123
 124
 125 /* This structure remembers which .s were used */
 126 typedef struct file_info_struct
 127 {
 128   char *filename;
 129   int linenum;
 130   FILE *file;
 131   struct file_info_struct *next;
 132   int end_pending;
 133
 134 } file_info_type ;
 135
 136
 137 /* this structure rememebrs which line from which file goes into which
 138    frag */
 139 typedef struct list_info_struct
 140 {
 141   /* Frag which this line of source is nearest to */
 142   fragS *frag;
 143   /* The actual line in the source file */
 144   unsigned int line;
 145   /* Pointer to the file info struct for the file which this line
 146      belongs to */
 147   file_info_type *file;
 148
 149   /* Next in list */
 150   struct list_info_struct *next;
 151
 152
 153   /* Pointer to the file info struct for the high level language
 154      source line that belongs here */
 155   file_info_type *hll_file;
 156
 157   /* High level language source line */
 158   int hll_line;
 159
 160
 161   /* Pointer to any error message associated with this line */
 162   char *message;
 163
 164   enum
 165   {
 166     EDICT_NONE,
 167     EDICT_SBTTL,
 168     EDICT_TITLE,
 169     EDICT_NOLIST,
 170     EDICT_LIST,
 171     EDICT_EJECT
 172    } edict;
 173   char *edict_arg;
 174
 175 } list_info_type;
 176
 177
 178 static struct list_info_struct *head;
 179 struct list_info_struct *listing_tail;
 180 extern int listing;
 181 extern unsigned int  physical_input_line;
 182 extern fragS *frag_now;
 183
 184
 185 static int paper_width = 200;
 186 static int paper_height = 60;
 187
 188
 189 /* this static array is used to keep the text of data to be printed
 190    before the start of the line.
 191     It is stored so we can give a bit more info on the next line.  To much, and large
 192    initialized arrays will use up lots of paper.
 193  */
 194
 195 static char data_buffer[100];
 196 static unsigned int data_buffer_size;
 197
 198
 199 static void
 200 DEFUN(listing_message,(name, message),
 201       char *name AND
 202       char *message)
 203 {
 204   unsigned int l = strlen(name) + strlen(message)+1;
 205   char *n =  (char*)malloc(l);
 206   strcpy(n,name);
 207   strcat(n,message);
 208   if(listing_tail != (list_info_type *)NULL)
 209   {
 210     listing_tail->message = n;
 211   }
 212
 213 }
 214
 215
 216
 217
 218 void
 219 DEFUN(listing_warning,(message),
 220       char *message)
 221 {
 222   listing_message("Warning:", message);
 223 }
 224
 225 void
 226 DEFUN(listing_error,(message),
 227       char *message)
 228 {
 229   listing_message("Error:", message);
 230 }
 231
 232
 233
 234
 235 static file_info_type *file_info_head;
 236
 237 static file_info_type *
 238 DEFUN(file_info, (file_name),
 239            char *file_name)
 240 {
 241   /* Find an entry with this file name */
 242   file_info_type *p = file_info_head;
 243
 244   while (p != (file_info_type *)NULL)
 245   {
 246     if (strcmp(p->filename, file_name) == 0)
 247      return p;
 248     p = p->next;
 249   }
 250
 251   /* Make new entry */
 252
 253   p = (file_info_type *)xmalloc(sizeof(file_info_type));
 254   p->next = file_info_head;
 255   file_info_head = p;
 256   p->filename = xmalloc(strlen(file_name)+1);
 257   strcpy(p->filename, file_name);
 258   p->linenum = 0;
 259   p->end_pending = 0;
 260
 261   p->file = fopen(p->filename,"rb");
 262 if (p->file)  fgetc(p->file);
 263
 264
 265
 266   return p;
 267
 268 }
 269
 270
 271 static void
 272 DEFUN_VOID(new_frag)
 273 {
 274
 275     frag_wane(frag_now);
 276     frag_new(0);
 277
 278 }
 279
 280 void
 281 DEFUN(listing_newline,(ps),
 282       char *ps)
 283 {
 284   char *s = ps;
 285   extern char *file_name;
 286   static unsigned int last_line =0xffff ;
 287
 288
 289   list_info_type *new;
 290   if (physical_input_line != last_line)
 291   {
 292     last_line = physical_input_line;
 293     new_frag();
 294
 295     new  = (list_info_type *)malloc(sizeof(list_info_type));
 296     new->frag = frag_now;
 297     new->line = physical_input_line ;
 298     new->file = file_info(file_name);
 299
 300     if (listing_tail)
 301     {
 302       listing_tail->next = new;
 303     }
 304     else
 305     {
 306       head = new;
 307     }
 308     listing_tail = new;
 309     new->next = (list_info_type *)NULL;
 310     new->message = (char *)NULL;
 311     new->edict = EDICT_NONE;
 312     new->hll_file = (file_info_type*)NULL;
 313     new->hll_line = 0;
 314     new_frag();
 315   }
 316 }
 317
 318
 319 /*
 320  This function returns the next source line from the file supplied,
 321  truncated to size.  It appends a fake line to the end of each input
 322  file to make
 323 */
 324
 325 static char *
 326 DEFUN(buffer_line,(file, line, size),
 327       file_info_type *file AND
 328       char *line AND
 329       unsigned int size)
 330 {
 331   unsigned int count = 0;
 332   int c;
 333
 334   char *p = line;
 335
 336   /* If we couldn't open the file, return an empty line */
 337   if  (file->file == (FILE*)NULL)
 338   {
 339     return "";
 340   }
 341
 342   if (file->end_pending == 10) {
 343       *p ++ = '\n';
 344       fseek(file->file, 0,0 );
 345       file->linenum = 0;
 346       file->end_pending = 0;
 347     }
 348   c = fgetc(file->file);
 349
 350
 351   size -= 1;                    /* leave room for null */
 352
 353   while (c != EOF && c != '\n')
 354   {
 355     if (count < size)
 356      *p++ = c;
 357     count++;
 358
 359     c= fgetc(file->file);
 360
 361   }
 362   if (c == EOF)
 363   {
 364     file->end_pending ++;
 365     *p++ = '.';
 366     *p++ = '.';
 367     *p++ = '.';
 368   }
 369   file->linenum++;
 370   *p++ = 0;
 371   return line;
 372 }
 373
 374
 375 static char *fn;
 376
 377 static unsigned int eject;      /* Eject pending */
 378 static unsigned int page;       /* Current page number */
 379 static char *title;             /* current title */
 380 static char *subtitle;          /* current subtitle */
 381 static unsigned int on_page;    /* number of lines printed on current page */
 382
 383
 384 static void
 385 DEFUN(listing_page,(list),
 386     list_info_type *list)
 387 {
 388   /* Grope around, see if we can see a title or subtitle edict coming up
 389      soon  (we look down 10 lines of the page and see if it's there)*/
 390   if ((eject || (on_page >= paper_height)) && paper_height != 0)
 391   {
 392     unsigned int c = 10;
 393     int had_title = 0;
 394     int had_subtitle = 0;
 395
 396     page++;
 397
 398     while (c != 0 && list)
 399     {
 400       if (list->edict == EDICT_SBTTL && !had_subtitle)
 401       {
 402         had_subtitle = 1;
 403         subtitle = list->edict_arg;
 404       }
 405       if (list->edict == EDICT_TITLE && !had_title)
 406       {
 407         had_title = 1;
 408         title = list->edict_arg;
 409       }
 410       list = list->next;
 411       c--;
 412     }
 413
 414
 415     if (page > 1)
 416     {
 417       printf("\f");
 418     }
 419
 420     printf("%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
 421     printf("%s\n", title);
 422     printf("%s\n", subtitle);
 423     on_page = 3;
 424     eject = 0;
 425   }
 426 }
 427
 428
 429 static unsigned int
 430 DEFUN(calc_hex,(list),
 431       list_info_type *list)
 432 {
 433   list_info_type *first = list;
 434   list_info_type *last = first;
 435   unsigned int address = ~0;
 436
 437   fragS *frag;
 438   fragS *frag_ptr;
 439
 440   unsigned    int    byte_in_frag = 0;
 441
 442   int anything = 0;
 443
 444   /* Find first frag which says it belongs to this line */
 445   frag = list->frag;
 446   while (frag  && frag->line != list)
 447    frag = frag->fr_next;
 448
 449   frag_ptr = frag;
 450
 451   data_buffer_size = 0;
 452
 453   /* Dump all the frags which belong to this line */
 454   while (frag_ptr != (fragS *)NULL  && frag_ptr->line == first)
 455   {
 456     /* Print as many bytes from the fixed part as is sensible */
 457     while(byte_in_frag < frag_ptr->fr_fix && data_buffer_size < sizeof(data_buffer)-10)
 458     {
 459       if (address == ~0)
 460       {
 461         address = frag_ptr->fr_address;
 462       }
 463
 464       sprintf(data_buffer + data_buffer_size,
 465               "%02X",
 466               (frag_ptr->fr_literal[byte_in_frag]) & 0xff);
 467       data_buffer_size += 2;
 468       byte_in_frag++;
 469     }
 470   {
 471     unsigned int var_rep_max = byte_in_frag;
 472     unsigned int var_rep_idx = byte_in_frag;
 473
 474     /* Print as many bytes from the variable part as is sensible */
 475     while (byte_in_frag < frag_ptr->fr_var * frag_ptr->fr_offset
 476            && data_buffer_size < sizeof(data_buffer)-10)
 477     {
 478       if (address == ~0)
 479       {
 480         address =  frag_ptr->fr_address;
 481       }
 482 sprintf(data_buffer + data_buffer_size,
 483         "%02X",
 484         (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
 485 #if 0
 486       data_buffer[data_buffer_size++] = '*';
 487       data_buffer[data_buffer_size++] = '*';
 488 #endif
 489       data_buffer_size +=2;
 490
 491       var_rep_idx ++;
 492       byte_in_frag++;
 493
 494       if (var_rep_idx >= frag_ptr->fr_var)
 495        var_rep_idx = var_rep_max;
 496     }
 497   }
 498
 499     frag_ptr = frag_ptr->fr_next;
 500   }
 501   data_buffer[data_buffer_size++] = 0;
 502   return address;
 503 }
 504
 505
 506
 507
 508
 509
 510 static void
 511 DEFUN(print_lines,(list, string, address),
 512 list_info_type *list AND
 513 char *string AND
 514 unsigned int address)
 515 {
 516   unsigned int idx;
 517   unsigned int nchars;
 518   unsigned int lines;
 519   unsigned int byte_in_word =0;
 520   char *src = data_buffer;
 521
 522   /* Print the stuff on the first line */
 523   listing_page(list);
 524   nchars = (LISTING_WORD_SIZE*2 +1)  * LISTING_LHS_WIDTH ;
 525   /* Print the hex for the first line */
 526   if (address == ~0)
 527   {
 528     printf("% 4d     ", list->line);
 529     for (idx = 0; idx < nchars; idx++)
 530      printf(" ");
 531
 532     printf("\t%s\n", string ? string : "");
 533     on_page++;
 534     listing_page(0);
 535
 536   }
 537   else
 538   {
 539     if (had_errors())
 540     {
 541       printf("% 4d ???? ", list->line);
 542     }
 543     else
 544     {
 545     printf("% 4d %04x ", list->line, address);
 546   }
 547
 548     /* And the data to go along with it */
 549     idx = 0;
 550
 551     while (*src && idx < nchars)
 552     {
 553       printf("%c%c", src[0], src[1]);
 554       src += 2;
 555       byte_in_word++;
 556       if (byte_in_word == LISTING_WORD_SIZE)
 557       {
 558         printf(" ");
 559         idx++;
 560         byte_in_word = 0;
 561       }
 562       idx+=2;
 563     }
 564
 565     for (;idx < nchars; idx++)
 566      printf(" ");
 567
 568     printf("\t%s\n", string ? string : "");
 569     on_page++;
 570     listing_page(list);
 571     if (list->message)
 572     {
 573       printf("****  %s\n",list->message);
 574       listing_page(list);
 575       on_page++;
 576     }
 577
 578     for (lines = 0;
 579          lines < LISTING_LHS_CONT_LINES
 580          && *src;
 581          lines++) {
 582         nchars = ((LISTING_WORD_SIZE*2) +1)  * LISTING_LHS_WIDTH_SECOND -1;
 583         idx = 0;
 584         /* Print any more lines of data, but more compactly */
 585         printf("% 4d      ", list->line);
 586
 587         while (*src && idx < nchars)
 588         {
 589           printf("%c%c", src[0], src[1]);
 590           src+=2;
 591           idx+=2;
 592           byte_in_word++;
 593           if (byte_in_word == LISTING_WORD_SIZE)
 594           {
 595             printf(" ");
 596             idx++;
 597             byte_in_word = 0;
 598           }
 599         }
 600
 601         printf("\n");
 602         on_page++;
 603         listing_page(list);
 604
 605       }
 606
 607
 608   }
 609 }
 610
 611
 612
 613
 614
 615
 616 static void
 617 DEFUN_VOID(list_symbol_table)
 618 {
 619   extern symbolS *symbol_rootP;
 620
 621   symbolS *ptr ;
 622   eject = 1;
 623   listing_page(0);
 624   printf("DEFINED SYMBOLS\n");
 625   on_page++;
 626
 627   for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr))
 628   {
 629     if (ptr->sy_frag->line)
 630     {
 631       if (S_GET_NAME(ptr))
 632       {
 633
 634       if (strlen(S_GET_NAME(ptr)))
 635       {
 636         printf("%20s:%-5d  %2d:%08x %s \n",
 637                ptr->sy_frag->line->file->filename,
 638                ptr->sy_frag->line->line,
 639                S_GET_SEGMENT(ptr),
 640                S_GET_VALUE(ptr),
 641                S_GET_NAME(ptr));
 642       }
 643
 644       else
 645       {
 646         printf("%20s:%-5d  %2d:%08x\n",
 647                ptr->sy_frag->line->file->filename,
 648                ptr->sy_frag->line->line,
 649                S_GET_SEGMENT(ptr),
 650                S_GET_VALUE(ptr));
 651
 652
 653       }
 654
 655         on_page++;
 656         listing_page(0);
 657       }
 658     }
 659
 660   }
 661   printf("\n");
 662   on_page++;
 663   listing_page(0);
 664   printf("UNDEFINED SYMBOLS\n");
 665   on_page++;
 666   listing_page(0);
 667
 668   for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr))
 669   {
 670     if (S_GET_NAME(ptr) && strlen(S_GET_NAME(ptr)) != 0)
 671     {
 672       if (ptr->sy_frag->line == 0)
 673       {
 674         printf("%s\n",       S_GET_NAME(ptr));
 675         on_page++;
 676         listing_page(0);
 677       }
 678     }
 679   }
 680 }
 681
 682 void
 683 DEFUN(print_source,(current_file, list, buffer, width),
 684       file_info_type *current_file AND
 685       list_info_type *list AND
 686       char *buffer AND
 687       unsigned int width)
 688 {
 689   if (current_file->file) {
 690       while (current_file->linenum < list->hll_line)
 691       {
 692         char * p = buffer_line(current_file, buffer, width);
 693         printf("%4d:%-13s **** %s\n", current_file->linenum, current_file->filename, p);
 694         on_page++;
 695         listing_page(list);
 696       }
 697     }
 698 }
 699
 700 /* Sometimes the user doesn't want to be bothered by the debugging
 701    records inserted by the compiler, see if the line is suspicioous */
 702
 703 static int
 704 DEFUN(debugging_pseudo,(line),
 705       char *line)
 706 {
 707   while (isspace(*line))
 708    line++;
 709
 710   if(*line != '.') return 0;
 711
 712   line++;
 713
 714   if (strncmp(line, "def",3) == 0) return 1;
 715   if (strncmp(line, "val",3) == 0) return 1;
 716   if (strncmp(line, "scl",3) == 0) return 1;
 717   if (strncmp(line, "line",4) == 0) return 1;
 718   if (strncmp(line, "endef",5) == 0) return 1;
 719   if (strncmp(line, "ln",2) ==0) return 1;
 720   if (strncmp(line, "type",4) ==0) return 1;
 721   if (strncmp(line, "size",4) == 0) return 1;
 722   if (strncmp(line, "dim",3) ==0) return 1;
 723   if (strncmp(line, "tag",3) == 0) return 1;
 724
 725   return 0;
 726
 727 }
 728
 729 void
 730 DEFUN(listing_listing,(name),
 731       char *name)
 732 {
 733   list_info_type *list = head;
 734   file_info_type *current_hll_file = (file_info_type *)NULL;
 735
 736   unsigned  int page= 1;
 737   unsigned int prev  = 0;
 738   char *message;
 739   char *buffer;
 740   char *p;
 741   unsigned int addr = 0;
 742   int on_page = 0;
 743   int show_listing = 1;
 744   unsigned int width;
 745
 746   buffer = malloc(LISTING_RHS_WIDTH);
 747   eject = 1;
 748   list = head;
 749
 750   while (list != (list_info_type *)NULL && 0)
 751   {
 752     if (list->next)
 753      list->frag = list->next->frag;
 754     list = list->next;
 755
 756   }
 757
 758   list = head->next;
 759
 760
 761   while ( list)
 762   {
 763     width =  LISTING_RHS_WIDTH > paper_width ?  paper_width :
 764     LISTING_RHS_WIDTH;
 765
 766     switch (list->edict) {
 767       case EDICT_LIST:
 768         show_listing++;
 769         break;
 770       case EDICT_NOLIST:
 771         show_listing--;
 772         break;
 773       case EDICT_EJECT:
 774         break;
 775       case EDICT_NONE:
 776         break;
 777       case EDICT_TITLE:
 778         title = list->edict_arg;
 779         break;
 780       case EDICT_SBTTL:
 781         subtitle = list->edict_arg;
 782         break;
 783       default:
 784         abort();
 785       }
 786
 787     if (show_listing > 0)
 788     {
 789       /* Scan down the list and print all the stuff which can be done
 790          with this line (or lines) */
 791       message = 0;
 792
 793       if (list->hll_file)
 794       {
 795         current_hll_file = list->hll_file;
 796       }
 797
 798       if (current_hll_file && list->hll_line && listing & LISTING_HLL)
 799       {
 800         print_source(current_hll_file, list, buffer, width);
 801       }
 802
 803       p = buffer_line(list->file, buffer, width);
 804
 805       if (! ((listing & LISTING_NODEBUG) && debugging_pseudo(p)))
 806       {
 807         print_lines(list, p,  calc_hex(list));
 808       }
 809
 810       if (list->edict == EDICT_EJECT)
 811       {
 812         eject = 1;
 813       }
 814     }
 815     else
 816     {
 817
 818       p = buffer_line(list->file, buffer, width);
 819     }
 820
 821     list = list->next;
 822   }
 823   free(buffer);
 824 }
 825
 826 void
 827 DEFUN(listing_print,(name),
 828       char *name)
 829 {
 830   title = "";
 831   subtitle = "";
 832
 833   if (listing & LISTING_NOFORM)
 834   {
 835     paper_height = 0;
 836   }
 837
 838   if (listing & LISTING_LISTING)
 839   {
 840     listing_listing(name);
 841
 842   }
 843   if (listing & LISTING_SYMBOLS)
 844   {
 845     list_symbol_table();
 846   }
 847 }
 848
 849
 850 void
 851 DEFUN(listing_file,(name),
 852 char *name)
 853 {
 854   fn = name;
 855 }
 856
 857 void
 858 DEFUN_VOID(listing_eject)
 859 {
 860   listing_tail->edict = EDICT_EJECT;
 861 }
 862
 863 void
 864 DEFUN_VOID(listing_flags)
 865 {
 866
 867 }
 868 void
 869 DEFUN(listing_list,(on),
 870            unsigned int on)
 871 {
 872   listing_tail->edict = on ? EDICT_LIST : EDICT_NOLIST;
 873 }
 874
 875
 876 void
 877 DEFUN_VOID(listing_psize)
 878 {
 879   paper_height = get_absolute_expression();
 880
 881   if (paper_height < 0 || paper_height > 1000)
 882   {
 883     paper_height = 0;
 884     as_warn("strange paper height, set to no form");
 885   }
 886  if (*input_line_pointer == ',')
 887   {
 888     input_line_pointer++;
 889     paper_width = get_absolute_expression();
 890   }
 891 }
 892
 893
 894 void
 895 DEFUN(listing_title,(depth),
 896       unsigned int depth)
 897 {
 898   char *start;
 899   char *title;
 900   unsigned int length;
 901
 902   SKIP_WHITESPACE();
 903   if (*input_line_pointer=='\"') {
 904       input_line_pointer++;
 905       start = input_line_pointer;
 906
 907       while (*input_line_pointer)
 908       {
 909         if (*input_line_pointer == '\"')
 910         {
 911           length = input_line_pointer - start;
 912           title = malloc(length + 1);
 913           memcpy(title, start, length);
 914           title[length] = 0;
 915           listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
 916           listing_tail->edict_arg = title;
 917           input_line_pointer++;
 918           demand_empty_rest_of_line();
 919           return;
 920         }
 921         else if (*input_line_pointer == '\n')
 922         {
 923           as_bad("New line in title");
 924           demand_empty_rest_of_line();
 925           return;
 926         }
 927         else
 928         {
 929           input_line_pointer++;
 930         }
 931       }
 932     }
 933   else
 934   {
 935     as_bad("expecting title in quotes");
 936   }
 937 }
 938
 939
 940
 941 void
 942 DEFUN(listing_source_line,(line),
 943            unsigned int line)
 944 {
 945   new_frag();
 946   listing_tail->hll_line = line;
 947   new_frag();
 948
 949 }
 950
 951 void
 952 DEFUN(listing_source_file,(file),
 953          char *file)
 954 {
 955   listing_tail->hll_file = file_info(file);
 956 }
 957
 958
 959
 960 #else
 961
 962
 963 /* Dummy functions for when compiled without listing enabled */
 964
 965 void
 966 DEFUN_VOID(listing_flags)
 967 {
 968   s_ignore();
 969 }
 970
 971 void DEFUN_VOID(listing_list)
 972 {
 973   s_ignore();
 974 }
 975
 976 void DEFUN_VOID(listing_eject)
 977 {
 978   s_ignore();
 979 }
 980 void DEFUN(listing_psize)
 981 {
 982   s_ignore();
 983 }
 984
 985 void DEFUN(listing_title, (depth),
 986 unsigned int depth)
 987 {
 988   s_ignore();
 989 }
 990 void
 991 DEFUN(listing_file,(name),
 992 char *name)
 993 {
 994
 995 }
 996
 997 void DEFUN(listing_newline,(name),
 998 char *name)
 999 {
1000
1001 }
1002
1003 void DEFUN(listing_source_line,(n),
1004 unsigned int n)
1005 {
1006
1007 }
1008 void DEFUN(listing_source_file, (n),
1009 char *n)
1010 {
1011
1012 }
1013
1014
1015
1016 #endif
1017