1 /* listing.c - mainting assembly listings
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999
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
27 A listing page looks like:
29 LISTING_HEADER sourcefilename pagenumber
32 linenumber address data source
33 linenumber address data source
34 linenumber address data source
35 linenumber address data source
37 If not overridden, the listing commands are:
40 Put "stuff" onto the title line
42 Put stuff onto the subtitle line
44 If these commands come within 10 lines of the top of the page, they
45 will affect the page they are on, as well as any subsequent page
50 Increment the enable listing counter
52 Decrement the enable listing counter
55 Set the paper size to X wide and Y high. Setting a psize Y of
56 zero will suppress form feeds except where demanded by .eject
58 If the counter goes below zero, listing is suppressed.
61 Listings are a maintained by read calling various listing_<foo>
62 functions. What happens most is that the macro NO_LISTING is not
63 defined (from the Makefile), then the macro LISTING_NEWLINE expands
64 into a call to listing_newline. The call is done from read.c, every
65 time it sees a newline, and -l is on the command line.
67 The function listing_newline remembers the frag associated with the
68 newline, and creates a new frag - note that this is wasteful, but not
69 a big deal, since listing slows things down a lot anyway. The
70 function also rememebers when the filename changes.
72 When all the input has finished, and gas has had a chance to settle
73 down, the listing is output. This is done by running down the list of
74 frag/source file records, and opening the files as needed and printing
75 out the bytes and chars associated with them.
77 The only things which the architecture can change about the listing
78 are defined in these macros:
80 LISTING_HEADER The name of the architecture
81 LISTING_WORD_SIZE The make of the number of bytes in a word, this determines
82 the clumping of the output data. eg a value of
83 2 makes words look like 1234 5678, whilst 1
84 would make the same value look like 12 34 56
86 LISTING_LHS_WIDTH Number of words of above size for the lhs
88 LISTING_LHS_WIDTH_SECOND Number of words for the data on the lhs
91 LISTING_LHS_CONT_LINES Max number of lines to use up for a continutation
92 LISTING_RHS_WIDTH Number of chars from the input file to print
100 #include "input-file.h"
105 #ifndef LISTING_HEADER
106 #define LISTING_HEADER "GAS LISTING"
108 #ifndef LISTING_WORD_SIZE
109 #define LISTING_WORD_SIZE 4
111 #ifndef LISTING_LHS_WIDTH
112 #define LISTING_LHS_WIDTH 1
114 #ifndef LISTING_LHS_WIDTH_SECOND
115 #define LISTING_LHS_WIDTH_SECOND 1
117 #ifndef LISTING_RHS_WIDTH
118 #define LISTING_RHS_WIDTH 100
120 #ifndef LISTING_LHS_CONT_LINES
121 #define LISTING_LHS_CONT_LINES 4
124 /* This structure remembers which .s were used */
125 typedef struct file_info_struct
127 struct file_info_struct
* next
;
130 unsigned int linenum
;
135 /* This structure rememebrs which line from which file goes into which
137 struct list_info_struct
139 /* Frag which this line of source is nearest to */
142 /* The actual line in the source file */
144 /* Pointer to the file info struct for the file which this line
146 file_info_type
* file
;
148 /* The expanded text of any macro that may have been executing. */
149 char * line_contents
;
152 struct list_info_struct
* next
;
154 /* Pointer to the file info struct for the high level language
155 source line that belongs here */
156 file_info_type
* hll_file
;
157 /* High level language source line */
158 unsigned int hll_line
;
160 /* Pointer to any error message associated with this line */
175 /* Nonzero if this line is to be omitted because it contains
176 debugging information. This can become a flags field if we come
177 up with more information to store here. */
181 typedef struct list_info_struct list_info_type
;
184 int listing_lhs_width
= LISTING_LHS_WIDTH
;
185 int listing_lhs_width_second
= LISTING_LHS_WIDTH_SECOND
;
186 int listing_lhs_cont_lines
= LISTING_LHS_CONT_LINES
;
187 int listing_rhs_width
= LISTING_RHS_WIDTH
;
189 struct list_info_struct
* listing_tail
;
191 static file_info_type
* file_info_head
;
192 static file_info_type
* last_open_file_info
;
193 static FILE * last_open_file
;
194 static struct list_info_struct
* head
;
195 static int paper_width
= 200;
196 static int paper_height
= 60;
200 /* File to output listings to. */
201 static FILE * list_file
;
203 /* This static array is used to keep the text of data to be printed
204 before the start of the line. */
207 (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width \
208 + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second) \
209 * listing_lhs_cont_lines) \
212 static char * data_buffer
;
215 static void listing_message
PARAMS ((const char *name
, const char *message
));
216 static file_info_type
* file_info
PARAMS ((const char *file_name
));
217 static void new_frag
PARAMS ((void));
218 static char * buffer_line
PARAMS ((file_info_type
*file
,
219 char *line
, unsigned int size
));
220 static void listing_page
PARAMS ((list_info_type
*list
));
221 static unsigned int calc_hex
PARAMS ((list_info_type
*list
));
222 static void print_lines
PARAMS ((list_info_type
*, unsigned int,
223 char *, unsigned int));
224 static void list_symbol_table
PARAMS ((void));
225 static void print_source
PARAMS ((file_info_type
*current_file
,
226 list_info_type
*list
,
228 unsigned int width
));
229 static int debugging_pseudo
PARAMS ((list_info_type
*, const char *));
230 static void listing_listing
PARAMS ((char *name
));
234 listing_message (name
, message
)
238 unsigned int l
= strlen (name
) + strlen (message
) + 1;
239 char *n
= (char *) xmalloc (l
);
242 if (listing_tail
!= (list_info_type
*) NULL
)
244 listing_tail
->message
= n
;
249 listing_warning (message
)
252 listing_message (_("Warning:"), message
);
256 listing_error (message
)
259 listing_message (_("Error:"), message
);
262 static file_info_type
*
263 file_info (file_name
)
264 const char *file_name
;
266 /* Find an entry with this file name */
267 file_info_type
*p
= file_info_head
;
269 while (p
!= (file_info_type
*) NULL
)
271 if (strcmp (p
->filename
, file_name
) == 0)
278 p
= (file_info_type
*) xmalloc (sizeof (file_info_type
));
279 p
->next
= file_info_head
;
281 p
->filename
= xmalloc ((unsigned long) strlen (file_name
) + 1);
282 strcpy (p
->filename
, file_name
);
295 frag_wane (frag_now
);
306 static unsigned int last_line
= 0xffff;
307 static char *last_file
= NULL
;
308 list_info_type
*new = NULL
;
313 if (now_seg
== absolute_section
)
317 /* In ELF, anything in a section beginning with .debug or .line is
318 considered to be debugging information. This includes the
319 statement which switches us into the debugging section, which we
320 can only set after we are already in the debugging section. */
321 if ((listing
& LISTING_NODEBUG
) != 0
322 && listing_tail
!= NULL
323 && ! listing_tail
->debugging
)
327 segname
= segment_name (now_seg
);
328 if (strncmp (segname
, ".debug", sizeof ".debug" - 1) == 0
329 || strncmp (segname
, ".line", sizeof ".line" - 1) == 0)
330 listing_tail
->debugging
= 1;
334 as_where (&file
, &line
);
337 if (line
== last_line
&& !(last_file
&& file
&& strcmp (file
, last_file
)))
340 new = (list_info_type
*) xmalloc (sizeof (list_info_type
));
342 /* Detect if we are reading from stdin by examining the file
343 name returned by as_where().
345 [FIXME: We rely upon the name in the strcmp below being the
346 same as the one used by input_scrub_new_file(), if that is
347 not true, then this code will fail].
349 If we are reading from stdin, then we need to save each input line
350 here (assuming of course that we actually have a line of input to read),
351 so that it can be displayed in the listing that is produced at the end
353 if (strcmp (file
, _("{standard input}")) == 0
354 && input_line_pointer
!= NULL
)
360 for (copy
= input_line_pointer
- 1;
361 * copy
&& (seen_quote
362 || (! is_end_of_line
[(unsigned char) * copy
]));
364 if (* copy
== '"' && copy
[-1] != '\\')
365 seen_quote
= ! seen_quote
;
367 len
= (copy
- input_line_pointer
) + 2;
369 copy
= xmalloc (len
);
373 char * src
= input_line_pointer
- 1;
378 unsigned char c
= * src
++;
380 /* Omit control characters in the listing. */
381 if (isascii (c
) && ! iscntrl (c
))
388 new->line_contents
= copy
;
391 new->line_contents
= NULL
;
395 new = (list_info_type
*) xmalloc (sizeof (list_info_type
));
396 new->line_contents
= ps
;
405 listing_tail
->next
= new;
411 new->frag
= frag_now
;
413 new->file
= file_info (file
);
414 new->next
= (list_info_type
*) NULL
;
415 new->message
= (char *) NULL
;
416 new->edict
= EDICT_NONE
;
417 new->hll_file
= (file_info_type
*) NULL
;
424 /* In ELF, anything in a section beginning with .debug or .line is
425 considered to be debugging information. */
426 if ((listing
& LISTING_NODEBUG
) != 0)
430 segname
= segment_name (now_seg
);
431 if (strncmp (segname
, ".debug", sizeof ".debug" - 1) == 0
432 || strncmp (segname
, ".line", sizeof ".line" - 1) == 0)
438 /* Attach all current frags to the previous line instead of the
439 current line. This is called by the MIPS backend when it discovers
440 that it needs to add some NOP instructions; the added NOP
441 instructions should go with the instruction that has the delay, not
442 with the new instruction. */
450 if (head
== (list_info_type
*) NULL
451 || head
== listing_tail
)
456 for (l
= head
; l
->next
!= listing_tail
; l
= l
->next
)
459 for (f
= frchain_now
->frch_root
; f
!= (fragS
*) NULL
; f
= f
->fr_next
)
460 if (f
->line
== listing_tail
)
463 listing_tail
->frag
= frag_now
;
468 This function returns the next source line from the file supplied,
469 truncated to size. It appends a fake line to the end of each input
474 buffer_line (file
, line
, size
)
475 file_info_type
* file
;
479 unsigned int count
= 0;
484 /* If we couldn't open the file, return an empty line */
488 /* Check the cache and see if we last used this file. */
489 if (!last_open_file_info
|| file
!= last_open_file_info
)
493 last_open_file_info
->pos
= ftell (last_open_file
);
494 fclose (last_open_file
);
497 last_open_file_info
= file
;
498 last_open_file
= fopen (file
->filename
, "r");
499 if (last_open_file
== NULL
)
505 /* Seek to where we were last time this file was open. */
507 fseek(last_open_file
, file
->pos
, SEEK_SET
);
510 c
= fgetc (last_open_file
);
512 size
-= 1; /* leave room for null */
514 while (c
!= EOF
&& c
!= '\n')
520 c
= fgetc (last_open_file
);
536 static const char *fn
;
538 static unsigned int eject
; /* Eject pending */
539 static unsigned int page
; /* Current page number */
540 static char *title
; /* current title */
541 static char *subtitle
; /* current subtitle */
542 static unsigned int on_page
; /* number of lines printed on current page */
547 list_info_type
*list
;
549 /* Grope around, see if we can see a title or subtitle edict coming up
550 soon (we look down 10 lines of the page and see if it's there)*/
551 if ((eject
|| (on_page
>= (unsigned int) paper_height
)) && paper_height
!= 0)
555 int had_subtitle
= 0;
559 while (c
!= 0 && list
)
561 if (list
->edict
== EDICT_SBTTL
&& !had_subtitle
)
564 subtitle
= list
->edict_arg
;
566 if (list
->edict
== EDICT_TITLE
&& !had_title
)
569 title
= list
->edict_arg
;
578 fprintf (list_file
, "\f");
581 fprintf (list_file
, "%s %s \t\t\tpage %d\n", LISTING_HEADER
, fn
, page
);
582 fprintf (list_file
, "%s\n", title
);
583 fprintf (list_file
, "%s\n", subtitle
);
592 list_info_type
* list
;
594 int data_buffer_size
;
595 list_info_type
*first
= list
;
596 unsigned int address
= ~ (unsigned int) 0;
599 unsigned int octet_in_frag
;
601 /* Find first frag which says it belongs to this line */
603 while (frag
&& frag
->line
!= list
)
604 frag
= frag
->fr_next
;
608 data_buffer_size
= 0;
610 /* Dump all the frags which belong to this line */
611 while (frag_ptr
!= (fragS
*) NULL
&& frag_ptr
->line
== first
)
613 /* Print as many bytes from the fixed part as is sensible */
615 while ((offsetT
) octet_in_frag
< frag_ptr
->fr_fix
616 && data_buffer_size
< MAX_BYTES
- 3)
618 if (address
== ~ (unsigned int) 0)
620 address
= frag_ptr
->fr_address
/ OCTETS_PER_BYTE
;
623 sprintf (data_buffer
+ data_buffer_size
,
625 (frag_ptr
->fr_literal
[octet_in_frag
]) & 0xff);
626 data_buffer_size
+= 2;
630 unsigned int var_rep_max
= octet_in_frag
;
631 unsigned int var_rep_idx
= octet_in_frag
;
633 /* Print as many bytes from the variable part as is sensible */
634 while (((offsetT
) octet_in_frag
635 < (frag_ptr
->fr_fix
+ frag_ptr
->fr_var
* frag_ptr
->fr_offset
))
636 && data_buffer_size
< MAX_BYTES
- 3)
638 if (address
== ~ (unsigned int) 0)
640 address
= frag_ptr
->fr_address
/ OCTETS_PER_BYTE
;
642 sprintf (data_buffer
+ data_buffer_size
,
644 (frag_ptr
->fr_literal
[var_rep_idx
]) & 0xff);
646 data_buffer
[data_buffer_size
++] = '*';
647 data_buffer
[data_buffer_size
++] = '*';
649 data_buffer_size
+= 2;
654 if ((offsetT
) var_rep_idx
>= frag_ptr
->fr_fix
+ frag_ptr
->fr_var
)
655 var_rep_idx
= var_rep_max
;
659 frag_ptr
= frag_ptr
->fr_next
;
661 data_buffer
[data_buffer_size
] = '\0';
671 print_lines (list
, lineno
, string
, address
)
672 list_info_type
*list
;
675 unsigned int address
;
680 unsigned int octet_in_word
= 0;
681 char *src
= data_buffer
;
682 int end
= strlen(src
);
685 /* Print the stuff on the first line */
687 nchars
= (LISTING_WORD_SIZE
* 2 + 1) * listing_lhs_width
;
689 /* Print the hex for the first line */
690 if (address
== ~ (unsigned int) 0)
692 fprintf (list_file
, "% 4d ", lineno
);
693 for (idx
= 0; idx
< nchars
; idx
++)
694 fprintf (list_file
, " ");
696 fprintf (list_file
, "\t%s\n", string
? string
: "");
706 fprintf (list_file
, "% 4d ???? ", lineno
);
708 fprintf (list_file
, "% 4d %04x ", lineno
, address
);
710 /* And the data to go along with it */
713 while (src
[cur
] && idx
< nchars
)
716 #if TARGET_BYTES_BIG_ENDIAN != 0
718 fprintf (list_file
, "%c%c", src
[offset
], src
[offset
+1]);
720 offset
= (cur
& ~(LISTING_WORD_SIZE
* 2 - 1))
721 + (LISTING_WORD_SIZE
- octet_in_word
- 1) * 2;
723 fprintf (list_file
, "%c%c", src
[offset
], src
[offset
+1]);
728 if (octet_in_word
== LISTING_WORD_SIZE
)
730 fprintf (list_file
, " ");
738 for (; idx
< nchars
; idx
++)
739 fprintf (list_file
, " ");
741 fprintf (list_file
, "\t%s\n", string
? string
: "");
747 fprintf (list_file
, "**** %s\n", list
->message
);
753 lines
< (unsigned int) listing_lhs_cont_lines
757 nchars
= ((LISTING_WORD_SIZE
* 2) + 1)
758 * listing_lhs_width_second
- 1;
761 /* Print any more lines of data, but more compactly */
762 fprintf (list_file
, "% 4d ", lineno
);
764 while (src
[cur
] && idx
< nchars
)
767 #if TARGET_BYTES_BIG_ENDIAN != 0
769 fprintf (list_file
, "%c%c", src
[offset
], src
[offset
+1]);
771 offset
= (cur
& ~(LISTING_WORD_SIZE
* 2 - 1))
772 + (LISTING_WORD_SIZE
- octet_in_word
- 1) * 2;
774 fprintf (list_file
, "%c%c", src
[offset
], src
[offset
+1]);
780 if (octet_in_word
== LISTING_WORD_SIZE
)
782 fprintf (list_file
, " ");
788 fprintf (list_file
, "\n");
798 extern symbolS
*symbol_rootP
;
805 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
807 if (SEG_NORMAL (S_GET_SEGMENT (ptr
))
808 || S_GET_SEGMENT (ptr
) == absolute_section
)
811 /* Don't report section symbols. They are not interesting. */
812 if (symbol_section_p (ptr
))
815 if (S_GET_NAME (ptr
))
817 char buf
[30], fmt
[8];
818 valueT val
= S_GET_VALUE (ptr
);
820 /* @@ Note that this is dependent on the compilation options,
821 not solely on the target characteristics. */
822 if (sizeof (val
) == 4 && sizeof (int) == 4)
823 sprintf (buf
, "%08lx", (unsigned long) val
);
824 else if (sizeof (val
) <= sizeof (unsigned long))
826 sprintf (fmt
, "%%0%lulx",
827 (unsigned long) (sizeof (val
) * 2));
828 sprintf (buf
, fmt
, (unsigned long) val
);
831 else if (sizeof (val
) > 4)
832 sprintf_vma (buf
, val
);
839 fprintf (list_file
, "DEFINED SYMBOLS\n");
844 if (symbol_get_frag (ptr
) && symbol_get_frag (ptr
)->line
)
846 fprintf (list_file
, "%20s:%-5d %s:%s %s\n",
847 symbol_get_frag (ptr
)->line
->file
->filename
,
848 symbol_get_frag (ptr
)->line
->line
,
849 segment_name (S_GET_SEGMENT (ptr
)),
850 buf
, S_GET_NAME (ptr
));
854 fprintf (list_file
, "%33s:%s %s\n",
855 segment_name (S_GET_SEGMENT (ptr
)),
856 buf
, S_GET_NAME (ptr
));
867 fprintf (list_file
, "NO DEFINED SYMBOLS\n");
870 fprintf (list_file
, "\n");
876 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
878 if (S_GET_NAME (ptr
) && strlen (S_GET_NAME (ptr
)) != 0)
880 if (S_GET_SEGMENT (ptr
) == undefined_section
)
885 fprintf (list_file
, "UNDEFINED SYMBOLS\n");
889 fprintf (list_file
, "%s\n", S_GET_NAME (ptr
));
897 fprintf (list_file
, "NO UNDEFINED SYMBOLS\n");
904 print_source (current_file
, list
, buffer
, width
)
905 file_info_type
*current_file
;
906 list_info_type
*list
;
910 if (!current_file
->at_end
)
912 while (current_file
->linenum
< list
->hll_line
913 && !current_file
->at_end
)
915 char *p
= buffer_line (current_file
, buffer
, width
);
916 fprintf (list_file
, "%4u:%-13s **** %s\n", current_file
->linenum
,
917 current_file
->filename
, p
);
924 /* Sometimes the user doesn't want to be bothered by the debugging
925 records inserted by the compiler, see if the line is suspicious. */
928 debugging_pseudo (list
, line
)
929 list_info_type
*list
;
941 was_debug
= in_debug
;
944 while (isspace ((unsigned char) *line
))
950 /* The ELF compiler sometimes emits blank lines after switching
951 out of a debugging section. If the next line drops us back
952 into debugging information, then don't print the blank line.
953 This is a hack for a particular compiler behaviour, not a
957 && list
->next
!= NULL
958 && list
->next
->debugging
)
970 if (strncmp (line
, "def", 3) == 0)
972 if (strncmp (line
, "val", 3) == 0)
974 if (strncmp (line
, "scl", 3) == 0)
976 if (strncmp (line
, "line", 4) == 0)
978 if (strncmp (line
, "endef", 5) == 0)
980 if (strncmp (line
, "ln", 2) == 0)
982 if (strncmp (line
, "type", 4) == 0)
984 if (strncmp (line
, "size", 4) == 0)
986 if (strncmp (line
, "dim", 3) == 0)
988 if (strncmp (line
, "tag", 3) == 0)
991 if (strncmp (line
, "stabs", 5) == 0)
993 if (strncmp (line
, "stabn", 5) == 0)
1000 listing_listing (name
)
1001 char *name ATTRIBUTE_UNUSED
;
1003 list_info_type
*list
= head
;
1004 file_info_type
*current_hll_file
= (file_info_type
*) NULL
;
1008 int show_listing
= 1;
1011 buffer
= xmalloc (listing_rhs_width
);
1012 data_buffer
= xmalloc (MAX_BYTES
);
1016 while (list
!= (list_info_type
*) NULL
&& 0)
1019 list
->frag
= list
->next
->frag
;
1029 unsigned int list_line
;
1031 width
= listing_rhs_width
> paper_width
? paper_width
:
1034 list_line
= list
->line
;
1035 switch (list
->edict
)
1038 /* Skip all lines up to the current. */
1044 case EDICT_NOLIST_NEXT
:
1051 title
= list
->edict_arg
;
1054 subtitle
= list
->edict_arg
;
1060 if (show_listing
<= 0)
1062 while (list
->file
->linenum
< list_line
1063 && !list
->file
->at_end
)
1064 p
= buffer_line (list
->file
, buffer
, width
);
1067 if (list
->edict
== EDICT_LIST
)
1069 /* Enable listing for the single line that caused the enable. */
1074 if (show_listing
> 0)
1076 /* Scan down the list and print all the stuff which can be done
1077 with this line (or lines). */
1082 current_hll_file
= list
->hll_file
;
1085 if (current_hll_file
&& list
->hll_line
&& (listing
& LISTING_HLL
))
1087 print_source (current_hll_file
, list
, buffer
, width
);
1090 if (list
->line_contents
)
1092 if (!((listing
& LISTING_NODEBUG
)
1093 && debugging_pseudo (list
, list
->line_contents
)))
1096 list
->file
->linenum
== 0 ? list
->line
: list
->file
->linenum
,
1097 list
->line_contents
, calc_hex (list
));
1099 free (list
->line_contents
);
1100 list
->line_contents
= NULL
;
1104 while (list
->file
->linenum
< list_line
1105 && !list
->file
->at_end
)
1107 unsigned int address
;
1109 p
= buffer_line (list
->file
, buffer
, width
);
1111 if (list
->file
->linenum
< list_line
)
1112 address
= ~ (unsigned int) 0;
1114 address
= calc_hex (list
);
1116 if (!((listing
& LISTING_NODEBUG
)
1117 && debugging_pseudo (list
, p
)))
1118 print_lines (list
, list
->file
->linenum
, p
, address
);
1122 if (list
->edict
== EDICT_EJECT
)
1128 if (list
->edict
== EDICT_NOLIST_NEXT
)
1140 listing_print (name
)
1155 list_file
= fopen (name
, "w");
1156 if (list_file
!= NULL
)
1160 as_perror (_("can't open list file: %s"), name
);
1166 if (listing
& LISTING_NOFORM
)
1171 if (listing
& LISTING_LISTING
)
1173 listing_listing (name
);
1176 if (listing
& LISTING_SYMBOLS
)
1178 list_symbol_table ();
1183 if (fclose (list_file
) == EOF
)
1184 as_perror (_("error closing list file: %s"), name
);
1189 fclose (last_open_file
);
1202 listing_eject (ignore
)
1203 int ignore ATTRIBUTE_UNUSED
;
1206 listing_tail
->edict
= EDICT_EJECT
;
1210 listing_flags (ignore
)
1211 int ignore ATTRIBUTE_UNUSED
;
1213 while ((*input_line_pointer
++) && (*input_line_pointer
!= '\n'))
1214 input_line_pointer
++;
1218 /* Turn listing on or off. An argument of 0 means to turn off
1219 listing. An argument of 1 means to turn on listing. An argument
1220 of 2 means to turn off listing, but as of the next line; that is,
1221 the current line should be listed, but the next line should not. */
1232 if (listing_tail
->edict
== EDICT_LIST
)
1233 listing_tail
->edict
= EDICT_NONE
;
1235 listing_tail
->edict
= EDICT_NOLIST
;
1238 if (listing_tail
->edict
== EDICT_NOLIST
1239 || listing_tail
->edict
== EDICT_NOLIST_NEXT
)
1240 listing_tail
->edict
= EDICT_NONE
;
1242 listing_tail
->edict
= EDICT_LIST
;
1245 listing_tail
->edict
= EDICT_NOLIST_NEXT
;
1255 listing_psize (width_only
)
1260 paper_height
= get_absolute_expression ();
1262 if (paper_height
< 0 || paper_height
> 1000)
1265 as_warn (_("strange paper height, set to no form"));
1268 if (*input_line_pointer
!= ',')
1270 demand_empty_rest_of_line ();
1274 ++input_line_pointer
;
1277 paper_width
= get_absolute_expression ();
1279 demand_empty_rest_of_line ();
1283 listing_nopage (ignore
)
1284 int ignore ATTRIBUTE_UNUSED
;
1290 listing_title (depth
)
1296 unsigned int length
;
1299 if (*input_line_pointer
!= '\"')
1304 ++input_line_pointer
;
1307 start
= input_line_pointer
;
1309 while (*input_line_pointer
)
1312 ? *input_line_pointer
== '\"'
1313 : is_end_of_line
[(unsigned char) *input_line_pointer
])
1317 length
= input_line_pointer
- start
;
1318 ttl
= xmalloc (length
+ 1);
1319 memcpy (ttl
, start
, length
);
1321 listing_tail
->edict
= depth
? EDICT_SBTTL
: EDICT_TITLE
;
1322 listing_tail
->edict_arg
= ttl
;
1325 input_line_pointer
++;
1326 demand_empty_rest_of_line ();
1329 else if (*input_line_pointer
== '\n')
1331 as_bad (_("New line in title"));
1332 demand_empty_rest_of_line ();
1337 input_line_pointer
++;
1345 listing_source_line (line
)
1351 listing_tail
->hll_line
= line
;
1357 listing_source_file (file
)
1361 listing_tail
->hll_file
= file_info (file
);
1369 /* Dummy functions for when compiled without listing enabled */
1372 listing_flags (ignore
)
1386 listing_eject (ignore
)
1393 listing_psize (ignore
)
1400 listing_nopage (ignore
)
1407 listing_title (depth
)
1421 listing_newline (name
)
1428 listing_source_line (n
)
1434 listing_source_file (n
)