1992-01-21 23:14:16 +01:00
|
|
|
/* listing.c - mainting assembly listings
|
|
|
|
Copyright (C) 1991, 1992 Free Software Foundation, Inc.
|
1992-02-13 09:33:54 +01:00
|
|
|
|
|
|
|
This file is part of GAS, the GNU Assembler.
|
|
|
|
|
|
|
|
GAS is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
any later version.
|
|
|
|
|
|
|
|
GAS is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
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. */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
/*
|
1992-02-13 09:33:54 +01:00
|
|
|
Contributed by Steve Chamberlain
|
|
|
|
sac@cygnus.com
|
|
|
|
|
|
|
|
|
|
|
|
A listing page looks like:
|
|
|
|
|
|
|
|
LISTING_HEADER sourcefilename pagenumber
|
|
|
|
TITLE LINE
|
|
|
|
SUBTITLE LINE
|
|
|
|
linenumber address data source
|
|
|
|
linenumber address data source
|
|
|
|
linenumber address data source
|
|
|
|
linenumber address data source
|
|
|
|
|
|
|
|
If not overridden, the listing commands are:
|
|
|
|
|
|
|
|
.title "stuff"
|
|
|
|
Put "stuff" onto the title line
|
|
|
|
.sbttl "stuff"
|
|
|
|
Put stuff onto the subtitle line
|
|
|
|
|
1992-01-21 23:14:16 +01:00
|
|
|
If these commands come within 10 lines of the top of the page, they
|
|
|
|
will affect the page they are on, as well as any subsequent page
|
1992-02-13 09:33:54 +01:00
|
|
|
|
|
|
|
.eject
|
|
|
|
Thow a page
|
|
|
|
.list
|
|
|
|
Increment the enable listing counter
|
|
|
|
.nolist
|
|
|
|
Decrement the enable listing counter
|
|
|
|
|
|
|
|
.psize Y[,X]
|
|
|
|
Set the paper size to X wide and Y high. Setting a psize Y of
|
|
|
|
zero will suppress form feeds except where demanded by .eject
|
|
|
|
|
|
|
|
If the counter goes below zero, listing is suppressed.
|
|
|
|
|
|
|
|
|
|
|
|
Listings are a maintained by read calling various listing_<foo>
|
|
|
|
functions. What happens most is that the macro NO_LISTING is not
|
|
|
|
defined (from the Makefile), then the macro LISTING_NEWLINE expands
|
|
|
|
into a call to listing_newline. The call is done from read.c, every
|
|
|
|
time it sees a newline, and -l is on the command line.
|
|
|
|
|
|
|
|
The function listing_newline remembers the frag associated with the
|
|
|
|
newline, and creates a new frag - note that this is wasteful, but not
|
|
|
|
a big deal, since listing slows things down a lot anyway. The
|
|
|
|
function also rememebers when the filename changes.
|
|
|
|
|
|
|
|
When all the input has finished, and gas has had a chance to settle
|
|
|
|
down, the listing is output. This is done by running down the list of
|
|
|
|
frag/source file records, and opening the files as needed and printing
|
|
|
|
out the bytes and chars associated with them.
|
|
|
|
|
|
|
|
The only things which the architecture can change about the listing
|
|
|
|
are defined in these macros:
|
|
|
|
|
|
|
|
LISTING_HEADER The name of the architecture
|
|
|
|
LISTING_WORD_SIZE The make of the number of bytes in a word, this determines
|
|
|
|
the clumping of the output data. eg a value of
|
|
|
|
2 makes words look like 1234 5678, whilst 1
|
|
|
|
would make the same value look like 12 34 56
|
|
|
|
78
|
|
|
|
LISTING_LHS_WIDTH Number of words of above size for the lhs
|
|
|
|
|
|
|
|
LISTING_LHS_WIDTH_SECOND Number of words for the data on the lhs
|
|
|
|
for the second line
|
|
|
|
|
|
|
|
LISTING_LHS_CONT_LINES Max number of lines to use up for a continutation
|
|
|
|
LISTING_RHS_WIDTH Number of chars from the input file to print
|
|
|
|
on a line
|
|
|
|
*/
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
#include "as.h"
|
|
|
|
#include <obstack.h>
|
|
|
|
#include "input-file.h"
|
|
|
|
#include "targ-cpu.h"
|
|
|
|
|
|
|
|
#ifndef NO_LISTING
|
1992-02-15 22:13:03 +01:00
|
|
|
|
1992-01-21 23:14:16 +01:00
|
|
|
#ifndef LISTING_HEADER
|
|
|
|
#define LISTING_HEADER "GAS LISTING"
|
|
|
|
#endif
|
|
|
|
#ifndef LISTING_WORD_SIZE
|
|
|
|
#define LISTING_WORD_SIZE 4
|
|
|
|
#endif
|
|
|
|
#ifndef LISTING_LHS_WIDTH
|
|
|
|
#define LISTING_LHS_WIDTH 1
|
|
|
|
#endif
|
|
|
|
#ifndef LISTING_LHS_WIDTH_SECOND
|
|
|
|
#define LISTING_LHS_WIDTH_SECOND 1
|
|
|
|
#endif
|
|
|
|
#ifndef LISTING_RHS_WIDTH
|
|
|
|
#define LISTING_RHS_WIDTH 100
|
|
|
|
#endif
|
|
|
|
#ifndef LISTING_LHS_CONT_LINES
|
|
|
|
#define LISTING_LHS_CONT_LINES 4
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
1992-01-25 01:51:20 +01:00
|
|
|
/* This structure remembers which .s were used */
|
1992-02-15 22:13:03 +01:00
|
|
|
typedef struct file_info_struct {
|
1992-02-13 09:33:54 +01:00
|
|
|
char *filename;
|
|
|
|
int linenum;
|
|
|
|
FILE *file;
|
|
|
|
struct file_info_struct *next;
|
|
|
|
int end_pending;
|
1992-01-21 23:14:16 +01:00
|
|
|
} file_info_type ;
|
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
/* this structure rememebrs which line from which file goes into which frag */
|
|
|
|
typedef struct list_info_struct {
|
1992-02-13 09:33:54 +01:00
|
|
|
/* Frag which this line of source is nearest to */
|
|
|
|
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;
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
/* High level language source line */
|
|
|
|
int hll_line;
|
|
|
|
|
|
|
|
|
|
|
|
/* Pointer to any error message associated with this line */
|
|
|
|
char *message;
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
enum {
|
|
|
|
EDICT_NONE,
|
|
|
|
EDICT_SBTTL,
|
|
|
|
EDICT_TITLE,
|
|
|
|
EDICT_NOLIST,
|
|
|
|
EDICT_LIST,
|
|
|
|
EDICT_EJECT,
|
|
|
|
} edict;
|
1992-02-13 09:33:54 +01:00
|
|
|
char *edict_arg;
|
1992-01-21 23:14:16 +01:00
|
|
|
} list_info_type;
|
|
|
|
|
|
|
|
static struct list_info_struct *head;
|
|
|
|
struct list_info_struct *listing_tail;
|
|
|
|
extern int listing;
|
|
|
|
extern unsigned int physical_input_line;
|
|
|
|
extern fragS *frag_now;
|
|
|
|
|
|
|
|
static int paper_width = 200;
|
|
|
|
static int paper_height = 60;
|
|
|
|
|
|
|
|
/* this static array is used to keep the text of data to be printed
|
1992-02-15 22:13:03 +01:00
|
|
|
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. */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
static char data_buffer[100];
|
|
|
|
static unsigned int data_buffer_size;
|
|
|
|
|
|
|
|
static void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_message(name, message)
|
|
|
|
char *name;
|
|
|
|
char *message;
|
1992-02-13 09:33:54 +01:00
|
|
|
{
|
1992-02-15 22:13:03 +01:00
|
|
|
unsigned int l = strlen(name) + strlen(message) + 1;
|
|
|
|
char *n = malloc(l);
|
1992-02-13 09:33:54 +01:00
|
|
|
strcpy(n,name);
|
|
|
|
strcat(n,message);
|
1992-02-15 22:13:03 +01:00
|
|
|
if (listing_tail != (list_info_type *)NULL) {
|
|
|
|
listing_tail->message = n;
|
|
|
|
}
|
1992-01-21 23:14:16 +01:00
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
return;
|
|
|
|
} /* lising_message() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_warning(message)
|
|
|
|
char *message;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
listing_message("Warning:", message);
|
1992-01-21 23:14:16 +01:00
|
|
|
}
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
void
|
|
|
|
listing_error(message)
|
|
|
|
char *message;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
listing_message("Error:", message);
|
1992-01-21 23:14:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static file_info_type *file_info_head;
|
|
|
|
|
|
|
|
static file_info_type *
|
1992-02-15 22:13:03 +01:00
|
|
|
file_info(file_name)
|
|
|
|
char *file_name;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
/* Find an entry with this file name */
|
|
|
|
file_info_type *p = file_info_head;
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
while (p != (file_info_type *)NULL) {
|
|
|
|
if (strcmp(p->filename, file_name) == 0)
|
|
|
|
return(p);
|
|
|
|
p = p->next;
|
|
|
|
}
|
1992-02-13 09:33:54 +01:00
|
|
|
|
|
|
|
/* Make new entry */
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
p = (file_info_type *) xmalloc(sizeof(file_info_type));
|
1992-02-13 09:33:54 +01:00
|
|
|
p->next = file_info_head;
|
|
|
|
file_info_head = p;
|
|
|
|
p->filename = xmalloc(strlen(file_name)+1);
|
|
|
|
strcpy(p->filename, file_name);
|
|
|
|
p->linenum = 0;
|
|
|
|
p->end_pending = 0;
|
|
|
|
|
|
|
|
p->file = fopen(p->filename,"r");
|
1992-02-15 22:13:03 +01:00
|
|
|
return(p);
|
|
|
|
} /* file_info() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
|
1992-01-25 01:51:20 +01:00
|
|
|
static void
|
1992-02-15 22:13:03 +01:00
|
|
|
new_frag()
|
1992-01-25 01:51:20 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
frag_wane(frag_now);
|
|
|
|
frag_new(0);
|
1992-01-25 01:51:20 +01:00
|
|
|
}
|
|
|
|
|
1992-01-21 23:14:16 +01:00
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_newline(ps)
|
|
|
|
char *ps;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
char *s = ps;
|
|
|
|
extern char *file_name;
|
1992-02-15 22:13:03 +01:00
|
|
|
static unsigned int last_line = 0xffff ;
|
1992-02-13 09:33:54 +01:00
|
|
|
|
|
|
|
|
|
|
|
list_info_type *new;
|
1992-02-15 22:13:03 +01:00
|
|
|
if (physical_input_line != last_line) {
|
|
|
|
last_line = physical_input_line;
|
|
|
|
new_frag();
|
|
|
|
|
|
|
|
new = (list_info_type *) malloc(sizeof(list_info_type));
|
|
|
|
new->frag = frag_now;
|
|
|
|
new->line = physical_input_line ;
|
|
|
|
new->file = file_info(file_name);
|
|
|
|
|
|
|
|
if (listing_tail) {
|
|
|
|
listing_tail->next = new;
|
|
|
|
} 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();
|
|
|
|
}
|
1992-01-21 23:14:16 +01:00
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
return;
|
|
|
|
} /* listing_newline() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
|
|
|
|
/* This function returns the next source line from the file supplied,
|
|
|
|
truncated to size. It appends a fake line to the end of each input
|
|
|
|
file to make. */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
static char *
|
1992-02-15 22:13:03 +01:00
|
|
|
buffer_line(file, line, size)
|
|
|
|
file_info_type *file;
|
|
|
|
char *line;
|
|
|
|
unsigned int size;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
unsigned int count = 0;
|
|
|
|
int c;
|
|
|
|
|
|
|
|
char *p = line;
|
|
|
|
|
|
|
|
/* If we couldn't open the file, return an empty line */
|
1992-02-15 22:13:03 +01:00
|
|
|
if (file->file == (FILE*) NULL) {
|
|
|
|
return("");
|
|
|
|
}
|
1992-02-13 09:33:54 +01:00
|
|
|
|
|
|
|
if (file->end_pending == 10) {
|
|
|
|
*p ++ = '\n';
|
|
|
|
rewind(file->file);
|
|
|
|
file->linenum = 0;
|
|
|
|
file->end_pending = 0;
|
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
c = fgetc(file->file);
|
|
|
|
size -= 1; /* leave room for null */
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
while (c != EOF && c != '\n') {
|
|
|
|
if (count < size)
|
|
|
|
*p++ = c;
|
|
|
|
count++;
|
|
|
|
|
|
|
|
c = fgetc(file->file);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c == EOF) {
|
|
|
|
file->end_pending ++;
|
|
|
|
*p++ = 'E';
|
|
|
|
*p++ = 'O';
|
|
|
|
*p++ = 'F';
|
|
|
|
}
|
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
file->linenum++;
|
|
|
|
*p++ = 0;
|
1992-02-15 22:13:03 +01:00
|
|
|
return(line);
|
|
|
|
} /* buffer_line() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
static char *fn;
|
|
|
|
|
|
|
|
static unsigned int eject; /* Eject pending */
|
|
|
|
static unsigned int page; /* Current page number */
|
|
|
|
static char *title; /* current title */
|
|
|
|
static char *subtitle; /* current subtitle */
|
|
|
|
static unsigned int on_page; /* number of lines printed on current page */
|
|
|
|
|
|
|
|
static void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_page(list)
|
|
|
|
list_info_type *list;
|
1992-02-13 09:33:54 +01:00
|
|
|
{
|
1992-02-15 22:13:03 +01:00
|
|
|
/* 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) {
|
|
|
|
unsigned int c = 10;
|
|
|
|
int had_title = 0;
|
|
|
|
int had_subtitle = 0;
|
|
|
|
|
|
|
|
page++;
|
|
|
|
|
|
|
|
while (c != 0 && list) {
|
|
|
|
if (list->edict == EDICT_SBTTL && !had_subtitle) {
|
|
|
|
had_subtitle = 1;
|
|
|
|
subtitle = list->edict_arg;
|
1992-02-13 09:33:54 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
|
|
|
|
if (list->edict == EDICT_TITLE && !had_title) {
|
|
|
|
had_title = 1;
|
|
|
|
title = list->edict_arg;
|
|
|
|
}
|
|
|
|
list = list->next;
|
|
|
|
--c;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (page > 1) {
|
|
|
|
printf("\f");
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
|
|
|
|
printf("%s\n", title);
|
|
|
|
printf("%s\n", subtitle);
|
|
|
|
on_page = 3;
|
|
|
|
eject = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
} /* listing_page() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
|
|
|
|
static unsigned int
|
1992-02-15 22:13:03 +01:00
|
|
|
calc_hex(list)
|
|
|
|
list_info_type *list;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
list_info_type *first = list;
|
|
|
|
list_info_type *last = first;
|
|
|
|
unsigned int address = ~0;
|
|
|
|
|
|
|
|
fragS *frag;
|
|
|
|
fragS *frag_ptr;
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
unsigned int byte_in_frag = 0;
|
1992-02-13 09:33:54 +01:00
|
|
|
|
|
|
|
int anything = 0;
|
|
|
|
|
|
|
|
/* Find first frag which says it belongs to this line */
|
|
|
|
frag = list->frag;
|
|
|
|
while (frag && frag->line != list)
|
|
|
|
frag = frag->fr_next;
|
|
|
|
|
|
|
|
frag_ptr = frag;
|
|
|
|
|
|
|
|
data_buffer_size = 0;
|
|
|
|
|
|
|
|
/* Dump all the frags which belong to this line */
|
1992-02-15 22:13:03 +01:00
|
|
|
while (frag_ptr != (fragS *)NULL && frag_ptr->line == first) {
|
|
|
|
/* Print as many bytes from the fixed part as is sensible */
|
|
|
|
while(byte_in_frag < frag_ptr->fr_fix && data_buffer_size < sizeof(data_buffer)-10) {
|
|
|
|
if (address == ~0) {
|
|
|
|
address = frag_ptr->fr_address;
|
1992-02-13 09:33:54 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
|
|
|
|
sprintf(data_buffer + data_buffer_size, "%02X", (frag_ptr->fr_literal[byte_in_frag]) & 0xff);
|
|
|
|
data_buffer_size += 2;
|
|
|
|
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) {
|
|
|
|
if (address == ~0) {
|
|
|
|
address = frag_ptr->fr_address;
|
1992-02-13 09:33:54 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
data_buffer[data_buffer_size++] = '*';
|
|
|
|
data_buffer[data_buffer_size++] = '*';
|
|
|
|
|
|
|
|
byte_in_frag++;
|
|
|
|
}
|
|
|
|
|
|
|
|
frag_ptr = frag_ptr->fr_next;
|
|
|
|
}
|
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
data_buffer[data_buffer_size++] = 0;
|
|
|
|
return address;
|
1992-02-15 22:13:03 +01:00
|
|
|
} /* calc_hex() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
static void
|
1992-02-15 22:13:03 +01:00
|
|
|
print_lines(list, string, address)
|
|
|
|
list_info_type *list;
|
|
|
|
char *string;
|
|
|
|
unsigned int address;
|
1992-02-13 09:33:54 +01:00
|
|
|
{
|
|
|
|
unsigned int idx;
|
|
|
|
unsigned int nchars;
|
|
|
|
unsigned int lines;
|
|
|
|
unsigned int byte_in_word =0;
|
|
|
|
char *src = data_buffer;
|
1992-01-21 23:14:16 +01:00
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
/* Print the stuff on the first line */
|
1992-01-21 23:14:16 +01:00
|
|
|
listing_page(list);
|
1992-02-15 22:13:03 +01:00
|
|
|
nchars = (LISTING_WORD_SIZE * 2 + 1) * LISTING_LHS_WIDTH ;
|
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
/* Print the hex for the first line */
|
1992-02-15 22:13:03 +01:00
|
|
|
if (address == ~0) {
|
|
|
|
printf("% 4d ", list->line);
|
|
|
|
for (idx = 0; idx < nchars; idx++)
|
|
|
|
printf(" ");
|
|
|
|
|
|
|
|
printf("\t%s\n", string ? string : "");
|
|
|
|
on_page++;
|
|
|
|
listing_page(0);
|
|
|
|
} else {
|
|
|
|
if (had_errors()) {
|
|
|
|
printf("% 4d ???? ", list->line);
|
|
|
|
} else {
|
|
|
|
printf("% 4d %04x ", list->line, address);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* And the data to go along with it */
|
|
|
|
idx = 0;
|
|
|
|
|
|
|
|
while (*src && idx < nchars) {
|
|
|
|
printf("%c%c", src[0], src[1]);
|
|
|
|
src += 2;
|
|
|
|
byte_in_word++;
|
|
|
|
|
|
|
|
if (byte_in_word == LISTING_WORD_SIZE) {
|
|
|
|
printf(" ");
|
|
|
|
idx++;
|
|
|
|
byte_in_word = 0;
|
1992-02-13 09:33:54 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
idx+=2;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;idx < nchars; idx++)
|
|
|
|
printf(" ");
|
|
|
|
|
|
|
|
printf("\t%s\n", string ? string : "");
|
|
|
|
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) {
|
1992-02-13 09:33:54 +01:00
|
|
|
printf("%c%c", src[0], src[1]);
|
1992-02-15 22:13:03 +01:00
|
|
|
src+=2;
|
1992-02-13 09:33:54 +01:00
|
|
|
idx+=2;
|
1992-02-15 22:13:03 +01:00
|
|
|
byte_in_word++;
|
|
|
|
if (byte_in_word == LISTING_WORD_SIZE) {
|
|
|
|
printf(" ");
|
|
|
|
idx++;
|
|
|
|
byte_in_word = 0;
|
1992-02-13 09:33:54 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
printf("\n");
|
|
|
|
on_page++;
|
|
|
|
listing_page(list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} /* print_lines() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
|
|
|
|
static void
|
1992-02-15 22:13:03 +01:00
|
|
|
list_symbol_table()
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
extern symbolS *symbol_rootP;
|
1992-02-15 22:13:03 +01:00
|
|
|
symbolS *ptr;
|
1992-02-13 09:33:54 +01:00
|
|
|
|
|
|
|
eject = 1;
|
|
|
|
listing_page(0);
|
|
|
|
printf("DEFINED SYMBOLS\n");
|
|
|
|
on_page++;
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr)) {
|
|
|
|
if (ptr->sy_frag->line) {
|
|
|
|
if (strlen(S_GET_NAME(ptr))) {
|
|
|
|
printf("%20s:%-5d %2d:%08x %s \n",
|
|
|
|
ptr->sy_frag->line->file->filename,
|
|
|
|
ptr->sy_frag->line->line,
|
|
|
|
S_GET_SEGMENT(ptr),
|
|
|
|
S_GET_VALUE(ptr),
|
|
|
|
S_GET_NAME(ptr));
|
|
|
|
|
|
|
|
on_page++;
|
|
|
|
listing_page(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
printf("\n");
|
1992-01-25 02:45:53 +01:00
|
|
|
on_page++;
|
|
|
|
listing_page(0);
|
1992-02-13 09:33:54 +01:00
|
|
|
printf("UNDEFINED SYMBOLS\n");
|
1992-01-25 01:51:20 +01:00
|
|
|
on_page++;
|
|
|
|
listing_page(0);
|
1992-02-13 09:33:54 +01:00
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr)) {
|
|
|
|
if (ptr && strlen(S_GET_NAME(ptr)) != 0) {
|
|
|
|
if (ptr->sy_frag->line == 0) {
|
|
|
|
printf("%s\n", S_GET_NAME(ptr));
|
|
|
|
on_page++;
|
|
|
|
listing_page(0);
|
1992-02-13 09:33:54 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
} /* list_symbol_table() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
1992-01-25 01:51:20 +01:00
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
print_source(current_file, list, buffer, width)
|
|
|
|
file_info_type *current_file;
|
|
|
|
list_info_type *list;
|
|
|
|
char *buffer;
|
|
|
|
unsigned int width;
|
1992-02-13 09:33:54 +01:00
|
|
|
{
|
|
|
|
if (current_file->file) {
|
1992-02-15 22:13:03 +01:00
|
|
|
while (current_file->linenum < list->hll_line) {
|
|
|
|
char * p = buffer_line(current_file, buffer, width);
|
|
|
|
printf("%4d:%-13s **** %s\n", current_file->linenum, current_file->filename, p);
|
|
|
|
on_page++;
|
|
|
|
listing_page(list);
|
|
|
|
}
|
1992-02-13 09:33:54 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
|
|
|
|
return;
|
|
|
|
} /* print_source() */
|
1992-01-25 01:51:20 +01:00
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
/* Sometimes the user doesn't want to be bothered by the debugging
|
|
|
|
records inserted by the compiler, see if the line is suspicioous */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
static int
|
1992-02-15 22:13:03 +01:00
|
|
|
debugging_pseudo(line)
|
|
|
|
char *line;
|
1992-02-13 09:33:54 +01:00
|
|
|
{
|
|
|
|
while (isspace(*line))
|
|
|
|
line++;
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
if (*line != '.') return 0;
|
1992-02-13 09:33:54 +01:00
|
|
|
|
|
|
|
line++;
|
|
|
|
|
|
|
|
if (strncmp(line, "def",3) == 0) return 1;
|
|
|
|
if (strncmp(line, "val",3) == 0) return 1;
|
|
|
|
if (strncmp(line, "scl",3) == 0) return 1;
|
|
|
|
if (strncmp(line, "line",4) == 0) return 1;
|
|
|
|
if (strncmp(line, "endef",5) == 0) return 1;
|
|
|
|
if (strncmp(line, "ln",2) ==0) return 1;
|
|
|
|
if (strncmp(line, "type",4) ==0) return 1;
|
|
|
|
if (strncmp(line, "size",4) == 0) return 1;
|
|
|
|
if (strncmp(line, "dim",3) ==0) return 1;
|
|
|
|
if (strncmp(line, "tag",3) == 0) return 1;
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
return(0);
|
|
|
|
} /* debugging_pseudo() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_listing(name)
|
|
|
|
char *name;
|
1992-02-13 09:33:54 +01:00
|
|
|
{
|
|
|
|
char *buffer;
|
1992-02-15 22:13:03 +01:00
|
|
|
char *message;
|
1992-02-13 09:33:54 +01:00
|
|
|
char *p;
|
1992-02-15 22:13:03 +01:00
|
|
|
file_info_type *current_hll_file = (file_info_type *) NULL;
|
1992-02-13 09:33:54 +01:00
|
|
|
int on_page = 0;
|
|
|
|
int show_listing = 1;
|
1992-02-15 22:13:03 +01:00
|
|
|
list_info_type *list = head;
|
|
|
|
unsigned int addr = 0;
|
|
|
|
unsigned int page = 1;
|
|
|
|
unsigned int prev = 0;
|
1992-02-13 09:33:54 +01:00
|
|
|
unsigned int width;
|
|
|
|
|
|
|
|
buffer = malloc(LISTING_RHS_WIDTH);
|
1992-01-21 23:14:16 +01:00
|
|
|
eject = 1;
|
1992-02-13 09:33:54 +01:00
|
|
|
list = head;
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
while (list != (list_info_type *)NULL && 0) {
|
|
|
|
if (list->next)
|
|
|
|
list->frag = list->next->frag;
|
|
|
|
list = list->next;
|
|
|
|
}
|
1992-02-13 09:33:54 +01:00
|
|
|
|
|
|
|
list = head->next;
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
while (list) {
|
|
|
|
width = LISTING_RHS_WIDTH > paper_width ? paper_width : LISTING_RHS_WIDTH;
|
|
|
|
|
|
|
|
switch (list->edict) {
|
|
|
|
case EDICT_LIST:
|
|
|
|
show_listing++;
|
|
|
|
break;
|
|
|
|
case EDICT_NOLIST:
|
|
|
|
show_listing--;
|
|
|
|
break;
|
|
|
|
case EDICT_EJECT:
|
|
|
|
break;
|
|
|
|
case EDICT_NONE:
|
|
|
|
break;
|
|
|
|
case EDICT_TITLE:
|
|
|
|
title = list->edict_arg;
|
|
|
|
break;
|
|
|
|
case EDICT_SBTTL:
|
|
|
|
subtitle = list->edict_arg;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (show_listing > 0) {
|
|
|
|
/* Scan down the list and print all the stuff which can be done
|
|
|
|
with this line (or lines) */
|
|
|
|
message = 0;
|
|
|
|
|
|
|
|
if (list->hll_file) {
|
|
|
|
current_hll_file = list->hll_file;
|
1992-02-13 09:33:54 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
|
|
|
|
if (current_hll_file && list->hll_line && listing & LISTING_HLL) {
|
|
|
|
print_source(current_hll_file, list, buffer, width);
|
1992-02-13 09:33:54 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
|
|
|
|
p = buffer_line(list->file, buffer, width);
|
|
|
|
|
|
|
|
if (! ((listing & LISTING_NODEBUG) && debugging_pseudo(p))) {
|
|
|
|
print_lines(list, p, calc_hex(list));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (list->edict == EDICT_EJECT) {
|
|
|
|
eject = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
p = buffer_line(list->file, buffer, width);
|
|
|
|
}
|
|
|
|
|
|
|
|
list = list->next;
|
|
|
|
}
|
1992-02-13 09:33:54 +01:00
|
|
|
free(buffer);
|
1992-02-15 22:13:03 +01:00
|
|
|
} /* listing_listing() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_print(name)
|
|
|
|
char *name;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
title = "";
|
|
|
|
subtitle = "";
|
|
|
|
|
|
|
|
if (listing & LISTING_NOFORM)
|
|
|
|
{
|
|
|
|
paper_height = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (listing & LISTING_LISTING)
|
|
|
|
{
|
|
|
|
listing_listing(name);
|
|
|
|
|
|
|
|
}
|
|
|
|
if (listing & LISTING_SYMBOLS)
|
|
|
|
{
|
|
|
|
list_symbol_table();
|
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
} /* listing_print() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
|
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_file(name)
|
|
|
|
char *name;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
fn = name;
|
1992-01-21 23:14:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_eject()
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
listing_tail->edict = EDICT_EJECT;
|
1992-02-15 22:13:03 +01:00
|
|
|
return;
|
1992-01-21 23:14:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_flags()
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
|
1992-01-21 23:14:16 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
|
1992-01-21 23:14:16 +01:00
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_list(on)
|
|
|
|
unsigned int on;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
listing_tail->edict = on ? EDICT_LIST : EDICT_NOLIST;
|
1992-01-21 23:14:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_psize()
|
1992-02-13 09:33:54 +01:00
|
|
|
{
|
|
|
|
paper_height = get_absolute_expression();
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
if (paper_height < 0 || paper_height > 1000) {
|
|
|
|
paper_height = 0;
|
|
|
|
as_warn("strantge paper height, set to no form");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*input_line_pointer == ',') {
|
|
|
|
input_line_pointer++;
|
|
|
|
paper_width = get_absolute_expression();
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
} /* listing_psize() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
|
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_title(depth)
|
|
|
|
unsigned int depth;
|
1992-01-21 23:14:16 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
char *start;
|
|
|
|
char *title;
|
|
|
|
unsigned int length;
|
|
|
|
|
|
|
|
SKIP_WHITESPACE();
|
1992-02-15 22:13:03 +01:00
|
|
|
|
1992-02-13 09:33:54 +01:00
|
|
|
if (*input_line_pointer=='\"') {
|
|
|
|
input_line_pointer++;
|
|
|
|
start = input_line_pointer;
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
while (*input_line_pointer) {
|
|
|
|
if (*input_line_pointer == '\"') {
|
|
|
|
length = input_line_pointer - start;
|
|
|
|
title = malloc(length + 1);
|
|
|
|
memcpy(title, start, length);
|
|
|
|
title[length] = 0;
|
|
|
|
listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
|
|
|
|
listing_tail->edict_arg = title;
|
|
|
|
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");
|
1992-01-21 23:14:16 +01:00
|
|
|
}
|
1992-02-15 22:13:03 +01:00
|
|
|
|
|
|
|
return;
|
|
|
|
} /* listing_title() */
|
1992-01-21 23:14:16 +01:00
|
|
|
|
|
|
|
|
1992-01-25 01:51:20 +01:00
|
|
|
|
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_source_line(line)
|
|
|
|
unsigned int line;
|
1992-01-25 01:51:20 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
new_frag();
|
|
|
|
listing_tail->hll_line = line;
|
|
|
|
new_frag();
|
1992-02-15 22:13:03 +01:00
|
|
|
return;
|
|
|
|
} /* lising_source_line() */
|
1992-01-25 01:51:20 +01:00
|
|
|
|
|
|
|
void
|
1992-02-15 22:13:03 +01:00
|
|
|
listing_source_file(file)
|
|
|
|
char *file;
|
1992-01-25 01:51:20 +01:00
|
|
|
{
|
1992-02-13 09:33:54 +01:00
|
|
|
listing_tail->hll_file = file_info(file);
|
1992-01-25 01:51:20 +01:00
|
|
|
}
|
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
#endif /* not NO_LISTING */
|
1992-01-25 01:51:20 +01:00
|
|
|
|
1992-02-15 22:13:03 +01:00
|
|
|
/* end of listing.c */
|