1 /* listing.c - mainting assembly listings
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 Contributed by Steve Chamberlain <sac@cygnus.com>
25 A listing page looks like:
27 LISTING_HEADER sourcefilename pagenumber
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:
38 Put "stuff" onto the title line
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
48 Increment the enable listing counter
50 Decrement the enable listing counter
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 rememebers 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
88 LISTING_LHS_CONT_LINES Max number of lines to use up for a continutation
89 LISTING_RHS_WIDTH Number of chars from the input file to print
97 #include "input-file.h"
102 #ifndef LISTING_HEADER
103 #define LISTING_HEADER "GAS LISTING"
105 #ifndef LISTING_WORD_SIZE
106 #define LISTING_WORD_SIZE 4
108 #ifndef LISTING_LHS_WIDTH
109 #define LISTING_LHS_WIDTH ((LISTING_WORD_SIZE) > 4 ? 1 : 4 / (LISTING_WORD_SIZE))
111 #ifndef LISTING_LHS_WIDTH_SECOND
112 #define LISTING_LHS_WIDTH_SECOND LISTING_LHS_WIDTH
114 #ifndef LISTING_RHS_WIDTH
115 #define LISTING_RHS_WIDTH 100
117 #ifndef LISTING_LHS_CONT_LINES
118 #define LISTING_LHS_CONT_LINES 4
121 /* This structure remembers which .s were used. */
122 typedef struct file_info_struct
124 struct file_info_struct
* next
;
127 unsigned int linenum
;
132 /* This structure rememebrs which line from which file goes into which
134 struct list_info_struct
136 /* Frag which this line of source is nearest to. */
139 /* The actual line in the source file. */
141 /* Pointer to the file info struct for the file which this line
143 file_info_type
*file
;
145 /* The expanded text of any macro that may have been executing. */
149 struct list_info_struct
*next
;
151 /* Pointer to the file info struct for the high level language
152 source line that belongs here. */
153 file_info_type
*hll_file
;
154 /* High level language source line. */
155 unsigned int hll_line
;
157 /* Pointer to any error message associated with this line. */
172 /* Nonzero if this line is to be omitted because it contains
173 debugging information. This can become a flags field if we come
174 up with more information to store here. */
178 typedef struct list_info_struct list_info_type
;
180 int listing_lhs_width
= LISTING_LHS_WIDTH
;
181 int listing_lhs_width_second
= LISTING_LHS_WIDTH_SECOND
;
182 int listing_lhs_cont_lines
= LISTING_LHS_CONT_LINES
;
183 int listing_rhs_width
= LISTING_RHS_WIDTH
;
185 struct list_info_struct
* listing_tail
;
187 static file_info_type
* file_info_head
;
188 static file_info_type
* last_open_file_info
;
189 static FILE * last_open_file
;
190 static struct list_info_struct
* head
;
191 static int paper_width
= 200;
192 static int paper_height
= 60;
196 /* File to output listings to. */
197 static FILE * list_file
;
199 /* This static array is used to keep the text of data to be printed
200 before the start of the line. */
203 (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width \
204 + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second) \
205 * listing_lhs_cont_lines) \
208 static char *data_buffer
;
211 static void listing_message
PARAMS ((const char *name
, const char *message
));
212 static file_info_type
* file_info
PARAMS ((const char *file_name
));
213 static void new_frag
PARAMS ((void));
214 static char *buffer_line
PARAMS ((file_info_type
*file
,
215 char *line
, unsigned int size
));
216 static void listing_page
PARAMS ((list_info_type
*list
));
217 static unsigned int calc_hex
PARAMS ((list_info_type
*list
));
218 static void print_lines
PARAMS ((list_info_type
*, unsigned int,
219 char *, unsigned int));
220 static void list_symbol_table
PARAMS ((void));
221 static void print_source
PARAMS ((file_info_type
*current_file
,
222 list_info_type
*list
,
224 unsigned int width
));
225 static int debugging_pseudo
PARAMS ((list_info_type
*, const char *));
226 static void listing_listing
PARAMS ((char *name
));
229 listing_message (name
, message
)
233 unsigned int l
= strlen (name
) + strlen (message
) + 1;
234 char *n
= (char *) xmalloc (l
);
237 if (listing_tail
!= (list_info_type
*) NULL
)
239 listing_tail
->message
= n
;
244 listing_warning (message
)
247 listing_message (_("Warning:"), message
);
251 listing_error (message
)
254 listing_message (_("Error:"), message
);
257 static file_info_type
*
258 file_info (file_name
)
259 const char *file_name
;
261 /* Find an entry with this file name. */
262 file_info_type
*p
= file_info_head
;
264 while (p
!= (file_info_type
*) NULL
)
266 if (strcmp (p
->filename
, file_name
) == 0)
271 /* Make new entry. */
273 p
= (file_info_type
*) xmalloc (sizeof (file_info_type
));
274 p
->next
= file_info_head
;
276 p
->filename
= xmalloc ((unsigned long) strlen (file_name
) + 1);
277 strcpy (p
->filename
, file_name
);
289 frag_wane (frag_now
);
300 static unsigned int last_line
= 0xffff;
301 static char *last_file
= NULL
;
302 list_info_type
*new = NULL
;
307 if (now_seg
== absolute_section
)
311 /* In ELF, anything in a section beginning with .debug or .line is
312 considered to be debugging information. This includes the
313 statement which switches us into the debugging section, which we
314 can only set after we are already in the debugging section. */
315 if ((listing
& LISTING_NODEBUG
) != 0
316 && listing_tail
!= NULL
317 && ! listing_tail
->debugging
)
321 segname
= segment_name (now_seg
);
322 if (strncmp (segname
, ".debug", sizeof ".debug" - 1) == 0
323 || strncmp (segname
, ".line", sizeof ".line" - 1) == 0)
324 listing_tail
->debugging
= 1;
328 as_where (&file
, &line
);
331 if (line
== last_line
332 && !(last_file
&& file
&& strcmp (file
, last_file
)))
335 new = (list_info_type
*) xmalloc (sizeof (list_info_type
));
337 /* Detect if we are reading from stdin by examining the file
338 name returned by as_where().
340 [FIXME: We rely upon the name in the strcmp below being the
341 same as the one used by input_scrub_new_file(), if that is
342 not true, then this code will fail].
344 If we are reading from stdin, then we need to save each input
345 line here (assuming of course that we actually have a line of
346 input to read), so that it can be displayed in the listing
347 that is produced at the end of the assembly. */
348 if (strcmp (file
, _("{standard input}")) == 0
349 && input_line_pointer
!= NULL
)
355 for (copy
= input_line_pointer
- 1;
357 || (! is_end_of_line
[(unsigned char) *copy
]));
359 if (*copy
== '"' && copy
[-1] != '\\')
360 seen_quote
= ! seen_quote
;
362 len
= (copy
- input_line_pointer
) + 2;
364 copy
= xmalloc (len
);
368 char *src
= input_line_pointer
- 1;
373 unsigned char c
= *src
++;
375 /* Omit control characters in the listing. */
376 if (isascii (c
) && ! iscntrl (c
))
383 new->line_contents
= copy
;
386 new->line_contents
= NULL
;
390 new = (list_info_type
*) xmalloc (sizeof (list_info_type
));
391 new->line_contents
= ps
;
400 listing_tail
->next
= new;
406 new->frag
= frag_now
;
408 new->file
= file_info (file
);
409 new->next
= (list_info_type
*) NULL
;
410 new->message
= (char *) NULL
;
411 new->edict
= EDICT_NONE
;
412 new->hll_file
= (file_info_type
*) NULL
;
419 /* In ELF, anything in a section beginning with .debug or .line is
420 considered to be debugging information. */
421 if ((listing
& LISTING_NODEBUG
) != 0)
425 segname
= segment_name (now_seg
);
426 if (strncmp (segname
, ".debug", sizeof ".debug" - 1) == 0
427 || strncmp (segname
, ".line", sizeof ".line" - 1) == 0)
433 /* Attach all current frags to the previous line instead of the
434 current line. This is called by the MIPS backend when it discovers
435 that it needs to add some NOP instructions; the added NOP
436 instructions should go with the instruction that has the delay, not
437 with the new instruction. */
445 if (head
== (list_info_type
*) NULL
446 || head
== listing_tail
)
451 for (l
= head
; l
->next
!= listing_tail
; l
= l
->next
)
454 for (f
= frchain_now
->frch_root
; f
!= (fragS
*) NULL
; f
= f
->fr_next
)
455 if (f
->line
== listing_tail
)
458 listing_tail
->frag
= frag_now
;
462 /* This function returns the next source line from the file supplied,
463 truncated to size. It appends a fake line to the end of each input
467 buffer_line (file
, line
, size
)
468 file_info_type
*file
;
472 unsigned int count
= 0;
477 /* If we couldn't open the file, return an empty line. */
481 /* Check the cache and see if we last used this file. */
482 if (!last_open_file_info
|| file
!= last_open_file_info
)
486 last_open_file_info
->pos
= ftell (last_open_file
);
487 fclose (last_open_file
);
490 last_open_file_info
= file
;
491 last_open_file
= fopen (file
->filename
, "r");
492 if (last_open_file
== NULL
)
498 /* Seek to where we were last time this file was open. */
500 fseek (last_open_file
, file
->pos
, SEEK_SET
);
503 c
= fgetc (last_open_file
);
505 /* Leave room for null. */
508 while (c
!= EOF
&& c
!= '\n')
514 c
= fgetc (last_open_file
);
529 static const char *fn
;
531 static unsigned int eject
; /* Eject pending */
532 static unsigned int page
; /* Current page number */
533 static char *title
; /* Current title */
534 static char *subtitle
; /* Current subtitle */
535 static unsigned int on_page
; /* Number of lines printed on current page */
539 list_info_type
*list
;
541 /* Grope around, see if we can see a title or subtitle edict coming up
542 soon. (we look down 10 lines of the page and see if it's there) */
543 if ((eject
|| (on_page
>= (unsigned int) paper_height
))
544 && paper_height
!= 0)
548 int had_subtitle
= 0;
552 while (c
!= 0 && list
)
554 if (list
->edict
== EDICT_SBTTL
&& !had_subtitle
)
557 subtitle
= list
->edict_arg
;
559 if (list
->edict
== EDICT_TITLE
&& !had_title
)
562 title
= list
->edict_arg
;
570 fprintf (list_file
, "\f");
573 fprintf (list_file
, "%s %s \t\t\tpage %d\n", LISTING_HEADER
, fn
, page
);
574 fprintf (list_file
, "%s\n", title
);
575 fprintf (list_file
, "%s\n", subtitle
);
583 list_info_type
*list
;
585 int data_buffer_size
;
586 list_info_type
*first
= list
;
587 unsigned int address
= ~(unsigned int) 0;
590 unsigned int octet_in_frag
;
592 /* Find first frag which says it belongs to this line. */
594 while (frag
&& frag
->line
!= list
)
595 frag
= frag
->fr_next
;
599 data_buffer_size
= 0;
601 /* Dump all the frags which belong to this line. */
602 while (frag_ptr
!= (fragS
*) NULL
&& frag_ptr
->line
== first
)
604 /* Print as many bytes from the fixed part as is sensible. */
606 while ((offsetT
) octet_in_frag
< frag_ptr
->fr_fix
607 && data_buffer_size
< MAX_BYTES
- 3)
609 if (address
== ~(unsigned int) 0)
611 address
= frag_ptr
->fr_address
/ OCTETS_PER_BYTE
;
614 sprintf (data_buffer
+ data_buffer_size
,
616 (frag_ptr
->fr_literal
[octet_in_frag
]) & 0xff);
617 data_buffer_size
+= 2;
621 unsigned int var_rep_max
= octet_in_frag
;
622 unsigned int var_rep_idx
= octet_in_frag
;
624 /* Print as many bytes from the variable part as is sensible. */
625 while (((offsetT
) octet_in_frag
626 < (frag_ptr
->fr_fix
+ frag_ptr
->fr_var
* frag_ptr
->fr_offset
))
627 && data_buffer_size
< MAX_BYTES
- 3)
629 if (address
== ~(unsigned int) 0)
631 address
= frag_ptr
->fr_address
/ OCTETS_PER_BYTE
;
633 sprintf (data_buffer
+ data_buffer_size
,
635 (frag_ptr
->fr_literal
[var_rep_idx
]) & 0xff);
637 data_buffer
[data_buffer_size
++] = '*';
638 data_buffer
[data_buffer_size
++] = '*';
640 data_buffer_size
+= 2;
645 if ((offsetT
) var_rep_idx
>= frag_ptr
->fr_fix
+ frag_ptr
->fr_var
)
646 var_rep_idx
= var_rep_max
;
650 frag_ptr
= frag_ptr
->fr_next
;
652 data_buffer
[data_buffer_size
] = '\0';
657 print_lines (list
, lineno
, string
, address
)
658 list_info_type
*list
;
661 unsigned int address
;
666 unsigned int octet_in_word
= 0;
667 char *src
= data_buffer
;
670 /* Print the stuff on the first line. */
672 nchars
= (LISTING_WORD_SIZE
* 2 + 1) * listing_lhs_width
;
674 /* Print the hex for the first line. */
675 if (address
== ~(unsigned int) 0)
677 fprintf (list_file
, "% 4d ", lineno
);
678 for (idx
= 0; idx
< nchars
; idx
++)
679 fprintf (list_file
, " ");
681 fprintf (list_file
, "\t%s\n", string
? string
: "");
691 fprintf (list_file
, "% 4d ???? ", lineno
);
693 fprintf (list_file
, "% 4d %04x ", lineno
, address
);
695 /* And the data to go along with it. */
698 while (src
[cur
] && idx
< nchars
)
702 fprintf (list_file
, "%c%c", src
[offset
], src
[offset
+ 1]);
706 if (octet_in_word
== LISTING_WORD_SIZE
)
708 fprintf (list_file
, " ");
716 for (; idx
< nchars
; idx
++)
717 fprintf (list_file
, " ");
719 fprintf (list_file
, "\t%s\n", string
? string
: "");
725 fprintf (list_file
, "**** %s\n", list
->message
);
731 lines
< (unsigned int) listing_lhs_cont_lines
735 nchars
= ((LISTING_WORD_SIZE
* 2) + 1) * listing_lhs_width_second
- 1;
738 /* Print any more lines of data, but more compactly. */
739 fprintf (list_file
, "% 4d ", lineno
);
741 while (src
[cur
] && idx
< nchars
)
745 fprintf (list_file
, "%c%c", src
[offset
], src
[offset
+ 1]);
750 if (octet_in_word
== LISTING_WORD_SIZE
)
752 fprintf (list_file
, " ");
758 fprintf (list_file
, "\n");
767 extern symbolS
*symbol_rootP
;
774 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
776 if (SEG_NORMAL (S_GET_SEGMENT (ptr
))
777 || S_GET_SEGMENT (ptr
) == absolute_section
)
780 /* Don't report section symbols. They are not interesting. */
781 if (symbol_section_p (ptr
))
784 if (S_GET_NAME (ptr
))
786 char buf
[30], fmt
[8];
787 valueT val
= S_GET_VALUE (ptr
);
789 /* @@ Note that this is dependent on the compilation options,
790 not solely on the target characteristics. */
791 if (sizeof (val
) == 4 && sizeof (int) == 4)
792 sprintf (buf
, "%08lx", (unsigned long) val
);
793 else if (sizeof (val
) <= sizeof (unsigned long))
795 sprintf (fmt
, "%%0%lulx",
796 (unsigned long) (sizeof (val
) * 2));
797 sprintf (buf
, fmt
, (unsigned long) val
);
800 else if (sizeof (val
) > 4)
801 sprintf_vma (buf
, val
);
808 fprintf (list_file
, "DEFINED SYMBOLS\n");
813 if (symbol_get_frag (ptr
) && symbol_get_frag (ptr
)->line
)
815 fprintf (list_file
, "%20s:%-5d %s:%s %s\n",
816 symbol_get_frag (ptr
)->line
->file
->filename
,
817 symbol_get_frag (ptr
)->line
->line
,
818 segment_name (S_GET_SEGMENT (ptr
)),
819 buf
, S_GET_NAME (ptr
));
823 fprintf (list_file
, "%33s:%s %s\n",
824 segment_name (S_GET_SEGMENT (ptr
)),
825 buf
, S_GET_NAME (ptr
));
836 fprintf (list_file
, "NO DEFINED SYMBOLS\n");
839 fprintf (list_file
, "\n");
845 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
847 if (S_GET_NAME (ptr
) && strlen (S_GET_NAME (ptr
)) != 0)
849 if (S_GET_SEGMENT (ptr
) == undefined_section
)
854 fprintf (list_file
, "UNDEFINED SYMBOLS\n");
858 fprintf (list_file
, "%s\n", S_GET_NAME (ptr
));
866 fprintf (list_file
, "NO UNDEFINED SYMBOLS\n");
873 print_source (current_file
, list
, buffer
, width
)
874 file_info_type
*current_file
;
875 list_info_type
*list
;
879 if (!current_file
->at_end
)
881 while (current_file
->linenum
< list
->hll_line
882 && !current_file
->at_end
)
884 char *p
= buffer_line (current_file
, buffer
, width
);
885 fprintf (list_file
, "%4u:%-13s **** %s\n", current_file
->linenum
,
886 current_file
->filename
, p
);
893 /* Sometimes the user doesn't want to be bothered by the debugging
894 records inserted by the compiler, see if the line is suspicious. */
897 debugging_pseudo (list
, line
)
898 list_info_type
*list
;
910 was_debug
= in_debug
;
913 while (isspace ((unsigned char) *line
))
919 /* The ELF compiler sometimes emits blank lines after switching
920 out of a debugging section. If the next line drops us back
921 into debugging information, then don't print the blank line.
922 This is a hack for a particular compiler behaviour, not a
926 && list
->next
!= NULL
927 && list
->next
->debugging
)
939 if (strncmp (line
, "def", 3) == 0)
941 if (strncmp (line
, "val", 3) == 0)
943 if (strncmp (line
, "scl", 3) == 0)
945 if (strncmp (line
, "line", 4) == 0)
947 if (strncmp (line
, "endef", 5) == 0)
949 if (strncmp (line
, "ln", 2) == 0)
951 if (strncmp (line
, "type", 4) == 0)
953 if (strncmp (line
, "size", 4) == 0)
955 if (strncmp (line
, "dim", 3) == 0)
957 if (strncmp (line
, "tag", 3) == 0)
960 if (strncmp (line
, "stabs", 5) == 0)
962 if (strncmp (line
, "stabn", 5) == 0)
969 listing_listing (name
)
970 char *name ATTRIBUTE_UNUSED
;
972 list_info_type
*list
= head
;
973 file_info_type
*current_hll_file
= (file_info_type
*) NULL
;
977 int show_listing
= 1;
980 buffer
= xmalloc (listing_rhs_width
);
981 data_buffer
= xmalloc (MAX_BYTES
);
985 while (list
!= (list_info_type
*) NULL
&& 0)
988 list
->frag
= list
->next
->frag
;
997 unsigned int list_line
;
999 width
= listing_rhs_width
> paper_width
? paper_width
:
1002 list_line
= list
->line
;
1003 switch (list
->edict
)
1006 /* Skip all lines up to the current. */
1012 case EDICT_NOLIST_NEXT
:
1019 title
= list
->edict_arg
;
1022 subtitle
= list
->edict_arg
;
1028 if (show_listing
<= 0)
1030 while (list
->file
->linenum
< list_line
1031 && !list
->file
->at_end
)
1032 p
= buffer_line (list
->file
, buffer
, width
);
1035 if (list
->edict
== EDICT_LIST
)
1037 /* Enable listing for the single line that caused the enable. */
1042 if (show_listing
> 0)
1044 /* Scan down the list and print all the stuff which can be done
1045 with this line (or lines). */
1050 current_hll_file
= list
->hll_file
;
1053 if (current_hll_file
&& list
->hll_line
&& (listing
& LISTING_HLL
))
1055 print_source (current_hll_file
, list
, buffer
, width
);
1058 if (list
->line_contents
)
1060 if (!((listing
& LISTING_NODEBUG
)
1061 && debugging_pseudo (list
, list
->line_contents
)))
1064 list
->file
->linenum
== 0 ? list
->line
: list
->file
->linenum
,
1065 list
->line_contents
, calc_hex (list
));
1067 free (list
->line_contents
);
1068 list
->line_contents
= NULL
;
1072 while (list
->file
->linenum
< list_line
1073 && !list
->file
->at_end
)
1075 unsigned int address
;
1077 p
= buffer_line (list
->file
, buffer
, width
);
1079 if (list
->file
->linenum
< list_line
)
1080 address
= ~(unsigned int) 0;
1082 address
= calc_hex (list
);
1084 if (!((listing
& LISTING_NODEBUG
)
1085 && debugging_pseudo (list
, p
)))
1086 print_lines (list
, list
->file
->linenum
, p
, address
);
1090 if (list
->edict
== EDICT_EJECT
)
1096 if (list
->edict
== EDICT_NOLIST_NEXT
)
1108 listing_print (name
)
1123 list_file
= fopen (name
, "w");
1124 if (list_file
!= NULL
)
1128 as_perror (_("can't open list file: %s"), name
);
1134 if (listing
& LISTING_NOFORM
)
1139 if (listing
& LISTING_LISTING
)
1141 listing_listing (name
);
1144 if (listing
& LISTING_SYMBOLS
)
1146 list_symbol_table ();
1151 if (fclose (list_file
) == EOF
)
1152 as_perror (_("error closing list file: %s"), name
);
1157 fclose (last_open_file
);
1169 listing_eject (ignore
)
1170 int ignore ATTRIBUTE_UNUSED
;
1173 listing_tail
->edict
= EDICT_EJECT
;
1177 listing_flags (ignore
)
1178 int ignore ATTRIBUTE_UNUSED
;
1180 while ((*input_line_pointer
++) && (*input_line_pointer
!= '\n'))
1181 input_line_pointer
++;
1185 /* Turn listing on or off. An argument of 0 means to turn off
1186 listing. An argument of 1 means to turn on listing. An argument
1187 of 2 means to turn off listing, but as of the next line; that is,
1188 the current line should be listed, but the next line should not. */
1199 if (listing_tail
->edict
== EDICT_LIST
)
1200 listing_tail
->edict
= EDICT_NONE
;
1202 listing_tail
->edict
= EDICT_NOLIST
;
1205 if (listing_tail
->edict
== EDICT_NOLIST
1206 || listing_tail
->edict
== EDICT_NOLIST_NEXT
)
1207 listing_tail
->edict
= EDICT_NONE
;
1209 listing_tail
->edict
= EDICT_LIST
;
1212 listing_tail
->edict
= EDICT_NOLIST_NEXT
;
1221 listing_psize (width_only
)
1226 paper_height
= get_absolute_expression ();
1228 if (paper_height
< 0 || paper_height
> 1000)
1231 as_warn (_("strange paper height, set to no form"));
1234 if (*input_line_pointer
!= ',')
1236 demand_empty_rest_of_line ();
1240 ++input_line_pointer
;
1243 paper_width
= get_absolute_expression ();
1245 demand_empty_rest_of_line ();
1249 listing_nopage (ignore
)
1250 int ignore ATTRIBUTE_UNUSED
;
1256 listing_title (depth
)
1262 unsigned int length
;
1265 if (*input_line_pointer
!= '\"')
1270 ++input_line_pointer
;
1273 start
= input_line_pointer
;
1275 while (*input_line_pointer
)
1278 ? *input_line_pointer
== '\"'
1279 : is_end_of_line
[(unsigned char) *input_line_pointer
])
1283 length
= input_line_pointer
- start
;
1284 ttl
= xmalloc (length
+ 1);
1285 memcpy (ttl
, start
, length
);
1287 listing_tail
->edict
= depth
? EDICT_SBTTL
: EDICT_TITLE
;
1288 listing_tail
->edict_arg
= ttl
;
1291 input_line_pointer
++;
1292 demand_empty_rest_of_line ();
1295 else if (*input_line_pointer
== '\n')
1297 as_bad (_("New line in title"));
1298 demand_empty_rest_of_line ();
1303 input_line_pointer
++;
1309 listing_source_line (line
)
1315 listing_tail
->hll_line
= line
;
1321 listing_source_file (file
)
1325 listing_tail
->hll_file
= file_info (file
);
1330 /* Dummy functions for when compiled without listing enabled. */
1333 listing_flags (ignore
)
1347 listing_eject (ignore
)
1354 listing_psize (ignore
)
1361 listing_nopage (ignore
)
1368 listing_title (depth
)
1382 listing_newline (name
)
1389 listing_source_line (n
)
1396 listing_source_file (n
)