Fix typo introduced by previous delta
[binutils.git] / gas / listing.c
blob642cb6f9f016fefd69a2e7b4e98d68b9479cad83
1 /* listing.c - maintain assembly listings
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2005
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
23 /* Contributed by Steve Chamberlain <sac@cygnus.com>
25 A listing page looks like:
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
35 If not overridden, the listing commands are:
37 .title "stuff"
38 Put "stuff" onto the title line
39 .sbttl "stuff"
40 Put stuff onto the subtitle line
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
45 .eject
46 Thow a page
47 .list
48 Increment the enable listing counter
49 .nolist
50 Decrement the enable listing counter
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
56 If the counter goes below zero, listing is suppressed.
58 Listings are a maintained by read calling various listing_<foo>
59 functions. What happens most is that the macro NO_LISTING is not
60 defined (from the Makefile), then the macro LISTING_NEWLINE expands
61 into a call to listing_newline. The call is done from read.c, every
62 time it sees a newline, and -l is on the command line.
64 The function listing_newline remembers the frag associated with the
65 newline, and creates a new frag - note that this is wasteful, but not
66 a big deal, since listing slows things down a lot anyway. The
67 function also remembers when the filename changes.
69 When all the input has finished, and gas has had a chance to settle
70 down, the listing is output. This is done by running down the list of
71 frag/source file records, and opening the files as needed and printing
72 out the bytes and chars associated with them.
74 The only things which the architecture can change about the listing
75 are defined in these macros:
77 LISTING_HEADER The name of the architecture
78 LISTING_WORD_SIZE The make of the number of bytes in a word, this determines
79 the clumping of the output data. eg a value of
80 2 makes words look like 1234 5678, whilst 1
81 would make the same value look like 12 34 56
83 LISTING_LHS_WIDTH Number of words of above size for the lhs
85 LISTING_LHS_WIDTH_SECOND Number of words for the data on the lhs
86 for the second line
88 LISTING_LHS_CONT_LINES Max number of lines to use up for a continuation
89 LISTING_RHS_WIDTH Number of chars from the input file to print
90 on a line. */
92 #include "as.h"
93 #include "obstack.h"
94 #include "safe-ctype.h"
95 #include "input-file.h"
96 #include "subsegs.h"
98 #ifndef NO_LISTING
100 #ifndef LISTING_HEADER
101 #define LISTING_HEADER "GAS LISTING"
102 #endif
103 #ifndef LISTING_WORD_SIZE
104 #define LISTING_WORD_SIZE 4
105 #endif
106 #ifndef LISTING_LHS_WIDTH
107 #define LISTING_LHS_WIDTH ((LISTING_WORD_SIZE) > 4 ? 1 : 4 / (LISTING_WORD_SIZE))
108 #endif
109 #ifndef LISTING_LHS_WIDTH_SECOND
110 #define LISTING_LHS_WIDTH_SECOND LISTING_LHS_WIDTH
111 #endif
112 #ifndef LISTING_RHS_WIDTH
113 #define LISTING_RHS_WIDTH 100
114 #endif
115 #ifndef LISTING_LHS_CONT_LINES
116 #define LISTING_LHS_CONT_LINES 4
117 #endif
119 /* This structure remembers which .s were used. */
120 typedef struct file_info_struct
122 struct file_info_struct * next;
123 char * filename;
124 long pos;
125 unsigned int linenum;
126 int at_end;
127 } file_info_type;
129 /* This structure remembers which line from which file goes into which
130 frag. */
131 struct list_info_struct
133 /* Frag which this line of source is nearest to. */
134 fragS *frag;
136 /* The actual line in the source file. */
137 unsigned int line;
139 /* Pointer to the file info struct for the file which this line
140 belongs to. */
141 file_info_type *file;
143 /* The expanded text of any macro that may have been executing. */
144 char *line_contents;
146 /* Next in list. */
147 struct list_info_struct *next;
149 /* Pointer to the file info struct for the high level language
150 source line that belongs here. */
151 file_info_type *hll_file;
153 /* High level language source line. */
154 unsigned int hll_line;
156 /* Pointer to any error message associated with this line. */
157 char *message;
159 enum
161 EDICT_NONE,
162 EDICT_SBTTL,
163 EDICT_TITLE,
164 EDICT_NOLIST,
165 EDICT_LIST,
166 EDICT_NOLIST_NEXT,
167 EDICT_EJECT
168 } edict;
169 char *edict_arg;
171 /* Nonzero if this line is to be omitted because it contains
172 debugging information. This can become a flags field if we come
173 up with more information to store here. */
174 int debugging;
177 typedef struct list_info_struct list_info_type;
179 int listing_lhs_width = LISTING_LHS_WIDTH;
180 int listing_lhs_width_second = LISTING_LHS_WIDTH_SECOND;
181 int listing_lhs_cont_lines = LISTING_LHS_CONT_LINES;
182 int listing_rhs_width = LISTING_RHS_WIDTH;
184 struct list_info_struct * listing_tail;
186 static file_info_type * file_info_head;
187 static file_info_type * last_open_file_info;
188 static FILE * last_open_file;
189 static struct list_info_struct * head;
190 static int paper_width = 200;
191 static int paper_height = 60;
193 extern int listing;
195 /* File to output listings to. */
196 static FILE *list_file;
198 /* This static array is used to keep the text of data to be printed
199 before the start of the line. */
201 #define MAX_BYTES \
202 (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width \
203 + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second) \
204 * listing_lhs_cont_lines) \
205 + 20)
207 static char *data_buffer;
209 /* Prototypes. */
210 static void listing_message (const char *, const char *);
211 static file_info_type *file_info (const char *);
212 static void new_frag (void);
213 static char *buffer_line (file_info_type *, char *, unsigned int);
214 static void listing_page (list_info_type *);
215 static unsigned int calc_hex (list_info_type *);
216 static void print_lines (list_info_type *, unsigned int, char *, unsigned int);
217 static void list_symbol_table (void);
218 static void print_source (file_info_type *, list_info_type *, char *, unsigned int);
219 static int debugging_pseudo (list_info_type *, const char *);
220 static void listing_listing (char *);
222 static void
223 listing_message (const char *name, const char *message)
225 if (listing_tail != (list_info_type *) NULL)
227 unsigned int l = strlen (name) + strlen (message) + 1;
228 char *n = (char *) xmalloc (l);
229 strcpy (n, name);
230 strcat (n, message);
231 listing_tail->message = n;
235 void
236 listing_warning (const char *message)
238 listing_message (_("Warning:"), message);
241 void
242 listing_error (const char *message)
244 listing_message (_("Error:"), message);
247 static file_info_type *
248 file_info (const char *file_name)
250 /* Find an entry with this file name. */
251 file_info_type *p = file_info_head;
253 while (p != (file_info_type *) NULL)
255 if (strcmp (p->filename, file_name) == 0)
256 return p;
257 p = p->next;
260 /* Make new entry. */
261 p = xmalloc (sizeof (file_info_type));
262 p->next = file_info_head;
263 file_info_head = p;
264 p->filename = xstrdup (file_name);
265 p->pos = 0;
266 p->linenum = 0;
267 p->at_end = 0;
269 return p;
272 static void
273 new_frag (void)
275 frag_wane (frag_now);
276 frag_new (0);
279 void
280 listing_newline (char *ps)
282 char *file;
283 unsigned int line;
284 static unsigned int last_line = 0xffff;
285 static char *last_file = NULL;
286 list_info_type *new = NULL;
288 if (listing == 0)
289 return;
291 if (now_seg == absolute_section)
292 return;
294 #ifdef OBJ_ELF
295 /* In ELF, anything in a section beginning with .debug or .line is
296 considered to be debugging information. This includes the
297 statement which switches us into the debugging section, which we
298 can only set after we are already in the debugging section. */
299 if ((listing & LISTING_NODEBUG) != 0
300 && listing_tail != NULL
301 && ! listing_tail->debugging)
303 const char *segname;
305 segname = segment_name (now_seg);
306 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
307 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
308 listing_tail->debugging = 1;
310 #endif
312 as_where (&file, &line);
313 if (ps == NULL)
315 if (line == last_line
316 && !(last_file && file && strcmp (file, last_file)))
317 return;
319 new = (list_info_type *) xmalloc (sizeof (list_info_type));
321 /* Detect if we are reading from stdin by examining the file
322 name returned by as_where().
324 [FIXME: We rely upon the name in the strcmp below being the
325 same as the one used by input_scrub_new_file(), if that is
326 not true, then this code will fail].
328 If we are reading from stdin, then we need to save each input
329 line here (assuming of course that we actually have a line of
330 input to read), so that it can be displayed in the listing
331 that is produced at the end of the assembly. */
332 if (strcmp (file, _("{standard input}")) == 0
333 && input_line_pointer != NULL)
335 char *copy;
336 int len;
337 int seen_quote = 0;
339 for (copy = input_line_pointer - 1;
340 *copy && (seen_quote
341 || (! is_end_of_line [(unsigned char) *copy]));
342 copy++)
343 if (*copy == '"' && copy[-1] != '\\')
344 seen_quote = ! seen_quote;
346 len = (copy - input_line_pointer) + 2;
348 copy = xmalloc (len);
350 if (copy != NULL)
352 char *src = input_line_pointer - 1;
353 char *dest = copy;
355 while (--len)
357 unsigned char c = *src++;
359 /* Omit control characters in the listing. */
360 if (!ISCNTRL (c))
361 *dest++ = c;
364 *dest = 0;
367 new->line_contents = copy;
369 else
370 new->line_contents = NULL;
372 else
374 new = xmalloc (sizeof (list_info_type));
375 new->line_contents = ps;
378 last_line = line;
379 last_file = file;
381 new_frag ();
383 if (listing_tail)
384 listing_tail->next = new;
385 else
386 head = new;
388 listing_tail = new;
390 new->frag = frag_now;
391 new->line = line;
392 new->file = file_info (file);
393 new->next = (list_info_type *) NULL;
394 new->message = (char *) NULL;
395 new->edict = EDICT_NONE;
396 new->hll_file = (file_info_type *) NULL;
397 new->hll_line = 0;
398 new->debugging = 0;
400 new_frag ();
402 #ifdef OBJ_ELF
403 /* In ELF, anything in a section beginning with .debug or .line is
404 considered to be debugging information. */
405 if ((listing & LISTING_NODEBUG) != 0)
407 const char *segname;
409 segname = segment_name (now_seg);
410 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
411 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
412 new->debugging = 1;
414 #endif
417 /* Attach all current frags to the previous line instead of the
418 current line. This is called by the MIPS backend when it discovers
419 that it needs to add some NOP instructions; the added NOP
420 instructions should go with the instruction that has the delay, not
421 with the new instruction. */
423 void
424 listing_prev_line (void)
426 list_info_type *l;
427 fragS *f;
429 if (head == (list_info_type *) NULL
430 || head == listing_tail)
431 return;
433 new_frag ();
435 for (l = head; l->next != listing_tail; l = l->next)
438 for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next)
439 if (f->line == listing_tail)
440 f->line = l;
442 listing_tail->frag = frag_now;
443 new_frag ();
446 /* This function returns the next source line from the file supplied,
447 truncated to size. It appends a fake line to the end of each input
448 file to make. */
450 static char *
451 buffer_line (file_info_type *file, char *line, unsigned int size)
453 unsigned int count = 0;
454 int c;
456 char *p = line;
458 /* If we couldn't open the file, return an empty line. */
459 if (file->at_end)
460 return "";
462 /* Check the cache and see if we last used this file. */
463 if (!last_open_file_info || file != last_open_file_info)
465 if (last_open_file)
467 last_open_file_info->pos = ftell (last_open_file);
468 fclose (last_open_file);
471 last_open_file_info = file;
472 last_open_file = fopen (file->filename, FOPEN_RT);
473 if (last_open_file == NULL)
475 file->at_end = 1;
476 return "";
479 /* Seek to where we were last time this file was open. */
480 if (file->pos)
481 fseek (last_open_file, file->pos, SEEK_SET);
484 c = fgetc (last_open_file);
486 /* Leave room for null. */
487 size -= 1;
489 while (c != EOF && c != '\n')
491 if (count < size)
492 *p++ = c;
493 count++;
495 c = fgetc (last_open_file);
498 if (c == EOF)
500 file->at_end = 1;
501 if (count + 2 < size)
503 *p++ = '.';
504 *p++ = '.';
505 *p++ = '.';
508 file->linenum++;
509 *p++ = 0;
510 return line;
513 static const char *fn;
515 static unsigned int eject; /* Eject pending */
516 static unsigned int page; /* Current page number */
517 static char *title; /* Current title */
518 static char *subtitle; /* Current subtitle */
519 static unsigned int on_page; /* Number of lines printed on current page */
521 static void
522 listing_page (list_info_type *list)
524 /* Grope around, see if we can see a title or subtitle edict coming up
525 soon. (we look down 10 lines of the page and see if it's there) */
526 if ((eject || (on_page >= (unsigned int) paper_height))
527 && paper_height != 0)
529 unsigned int c = 10;
530 int had_title = 0;
531 int had_subtitle = 0;
533 page++;
535 while (c != 0 && list)
537 if (list->edict == EDICT_SBTTL && !had_subtitle)
539 had_subtitle = 1;
540 subtitle = list->edict_arg;
542 if (list->edict == EDICT_TITLE && !had_title)
544 had_title = 1;
545 title = list->edict_arg;
547 list = list->next;
548 c--;
551 if (page > 1)
553 fprintf (list_file, "\f");
556 fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
557 fprintf (list_file, "%s\n", title);
558 fprintf (list_file, "%s\n", subtitle);
559 on_page = 3;
560 eject = 0;
564 static unsigned int
565 calc_hex (list_info_type *list)
567 int data_buffer_size;
568 list_info_type *first = list;
569 unsigned int address = ~(unsigned int) 0;
570 fragS *frag;
571 fragS *frag_ptr;
572 unsigned int octet_in_frag;
574 /* Find first frag which says it belongs to this line. */
575 frag = list->frag;
576 while (frag && frag->line != list)
577 frag = frag->fr_next;
579 frag_ptr = frag;
581 data_buffer_size = 0;
583 /* Dump all the frags which belong to this line. */
584 while (frag_ptr != (fragS *) NULL && frag_ptr->line == first)
586 /* Print as many bytes from the fixed part as is sensible. */
587 octet_in_frag = 0;
588 while ((offsetT) octet_in_frag < frag_ptr->fr_fix
589 && data_buffer_size < MAX_BYTES - 3)
591 if (address == ~(unsigned int) 0)
592 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
594 sprintf (data_buffer + data_buffer_size,
595 "%02X",
596 (frag_ptr->fr_literal[octet_in_frag]) & 0xff);
597 data_buffer_size += 2;
598 octet_in_frag++;
600 if (frag_ptr->fr_type == rs_fill)
602 unsigned int var_rep_max = octet_in_frag;
603 unsigned int var_rep_idx = octet_in_frag;
605 /* Print as many bytes from the variable part as is sensible. */
606 while (((offsetT) octet_in_frag
607 < (frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset))
608 && data_buffer_size < MAX_BYTES - 3)
610 if (address == ~(unsigned int) 0)
611 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
613 sprintf (data_buffer + data_buffer_size,
614 "%02X",
615 (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
616 data_buffer_size += 2;
618 var_rep_idx++;
619 octet_in_frag++;
621 if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
622 var_rep_idx = var_rep_max;
626 frag_ptr = frag_ptr->fr_next;
628 data_buffer[data_buffer_size] = '\0';
629 return address;
632 static void
633 print_lines (list_info_type *list, unsigned int lineno,
634 char *string, unsigned int address)
636 unsigned int idx;
637 unsigned int nchars;
638 unsigned int lines;
639 unsigned int octet_in_word = 0;
640 char *src = data_buffer;
641 int cur;
643 /* Print the stuff on the first line. */
644 listing_page (list);
645 nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width;
647 /* Print the hex for the first line. */
648 if (address == ~(unsigned int) 0)
650 fprintf (list_file, "% 4d ", lineno);
651 for (idx = 0; idx < nchars; idx++)
652 fprintf (list_file, " ");
654 fprintf (list_file, "\t%s\n", string ? string : "");
656 on_page++;
658 listing_page (0);
660 return;
663 if (had_errors ())
664 fprintf (list_file, "% 4d ???? ", lineno);
665 else
666 fprintf (list_file, "% 4d %04x ", lineno, address);
668 /* And the data to go along with it. */
669 idx = 0;
670 cur = 0;
671 while (src[cur] && idx < nchars)
673 int offset;
674 offset = cur;
675 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
676 cur += 2;
677 octet_in_word++;
679 if (octet_in_word == LISTING_WORD_SIZE)
681 fprintf (list_file, " ");
682 idx++;
683 octet_in_word = 0;
686 idx += 2;
689 for (; idx < nchars; idx++)
690 fprintf (list_file, " ");
692 fprintf (list_file, "\t%s\n", string ? string : "");
693 on_page++;
694 listing_page (list);
696 if (list->message)
698 fprintf (list_file, "**** %s\n", list->message);
699 listing_page (list);
700 on_page++;
703 for (lines = 0;
704 lines < (unsigned int) listing_lhs_cont_lines
705 && src[cur];
706 lines++)
708 nchars = ((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second - 1;
709 idx = 0;
711 /* Print any more lines of data, but more compactly. */
712 fprintf (list_file, "% 4d ", lineno);
714 while (src[cur] && idx < nchars)
716 int offset;
717 offset = cur;
718 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
719 cur += 2;
720 idx += 2;
721 octet_in_word++;
723 if (octet_in_word == LISTING_WORD_SIZE)
725 fprintf (list_file, " ");
726 idx++;
727 octet_in_word = 0;
731 fprintf (list_file, "\n");
732 on_page++;
733 listing_page (list);
737 static void
738 list_symbol_table (void)
740 extern symbolS *symbol_rootP;
741 int got_some = 0;
743 symbolS *ptr;
744 eject = 1;
745 listing_page (0);
747 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
749 if (SEG_NORMAL (S_GET_SEGMENT (ptr))
750 || S_GET_SEGMENT (ptr) == absolute_section)
752 #ifdef BFD_ASSEMBLER
753 /* Don't report section symbols. They are not interesting. */
754 if (symbol_section_p (ptr))
755 continue;
756 #endif
757 if (S_GET_NAME (ptr))
759 char buf[30], fmt[8];
760 valueT val = S_GET_VALUE (ptr);
762 /* @@ Note that this is dependent on the compilation options,
763 not solely on the target characteristics. */
764 if (sizeof (val) == 4 && sizeof (int) == 4)
765 sprintf (buf, "%08lx", (unsigned long) val);
766 else if (sizeof (val) <= sizeof (unsigned long))
768 sprintf (fmt, "%%0%lulx",
769 (unsigned long) (sizeof (val) * 2));
770 sprintf (buf, fmt, (unsigned long) val);
772 #if defined (BFD64)
773 else if (sizeof (val) > 4)
774 sprintf_vma (buf, val);
775 #endif
776 else
777 abort ();
779 if (!got_some)
781 fprintf (list_file, "DEFINED SYMBOLS\n");
782 on_page++;
783 got_some = 1;
786 if (symbol_get_frag (ptr) && symbol_get_frag (ptr)->line)
788 fprintf (list_file, "%20s:%-5d %s:%s %s\n",
789 symbol_get_frag (ptr)->line->file->filename,
790 symbol_get_frag (ptr)->line->line,
791 segment_name (S_GET_SEGMENT (ptr)),
792 buf, S_GET_NAME (ptr));
794 else
796 fprintf (list_file, "%33s:%s %s\n",
797 segment_name (S_GET_SEGMENT (ptr)),
798 buf, S_GET_NAME (ptr));
801 on_page++;
802 listing_page (0);
807 if (!got_some)
809 fprintf (list_file, "NO DEFINED SYMBOLS\n");
810 on_page++;
812 fprintf (list_file, "\n");
813 on_page++;
814 listing_page (0);
816 got_some = 0;
818 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
820 if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0)
822 if (S_GET_SEGMENT (ptr) == undefined_section)
824 if (!got_some)
826 got_some = 1;
827 fprintf (list_file, "UNDEFINED SYMBOLS\n");
828 on_page++;
829 listing_page (0);
831 fprintf (list_file, "%s\n", S_GET_NAME (ptr));
832 on_page++;
833 listing_page (0);
837 if (!got_some)
839 fprintf (list_file, "NO UNDEFINED SYMBOLS\n");
840 on_page++;
841 listing_page (0);
845 static void
846 print_source (file_info_type *current_file, list_info_type *list,
847 char *buffer, unsigned int width)
849 if (!current_file->at_end)
851 while (current_file->linenum < list->hll_line
852 && !current_file->at_end)
854 char *p = buffer_line (current_file, buffer, width);
856 fprintf (list_file, "%4u:%-13s **** %s\n", current_file->linenum,
857 current_file->filename, p);
858 on_page++;
859 listing_page (list);
864 /* Sometimes the user doesn't want to be bothered by the debugging
865 records inserted by the compiler, see if the line is suspicious. */
867 static int
868 debugging_pseudo (list_info_type *list, const char *line)
870 static int in_debug;
871 int was_debug;
873 if (list->debugging)
875 in_debug = 1;
876 return 1;
879 was_debug = in_debug;
880 in_debug = 0;
882 while (ISSPACE (*line))
883 line++;
885 if (*line != '.')
887 #ifdef OBJ_ELF
888 /* The ELF compiler sometimes emits blank lines after switching
889 out of a debugging section. If the next line drops us back
890 into debugging information, then don't print the blank line.
891 This is a hack for a particular compiler behaviour, not a
892 general case. */
893 if (was_debug
894 && *line == '\0'
895 && list->next != NULL
896 && list->next->debugging)
898 in_debug = 1;
899 return 1;
901 #endif
903 return 0;
906 line++;
908 if (strncmp (line, "def", 3) == 0)
909 return 1;
910 if (strncmp (line, "val", 3) == 0)
911 return 1;
912 if (strncmp (line, "scl", 3) == 0)
913 return 1;
914 if (strncmp (line, "line", 4) == 0)
915 return 1;
916 if (strncmp (line, "endef", 5) == 0)
917 return 1;
918 if (strncmp (line, "ln", 2) == 0)
919 return 1;
920 if (strncmp (line, "type", 4) == 0)
921 return 1;
922 if (strncmp (line, "size", 4) == 0)
923 return 1;
924 if (strncmp (line, "dim", 3) == 0)
925 return 1;
926 if (strncmp (line, "tag", 3) == 0)
927 return 1;
928 if (strncmp (line, "stabs", 5) == 0)
929 return 1;
930 if (strncmp (line, "stabn", 5) == 0)
931 return 1;
933 return 0;
936 static void
937 listing_listing (char *name ATTRIBUTE_UNUSED)
939 list_info_type *list = head;
940 file_info_type *current_hll_file = (file_info_type *) NULL;
941 char *message;
942 char *buffer;
943 char *p;
944 int show_listing = 1;
945 unsigned int width;
947 buffer = xmalloc (listing_rhs_width);
948 data_buffer = xmalloc (MAX_BYTES);
949 eject = 1;
950 list = head;
952 while (list != (list_info_type *) NULL && 0)
954 if (list->next)
955 list->frag = list->next->frag;
956 list = list->next;
959 list = head->next;
961 while (list)
963 unsigned int list_line;
965 width = listing_rhs_width > paper_width ? paper_width :
966 listing_rhs_width;
968 list_line = list->line;
969 switch (list->edict)
971 case EDICT_LIST:
972 /* Skip all lines up to the current. */
973 list_line--;
974 break;
975 case EDICT_NOLIST:
976 show_listing--;
977 break;
978 case EDICT_NOLIST_NEXT:
979 if (show_listing == 0)
980 list_line--;
981 break;
982 case EDICT_EJECT:
983 break;
984 case EDICT_NONE:
985 break;
986 case EDICT_TITLE:
987 title = list->edict_arg;
988 break;
989 case EDICT_SBTTL:
990 subtitle = list->edict_arg;
991 break;
992 default:
993 abort ();
996 if (show_listing <= 0)
998 while (list->file->linenum < list_line
999 && !list->file->at_end)
1000 p = buffer_line (list->file, buffer, width);
1003 if (list->edict == EDICT_LIST
1004 || (list->edict == EDICT_NOLIST_NEXT && show_listing == 0))
1006 /* Enable listing for the single line that caused the enable. */
1007 list_line++;
1008 show_listing++;
1011 if (show_listing > 0)
1013 /* Scan down the list and print all the stuff which can be done
1014 with this line (or lines). */
1015 message = 0;
1017 if (list->hll_file)
1018 current_hll_file = list->hll_file;
1020 if (current_hll_file && list->hll_line && (listing & LISTING_HLL))
1021 print_source (current_hll_file, list, buffer, width);
1023 if (list->line_contents)
1025 if (!((listing & LISTING_NODEBUG)
1026 && debugging_pseudo (list, list->line_contents)))
1027 print_lines (list,
1028 list->file->linenum == 0 ? list->line : list->file->linenum,
1029 list->line_contents, calc_hex (list));
1031 free (list->line_contents);
1032 list->line_contents = NULL;
1034 else
1036 while (list->file->linenum < list_line
1037 && !list->file->at_end)
1039 unsigned int address;
1041 p = buffer_line (list->file, buffer, width);
1043 if (list->file->linenum < list_line)
1044 address = ~(unsigned int) 0;
1045 else
1046 address = calc_hex (list);
1048 if (!((listing & LISTING_NODEBUG)
1049 && debugging_pseudo (list, p)))
1050 print_lines (list, list->file->linenum, p, address);
1054 if (list->edict == EDICT_EJECT)
1055 eject = 1;
1058 if (list->edict == EDICT_NOLIST_NEXT && show_listing == 1)
1059 --show_listing;
1061 list = list->next;
1064 free (buffer);
1065 free (data_buffer);
1066 data_buffer = NULL;
1069 void
1070 listing_print (char *name)
1072 int using_stdout;
1074 title = "";
1075 subtitle = "";
1077 if (name == NULL)
1079 list_file = stdout;
1080 using_stdout = 1;
1082 else
1084 list_file = fopen (name, FOPEN_WT);
1085 if (list_file != NULL)
1086 using_stdout = 0;
1087 else
1089 #ifdef BFD_ASSEMBLER
1090 bfd_set_error (bfd_error_system_call);
1091 #endif
1092 as_perror (_("can't open list file: %s"), name);
1093 list_file = stdout;
1094 using_stdout = 1;
1098 if (listing & LISTING_NOFORM)
1099 paper_height = 0;
1101 if (listing & LISTING_LISTING)
1102 listing_listing (name);
1104 if (listing & LISTING_SYMBOLS)
1105 list_symbol_table ();
1107 if (! using_stdout)
1109 if (fclose (list_file) == EOF)
1111 #ifdef BFD_ASSEMBLER
1112 bfd_set_error (bfd_error_system_call);
1113 #endif
1114 as_perror (_("error closing list file: %s"), name);
1118 if (last_open_file)
1119 fclose (last_open_file);
1122 void
1123 listing_file (const char *name)
1125 fn = name;
1128 void
1129 listing_eject (int ignore ATTRIBUTE_UNUSED)
1131 if (listing)
1132 listing_tail->edict = EDICT_EJECT;
1135 void
1136 listing_flags (int ignore ATTRIBUTE_UNUSED)
1138 while ((*input_line_pointer++) && (*input_line_pointer != '\n'))
1139 input_line_pointer++;
1143 /* Turn listing on or off. An argument of 0 means to turn off
1144 listing. An argument of 1 means to turn on listing. An argument
1145 of 2 means to turn off listing, but as of the next line; that is,
1146 the current line should be listed, but the next line should not. */
1148 void
1149 listing_list (int on)
1151 if (listing)
1153 switch (on)
1155 case 0:
1156 if (listing_tail->edict == EDICT_LIST)
1157 listing_tail->edict = EDICT_NONE;
1158 else
1159 listing_tail->edict = EDICT_NOLIST;
1160 break;
1161 case 1:
1162 if (listing_tail->edict == EDICT_NOLIST
1163 || listing_tail->edict == EDICT_NOLIST_NEXT)
1164 listing_tail->edict = EDICT_NONE;
1165 else
1166 listing_tail->edict = EDICT_LIST;
1167 break;
1168 case 2:
1169 listing_tail->edict = EDICT_NOLIST_NEXT;
1170 break;
1171 default:
1172 abort ();
1177 void
1178 listing_psize (int width_only)
1180 if (! width_only)
1182 paper_height = get_absolute_expression ();
1184 if (paper_height < 0 || paper_height > 1000)
1186 paper_height = 0;
1187 as_warn (_("strange paper height, set to no form"));
1190 if (*input_line_pointer != ',')
1192 demand_empty_rest_of_line ();
1193 return;
1196 ++input_line_pointer;
1199 paper_width = get_absolute_expression ();
1201 demand_empty_rest_of_line ();
1204 void
1205 listing_nopage (int ignore ATTRIBUTE_UNUSED)
1207 paper_height = 0;
1210 void
1211 listing_title (int depth)
1213 int quoted;
1214 char *start;
1215 char *ttl;
1216 unsigned int length;
1218 SKIP_WHITESPACE ();
1219 if (*input_line_pointer != '\"')
1220 quoted = 0;
1221 else
1223 quoted = 1;
1224 ++input_line_pointer;
1227 start = input_line_pointer;
1229 while (*input_line_pointer)
1231 if (quoted
1232 ? *input_line_pointer == '\"'
1233 : is_end_of_line[(unsigned char) *input_line_pointer])
1235 if (listing)
1237 length = input_line_pointer - start;
1238 ttl = xmalloc (length + 1);
1239 memcpy (ttl, start, length);
1240 ttl[length] = 0;
1241 listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
1242 listing_tail->edict_arg = ttl;
1244 if (quoted)
1245 input_line_pointer++;
1246 demand_empty_rest_of_line ();
1247 return;
1249 else if (*input_line_pointer == '\n')
1251 as_bad (_("new line in title"));
1252 demand_empty_rest_of_line ();
1253 return;
1255 else
1257 input_line_pointer++;
1262 void
1263 listing_source_line (unsigned int line)
1265 if (listing)
1267 new_frag ();
1268 listing_tail->hll_line = line;
1269 new_frag ();
1273 void
1274 listing_source_file (const char *file)
1276 if (listing)
1277 listing_tail->hll_file = file_info (file);
1280 #else
1282 /* Dummy functions for when compiled without listing enabled. */
1284 void
1285 listing_flags (int ignore)
1287 s_ignore (0);
1290 void
1291 listing_list (int on)
1293 s_ignore (0);
1296 void
1297 listing_eject (int ignore)
1299 s_ignore (0);
1302 void
1303 listing_psize (int ignore)
1305 s_ignore (0);
1308 void
1309 listing_nopage (int ignore)
1311 s_ignore (0);
1314 void
1315 listing_title (int depth)
1317 s_ignore (0);
1320 void
1321 listing_file (const char *name)
1325 void
1326 listing_newline (char *name)
1330 void
1331 listing_source_line (unsigned int n)
1335 void
1336 listing_source_file (const char *n)
1340 #endif