/* listing.c - mainting assembly listings
- Copyright (C) 1991, 1992 Free Software Foundation, Inc.
+ Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 1998
+ Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GAS; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with GAS; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
/*
Contributed by Steve Chamberlain
#include "subsegs.h"
#ifndef NO_LISTING
+
#ifndef LISTING_HEADER
#define LISTING_HEADER "GAS LISTING"
#endif
#define LISTING_LHS_CONT_LINES 4
#endif
-
-
-
/* This structure remembers which .s were used */
typedef struct file_info_struct
{
- char *filename;
- int linenum;
- FILE *file;
- struct file_info_struct *next;
- int end_pending;
-
+ struct file_info_struct * next;
+ char * filename;
+ long pos;
+ unsigned int linenum;
+ int at_end;
}
-
file_info_type;
-
-/* this structure rememebrs which line from which file goes into which
+/* This structure rememebrs which line from which file goes into which
frag */
-typedef struct list_info_struct
+struct list_info_struct
{
/* Frag which this line of source is nearest to */
- fragS *frag;
+ fragS * frag;
+
/* The actual line in the source file */
unsigned int line;
/* Pointer to the file info struct for the file which this line
belongs to */
- file_info_type *file;
+ file_info_type * file;
- /* Next in list */
- struct list_info_struct *next;
+ /* The expanded text of any macro that may have been executing. */
+ char * line_contents;
+ /* Next in list */
+ struct list_info_struct * next;
/* Pointer to the file info struct for the high level language
source line that belongs here */
- file_info_type *hll_file;
-
+ file_info_type * hll_file;
/* High level language source line */
- int hll_line;
-
+ unsigned int hll_line;
/* Pointer to any error message associated with this line */
- char *message;
+ char * message;
enum
{
EDICT_TITLE,
EDICT_NOLIST,
EDICT_LIST,
+ EDICT_NOLIST_NEXT,
EDICT_EJECT
} edict;
- char *edict_arg;
+ char * edict_arg;
-}
+ /* Nonzero if this line is to be omitted because it contains
+ debugging information. This can become a flags field if we come
+ up with more information to store here. */
+ int debugging;
+};
-list_info_type;
+typedef struct list_info_struct list_info_type;
-static struct list_info_struct *head;
-struct list_info_struct *listing_tail;
-extern int listing;
-extern fragS *frag_now;
+int listing_lhs_width = LISTING_LHS_WIDTH;
+int listing_lhs_width_second = LISTING_LHS_WIDTH_SECOND;
+int listing_lhs_cont_lines = LISTING_LHS_CONT_LINES;
+int listing_rhs_width = LISTING_RHS_WIDTH;
+struct list_info_struct * listing_tail;
-static int paper_width = 200;
-static int paper_height = 60;
+static file_info_type * file_info_head;
+static file_info_type * last_open_file_info;
+static FILE * last_open_file;
+static struct list_info_struct * head;
+static int paper_width = 200;
+static int paper_height = 60;
+extern int listing;
-/* this static array is used to keep the text of data to be printed
- before the start of the line.
- It is stored so we can give a bit more info on the next line. To much, and large
- initialized arrays will use up lots of paper.
- */
+/* File to output listings to. */
+static FILE * list_file;
-static char data_buffer[100];
-static unsigned int data_buffer_size;
+/* This static array is used to keep the text of data to be printed
+ before the start of the line. */
+#define MAX_BYTES \
+ (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width \
+ + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second) \
+ * listing_lhs_cont_lines) \
+ + 20)
+
+static char * data_buffer;
/* Prototypes. */
static void listing_message PARAMS ((const char *name, const char *message));
-static file_info_type *file_info PARAMS ((const char *file_name));
+static file_info_type * file_info PARAMS ((const char *file_name));
static void new_frag PARAMS ((void));
-static char *buffer_line PARAMS ((file_info_type *file,
+static char * buffer_line PARAMS ((file_info_type *file,
char *line, unsigned int size));
static void listing_page PARAMS ((list_info_type *list));
static unsigned int calc_hex PARAMS ((list_info_type *list));
-static void print_lines PARAMS ((list_info_type *list,
- char *string,
- unsigned int address));
+static void print_lines PARAMS ((list_info_type *, unsigned int,
+ char *, unsigned int));
static void list_symbol_table PARAMS ((void));
static void print_source PARAMS ((file_info_type *current_file,
list_info_type *list,
char *buffer,
unsigned int width));
-static int debugging_pseudo PARAMS ((char *line));
+static int debugging_pseudo PARAMS ((list_info_type *, const char *));
static void listing_listing PARAMS ((char *name));
{
listing_tail->message = n;
}
-
}
-
-
-
void
listing_warning (message)
const char *message;
{
- listing_message ("Warning:", message);
+ listing_message (_("Warning:"), message);
}
void
listing_error (message)
const char *message;
{
- listing_message ("Error:", message);
+ listing_message (_("Error:"), message);
}
-
-
-
-static file_info_type *file_info_head;
-
static file_info_type *
file_info (file_name)
const char *file_name;
file_info_head = p;
p->filename = xmalloc ((unsigned long) strlen (file_name) + 1);
strcpy (p->filename, file_name);
+ p->pos = 0;
p->linenum = 0;
- p->end_pending = 0;
-
- /* Do we really prefer binary mode for this?? */
- p->file = fopen (p->filename, FOPEN_RB);
- if (p->file)
- fgetc (p->file);
+ p->at_end = 0;
return p;
}
char *file;
unsigned int line;
static unsigned int last_line = 0xffff;
- list_info_type *new;
+ static char *last_file = NULL;
+ list_info_type *new = NULL;
+
+ if (listing == 0)
+ return;
+
+ if (now_seg == absolute_section)
+ return;
+
+#ifdef OBJ_ELF
+ /* In ELF, anything in a section beginning with .debug or .line is
+ considered to be debugging information. This includes the
+ statement which switches us into the debugging section, which we
+ can only set after we are already in the debugging section. */
+ if ((listing & LISTING_NODEBUG) != 0
+ && listing_tail != NULL
+ && ! listing_tail->debugging)
+ {
+ const char *segname;
+
+ segname = segment_name (now_seg);
+ if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
+ || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
+ listing_tail->debugging = 1;
+ }
+#endif
as_where (&file, &line);
- if (line != last_line)
+ if (ps == NULL)
{
- last_line = line;
- new_frag ();
+ if (line == last_line && !(last_file && file && strcmp (file, last_file)))
+ return;
new = (list_info_type *) xmalloc (sizeof (list_info_type));
- new->frag = frag_now;
- new->line = line;
- new->file = file_info (file);
- if (listing_tail)
+ /* Detect if we are reading from stdin by examining the file
+ name returned by as_where().
+
+ [FIXME: We rely upon the name in the strcmp below being the
+ same as the one used by input_scrub_new_file(), if that is
+ not true, then this code will fail].
+
+ If we are reading from stdin, then we need to save each input line
+ here (assuming of course that we actually have a line of input to read),
+ so that it can be displayed in the listing that is produced at the end
+ of the assembly. */
+ if (strcmp (file, _("{standard input}")) == 0
+ && input_line_pointer != NULL)
{
- listing_tail->next = new;
+ char * copy;
+ int len;
+
+ for (copy = input_line_pointer - 1;
+ * copy && ! is_end_of_line [* copy];
+ copy ++)
+ continue;
+
+ len = (copy - input_line_pointer) + 2;
+
+ copy = xmalloc (len);
+
+ if (copy != NULL)
+ {
+ char * src = input_line_pointer - 1;
+ char * dest = copy;
+
+ while (--len)
+ {
+ char c = * src ++;
+
+ /* Omit control characters in the listing. */
+ if (isascii (c) && ! iscntrl (c))
+ * dest ++ = c;
+ }
+
+ *dest = 0;
+ }
+
+ new->line_contents = copy;
}
else
- {
- head = new;
- }
- listing_tail = new;
- new->next = (list_info_type *) NULL;
- new->message = (char *) NULL;
- new->edict = EDICT_NONE;
- new->hll_file = (file_info_type *) NULL;
- new->hll_line = 0;
- new_frag ();
+ new->line_contents = NULL;
}
+ else
+ {
+ new = (list_info_type *) xmalloc (sizeof (list_info_type));
+ new->line_contents = ps;
+ }
+
+ last_line = line;
+ last_file = file;
+
+ new_frag ();
+
+ if (listing_tail)
+ listing_tail->next = new;
+ else
+ head = new;
+
+ listing_tail = new;
+
+ new->frag = frag_now;
+ new->line = line;
+ new->file = file_info (file);
+ new->next = (list_info_type *) NULL;
+ new->message = (char *) NULL;
+ new->edict = EDICT_NONE;
+ new->hll_file = (file_info_type *) NULL;
+ new->hll_line = 0;
+ new->debugging = 0;
+
+ new_frag ();
+
+#ifdef OBJ_ELF
+ /* In ELF, anything in a section beginning with .debug or .line is
+ considered to be debugging information. */
+ if ((listing & LISTING_NODEBUG) != 0)
+ {
+ const char *segname;
+
+ segname = segment_name (now_seg);
+ if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
+ || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
+ new->debugging = 1;
+ }
+#endif
}
/* Attach all current frags to the previous line instead of the
char *p = line;
/* If we couldn't open the file, return an empty line */
- if (file->file == (FILE *) NULL)
- {
- return "";
- }
-
- if (file->linenum == 0)
- rewind (file->file);
+ if (file->at_end)
+ return "";
- if (file->end_pending == 10)
+ /* Check the cache and see if we last used this file. */
+ if (!last_open_file_info || file != last_open_file_info)
{
- *p++ = '\n';
- fseek (file->file, 0, 0);
- file->linenum = 0;
- file->end_pending = 0;
+ if (last_open_file)
+ {
+ last_open_file_info->pos = ftell (last_open_file);
+ fclose (last_open_file);
+ }
+
+ last_open_file_info = file;
+ last_open_file = fopen (file->filename, "r");
+ if (last_open_file == NULL)
+ {
+ file->at_end = 1;
+ return "";
+ }
+
+ /* Seek to where we were last time this file was open. */
+ if (file->pos)
+ fseek(last_open_file, file->pos, SEEK_SET);
}
- c = fgetc (file->file);
+ c = fgetc (last_open_file);
size -= 1; /* leave room for null */
*p++ = c;
count++;
- c = fgetc (file->file);
+ c = fgetc (last_open_file);
}
if (c == EOF)
{
- file->end_pending++;
+ file->at_end = 1;
*p++ = '.';
*p++ = '.';
*p++ = '.';
{
/* Grope around, see if we can see a title or subtitle edict coming up
soon (we look down 10 lines of the page and see if it's there)*/
- if ((eject || (on_page >= paper_height)) && paper_height != 0)
+ if ((eject || (on_page >= (unsigned int) paper_height)) && paper_height != 0)
{
unsigned int c = 10;
int had_title = 0;
if (page > 1)
{
- printf ("\f");
+ fprintf (list_file, "\f");
}
- printf ("%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
- printf ("%s\n", title);
- printf ("%s\n", subtitle);
+ fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
+ fprintf (list_file, "%s\n", title);
+ fprintf (list_file, "%s\n", subtitle);
on_page = 3;
eject = 0;
}
calc_hex (list)
list_info_type * list;
{
+ int data_buffer_size;
list_info_type *first = list;
- unsigned int address = (unsigned int) ~0;
-
+ unsigned int address = ~ (unsigned int) 0;
fragS *frag;
fragS *frag_ptr;
-
unsigned int byte_in_frag;
-
/* Find first frag which says it belongs to this line */
frag = list->frag;
while (frag && frag->line != list)
{
/* Print as many bytes from the fixed part as is sensible */
byte_in_frag = 0;
- while (byte_in_frag < frag_ptr->fr_fix && data_buffer_size < sizeof (data_buffer) - 10)
+ while ((offsetT) byte_in_frag < frag_ptr->fr_fix
+ && data_buffer_size < MAX_BYTES - 3)
{
- if (address == ~0)
+ if (address == ~ (unsigned int) 0)
{
address = frag_ptr->fr_address;
}
unsigned int var_rep_idx = byte_in_frag;
/* Print as many bytes from the variable part as is sensible */
- while (byte_in_frag < frag_ptr->fr_var * frag_ptr->fr_offset
- && data_buffer_size < sizeof (data_buffer) - 10)
+ while (((offsetT) byte_in_frag
+ < frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset)
+ && data_buffer_size < MAX_BYTES - 3)
{
- if (address == ~0)
+ if (address == ~ (unsigned int) 0)
{
address = frag_ptr->fr_address;
}
var_rep_idx++;
byte_in_frag++;
- if (var_rep_idx >= frag_ptr->fr_var)
+ if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
var_rep_idx = var_rep_max;
}
}
frag_ptr = frag_ptr->fr_next;
}
- data_buffer[data_buffer_size++] = 0;
+ data_buffer[data_buffer_size] = '\0';
return address;
}
static void
-print_lines (list, string, address)
+print_lines (list, lineno, string, address)
list_info_type *list;
+ unsigned int lineno;
char *string;
unsigned int address;
{
/* Print the stuff on the first line */
listing_page (list);
- nchars = (LISTING_WORD_SIZE * 2 + 1) * LISTING_LHS_WIDTH;
+ nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width;
+
/* Print the hex for the first line */
- if (address == ~0)
+ if (address == ~ (unsigned int) 0)
{
- printf ("% 4d ", list->line);
+ fprintf (list_file, "% 4d ", lineno);
for (idx = 0; idx < nchars; idx++)
- printf (" ");
+ fprintf (list_file, " ");
- printf ("\t%s\n", string ? string : "");
- on_page++;
+ fprintf (list_file, "\t%s\n", string ? string : "");
+
+ on_page ++;
+
listing_page (0);
+ return;
}
+
+ if (had_errors ())
+ fprintf (list_file, "% 4d ???? ", lineno);
else
+ fprintf (list_file, "% 4d %04x ", lineno, address);
+
+ /* And the data to go along with it */
+ idx = 0;
+
+ while (*src && idx < nchars)
{
- if (had_errors ())
- {
- printf ("% 4d ???? ", list->line);
- }
- else
+ fprintf (list_file, "%c%c", src[0], src[1]);
+ src += 2;
+ byte_in_word++;
+
+ if (byte_in_word == LISTING_WORD_SIZE)
{
- printf ("% 4d %04x ", list->line, address);
+ fprintf (list_file, " ");
+ idx++;
+ byte_in_word = 0;
}
-
- /* And the data to go along with it */
+
+ idx += 2;
+ }
+
+ for (; idx < nchars; idx++)
+ fprintf (list_file, " ");
+
+ fprintf (list_file, "\t%s\n", string ? string : "");
+ on_page++;
+ listing_page (list);
+
+ if (list->message)
+ {
+ fprintf (list_file, "**** %s\n", list->message);
+ listing_page (list);
+ on_page++;
+ }
+
+ for (lines = 0;
+ lines < (unsigned int) listing_lhs_cont_lines
+ && *src;
+ lines ++)
+ {
+ nchars = ((LISTING_WORD_SIZE * 2) + 1)
+ * listing_lhs_width_second - 1;
idx = 0;
-
+
+ /* Print any more lines of data, but more compactly */
+ fprintf (list_file, "% 4d ", lineno);
+
while (*src && idx < nchars)
{
- printf ("%c%c", src[0], src[1]);
+ fprintf (list_file, "%c%c", src[0], src[1]);
src += 2;
+ idx += 2;
byte_in_word++;
+
if (byte_in_word == LISTING_WORD_SIZE)
{
- printf (" ");
+ fprintf (list_file, " ");
idx++;
byte_in_word = 0;
}
- idx += 2;
}
-
- for (; idx < nchars; idx++)
- printf (" ");
-
- printf ("\t%s\n", string ? string : "");
- on_page++;
+
+ fprintf (list_file, "\n");
+ on_page ++;
listing_page (list);
- if (list->message)
- {
- printf ("**** %s\n", list->message);
- listing_page (list);
- on_page++;
- }
-
- for (lines = 0;
- lines < LISTING_LHS_CONT_LINES
- && *src;
- lines++)
- {
- nchars = ((LISTING_WORD_SIZE * 2) + 1) * LISTING_LHS_WIDTH_SECOND - 1;
- idx = 0;
- /* Print any more lines of data, but more compactly */
- printf ("% 4d ", list->line);
-
- while (*src && idx < nchars)
- {
- printf ("%c%c", src[0], src[1]);
- src += 2;
- idx += 2;
- byte_in_word++;
- if (byte_in_word == LISTING_WORD_SIZE)
- {
- printf (" ");
- idx++;
- byte_in_word = 0;
- }
- }
-
- printf ("\n");
- on_page++;
- listing_page (list);
-
- }
-
-
}
}
list_symbol_table ()
{
extern symbolS *symbol_rootP;
+ int got_some = 0;
symbolS *ptr;
eject = 1;
listing_page (0);
- printf ("DEFINED SYMBOLS\n");
- on_page++;
for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
{
- if (ptr->sy_frag->line)
+ if (SEG_NORMAL (S_GET_SEGMENT (ptr))
+ || S_GET_SEGMENT (ptr) == absolute_section)
{
+#ifdef BFD_ASSEMBLER
+ /* Don't report section symbols. They are not interesting. */
+ if (ptr->bsym->flags & BSF_SECTION_SYM)
+ continue;
+#endif
if (S_GET_NAME (ptr))
{
- char buf[30];
+ char buf[30], fmt[8];
valueT val = S_GET_VALUE (ptr);
/* @@ Note that this is dependent on the compilation options,
not solely on the target characteristics. */
if (sizeof (val) == 4 && sizeof (int) == 4)
sprintf (buf, "%08lx", (unsigned long) val);
-#if defined (BFD_ASSEMBLER) && defined (BFD64)
- else if (sizeof (val) > 4)
+ else if (sizeof (val) <= sizeof (unsigned long))
{
- char buf1[30];
- sprintf_vma (buf1, val);
- strcpy (buf, "00000000");
- strcpy (buf + 8 - strlen (buf1), buf1);
+ sprintf (fmt, "%%0%lulx",
+ (unsigned long) (sizeof (val) * 2));
+ sprintf (buf, fmt, (unsigned long) val);
}
+#if defined (BFD64)
+ else if (sizeof (val) > 4)
+ sprintf_vma (buf, val);
#endif
else
abort ();
- printf ("%20s:%-5d %s:%s %s\n",
- ptr->sy_frag->line->file->filename,
- ptr->sy_frag->line->line,
- segment_name (S_GET_SEGMENT (ptr)),
- buf, S_GET_NAME (ptr));
+ if (!got_some)
+ {
+ fprintf (list_file, "DEFINED SYMBOLS\n");
+ on_page++;
+ got_some = 1;
+ }
- on_page++;
+ if (ptr->sy_frag && ptr->sy_frag->line)
+ {
+ fprintf (list_file, "%20s:%-5d %s:%s %s\n",
+ ptr->sy_frag->line->file->filename,
+ ptr->sy_frag->line->line,
+ segment_name (S_GET_SEGMENT (ptr)),
+ buf, S_GET_NAME (ptr));
+ }
+ else
+ {
+ fprintf (list_file, "%33s:%s %s\n",
+ segment_name (S_GET_SEGMENT (ptr)),
+ buf, S_GET_NAME (ptr));
+ }
+
+ on_page ++;
listing_page (0);
}
}
}
- printf ("\n");
- on_page++;
- listing_page (0);
- printf ("UNDEFINED SYMBOLS\n");
+ if (!got_some)
+ {
+ fprintf (list_file, "NO DEFINED SYMBOLS\n");
+ on_page++;
+ }
+ fprintf (list_file, "\n");
on_page++;
listing_page (0);
+ got_some = 0;
+
for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
{
if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0)
{
- if (ptr->sy_frag->line == 0
- && S_GET_SEGMENT (ptr) != reg_section)
+ if (S_GET_SEGMENT (ptr) == undefined_section)
{
- printf ("%s\n", S_GET_NAME (ptr));
+ if (!got_some)
+ {
+ got_some = 1;
+ fprintf (list_file, "UNDEFINED SYMBOLS\n");
+ on_page++;
+ listing_page (0);
+ }
+ fprintf (list_file, "%s\n", S_GET_NAME (ptr));
on_page++;
listing_page (0);
}
}
}
+ if (!got_some)
+ {
+ fprintf (list_file, "NO UNDEFINED SYMBOLS\n");
+ on_page++;
+ listing_page (0);
+ }
}
static void
char *buffer;
unsigned int width;
{
- if (current_file->file)
+ if (!current_file->at_end)
{
- while (current_file->linenum < list->hll_line)
+ while (current_file->linenum < list->hll_line
+ && !current_file->at_end)
{
char *p = buffer_line (current_file, buffer, width);
- printf ("%4d:%-13s **** %s\n", current_file->linenum, current_file->filename, p);
+ fprintf (list_file, "%4u:%-13s **** %s\n", current_file->linenum,
+ current_file->filename, p);
on_page++;
listing_page (list);
}
}
/* Sometimes the user doesn't want to be bothered by the debugging
- records inserted by the compiler, see if the line is suspicious */
+ records inserted by the compiler, see if the line is suspicious. */
static int
-debugging_pseudo (line)
- char *line;
+debugging_pseudo (list, line)
+ list_info_type *list;
+ const char *line;
{
- while (isspace (*line))
+ static int in_debug;
+ int was_debug;
+
+ if (list->debugging)
+ {
+ in_debug = 1;
+ return 1;
+ }
+
+ was_debug = in_debug;
+ in_debug = 0;
+
+ while (isspace ((unsigned char) *line))
line++;
if (*line != '.')
- return 0;
+ {
+#ifdef OBJ_ELF
+ /* The ELF compiler sometimes emits blank lines after switching
+ out of a debugging section. If the next line drops us back
+ into debugging information, then don't print the blank line.
+ This is a hack for a particular compiler behaviour, not a
+ general case. */
+ if (was_debug
+ && *line == '\0'
+ && list->next != NULL
+ && list->next->debugging)
+ {
+ in_debug = 1;
+ return 1;
+ }
+#endif
+
+ return 0;
+ }
line++;
return 1;
return 0;
-
}
static void
int show_listing = 1;
unsigned int width;
- buffer = xmalloc (LISTING_RHS_WIDTH);
+ buffer = xmalloc (listing_rhs_width);
+ data_buffer = xmalloc (MAX_BYTES);
eject = 1;
list = head;
while (list)
{
- width = LISTING_RHS_WIDTH > paper_width ? paper_width :
- LISTING_RHS_WIDTH;
+ int list_line;
+ width = listing_rhs_width > paper_width ? paper_width :
+ listing_rhs_width;
+
+ list_line = list->line;
switch (list->edict)
{
case EDICT_LIST:
- show_listing++;
+ /* Skip all lines up to the current. */
+ list_line--;
break;
case EDICT_NOLIST:
show_listing--;
break;
+ case EDICT_NOLIST_NEXT:
+ break;
case EDICT_EJECT:
break;
case EDICT_NONE:
abort ();
}
+ if (show_listing <= 0)
+ {
+ while (list->file->linenum < list_line
+ && !list->file->at_end)
+ p = buffer_line (list->file, buffer, width);
+ }
+
+ if (list->edict == EDICT_LIST)
+ {
+ /* Enable listing for the single line that caused the enable. */
+ list_line++;
+ show_listing++;
+ }
+
if (show_listing > 0)
{
/* Scan down the list and print all the stuff which can be done
current_hll_file = list->hll_file;
}
- if (current_hll_file && list->hll_line && listing & LISTING_HLL)
+ if (current_hll_file && list->hll_line && (listing & LISTING_HLL))
{
print_source (current_hll_file, list, buffer, width);
}
- p = buffer_line (list->file, buffer, width);
-
- if (!((listing & LISTING_NODEBUG) && debugging_pseudo (p)))
+ if (list->line_contents)
+ {
+ if (!((listing & LISTING_NODEBUG)
+ && debugging_pseudo (list, list->line_contents)))
+ {
+ print_lines (list,
+ list->file->linenum == 0 ? list->line : list->file->linenum,
+ list->line_contents, calc_hex (list));
+ }
+ free (list->line_contents);
+ list->line_contents = NULL;
+ }
+ else
{
- print_lines (list, p, calc_hex (list));
+ while (list->file->linenum < list_line
+ && !list->file->at_end)
+ {
+ unsigned int address;
+
+ p = buffer_line (list->file, buffer, width);
+
+ if (list->file->linenum < list_line)
+ address = ~ (unsigned int) 0;
+ else
+ address = calc_hex (list);
+
+ if (!((listing & LISTING_NODEBUG)
+ && debugging_pseudo (list, p)))
+ print_lines (list, list->file->linenum, p, address);
+ }
}
if (list->edict == EDICT_EJECT)
eject = 1;
}
}
- else
- {
- p = buffer_line (list->file, buffer, width);
- }
+ if (list->edict == EDICT_NOLIST_NEXT)
+ --show_listing;
list = list->next;
}
+
free (buffer);
+ free (data_buffer);
+ data_buffer = NULL;
}
void
listing_print (name)
char *name;
{
+ int using_stdout;
+
title = "";
subtitle = "";
+ if (name == NULL)
+ {
+ list_file = stdout;
+ using_stdout = 1;
+ }
+ else
+ {
+ list_file = fopen (name, "w");
+ if (list_file != NULL)
+ using_stdout = 0;
+ else
+ {
+ as_perror (_("can't open list file: %s"), name);
+ list_file = stdout;
+ using_stdout = 1;
+ }
+ }
+
if (listing & LISTING_NOFORM)
{
paper_height = 0;
if (listing & LISTING_LISTING)
{
listing_listing (name);
-
}
+
if (listing & LISTING_SYMBOLS)
{
list_symbol_table ();
}
+
+ if (! using_stdout)
+ {
+ if (fclose (list_file) == EOF)
+ as_perror (_("error closing list file: %s"), name);
+ }
+
+ if (last_open_file)
+ {
+ fclose (last_open_file);
+ }
}
listing_eject (ignore)
int ignore;
{
- listing_tail->edict = EDICT_EJECT;
+ if (listing)
+ listing_tail->edict = EDICT_EJECT;
}
void
}
+/* Turn listing on or off. An argument of 0 means to turn off
+ listing. An argument of 1 means to turn on listing. An argument
+ of 2 means to turn off listing, but as of the next line; that is,
+ the current line should be listed, but the next line should not. */
+
void
listing_list (on)
int on;
{
- listing_tail->edict = on ? EDICT_LIST : EDICT_NOLIST;
+ if (listing)
+ {
+ switch (on)
+ {
+ case 0:
+ if (listing_tail->edict == EDICT_LIST)
+ listing_tail->edict = EDICT_NONE;
+ else
+ listing_tail->edict = EDICT_NOLIST;
+ break;
+ case 1:
+ if (listing_tail->edict == EDICT_NOLIST
+ || listing_tail->edict == EDICT_NOLIST_NEXT)
+ listing_tail->edict = EDICT_NONE;
+ else
+ listing_tail->edict = EDICT_LIST;
+ break;
+ case 2:
+ listing_tail->edict = EDICT_NOLIST_NEXT;
+ break;
+ default:
+ abort ();
+ }
+ }
}
void
-listing_psize (ignore)
- int ignore;
+listing_psize (width_only)
+ int width_only;
{
- paper_height = get_absolute_expression ();
-
- if (paper_height < 0 || paper_height > 1000)
- {
- paper_height = 0;
- as_warn ("strange paper height, set to no form");
- }
- if (*input_line_pointer == ',')
+ if (! width_only)
{
- input_line_pointer++;
- paper_width = get_absolute_expression ();
+ paper_height = get_absolute_expression ();
+
+ if (paper_height < 0 || paper_height > 1000)
+ {
+ paper_height = 0;
+ as_warn (_("strange paper height, set to no form"));
+ }
+
+ if (*input_line_pointer != ',')
+ {
+ demand_empty_rest_of_line ();
+ return;
+ }
+
+ ++input_line_pointer;
}
+
+ paper_width = get_absolute_expression ();
+
+ demand_empty_rest_of_line ();
}
+void
+listing_nopage (ignore)
+ int ignore;
+{
+ paper_height = 0;
+}
void
listing_title (depth)
int depth;
{
+ int quoted;
char *start;
char *ttl;
unsigned int length;
SKIP_WHITESPACE ();
- if (*input_line_pointer == '\"')
+ if (*input_line_pointer != '\"')
+ quoted = 0;
+ else
{
- input_line_pointer++;
- start = input_line_pointer;
+ quoted = 1;
+ ++input_line_pointer;
+ }
+
+ start = input_line_pointer;
- while (*input_line_pointer)
+ while (*input_line_pointer)
+ {
+ if (quoted
+ ? *input_line_pointer == '\"'
+ : is_end_of_line[(unsigned char) *input_line_pointer])
{
- if (*input_line_pointer == '\"')
+ if (listing)
{
length = input_line_pointer - start;
ttl = xmalloc (length + 1);
ttl[length] = 0;
listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
listing_tail->edict_arg = ttl;
- input_line_pointer++;
- demand_empty_rest_of_line ();
- return;
- }
- else if (*input_line_pointer == '\n')
- {
- as_bad ("New line in title");
- demand_empty_rest_of_line ();
- return;
- }
- else
- {
- input_line_pointer++;
}
+ if (quoted)
+ input_line_pointer++;
+ demand_empty_rest_of_line ();
+ return;
+ }
+ else if (*input_line_pointer == '\n')
+ {
+ as_bad (_("New line in title"));
+ demand_empty_rest_of_line ();
+ return;
+ }
+ else
+ {
+ input_line_pointer++;
}
- }
- else
- {
- as_bad ("expecting title in quotes");
}
}
listing_source_line (line)
unsigned int line;
{
- new_frag ();
- listing_tail->hll_line = line;
- new_frag ();
-
+ if (listing)
+ {
+ new_frag ();
+ listing_tail->hll_line = line;
+ new_frag ();
+ }
}
void
listing_source_file (file)
const char *file;
{
- if (listing_tail)
+ if (listing)
listing_tail->hll_file = file_info (file);
}
s_ignore (0);
}
+void
+listing_nopage (ignore)
+ int ignore;
+{
+ s_ignore (0);
+}
+
void
listing_title (depth)
int depth;