1 /*****************************************************************************/
5 /* Listing support for the ca65 crossassembler */
9 /* (C) 2000 Ullrich von Bassewitz */
11 /* D-70597 Stuttgart */
12 /* EMail: uz@musoftware.de */
15 /* This software is provided 'as-is', without any expressed or implied */
16 /* warranty. In no event will the authors be held liable for any damages */
17 /* arising from the use of this software. */
19 /* Permission is granted to anyone to use this software for any purpose, */
20 /* including commercial applications, and to alter it and redistribute it */
21 /* freely, subject to the following restrictions: */
23 /* 1. The origin of this software must not be misrepresented; you must not */
24 /* claim that you wrote the original software. If you use this software */
25 /* in a product, an acknowledgment in the product documentation would be */
26 /* appreciated but is not required. */
27 /* 2. Altered source versions must be plainly marked as such, and must not */
28 /* be misrepresented as being the original software. */
29 /* 3. This notice may not be removed or altered from any source */
32 /*****************************************************************************/
56 /*****************************************************************************/
58 /*****************************************************************************/
62 /* Single linked list of lines */
63 ListLine* LineList = 0; /* List of listing lines */
64 ListLine* LineCur = 0; /* Current listing line */
65 ListLine* LineLast = 0; /* Last (current) listing line */
67 /* Page and other formatting */
68 int PageLength = -1; /* Length of a listing page */
69 static unsigned PageNumber = 1; /* Current listing page number */
70 static int PageLines = 0; /* Current line on page */
71 static unsigned ListBytes = 12; /* Number of bytes to list for one line */
73 /* Switch the listing on/off */
74 static int ListingEnabled = 1; /* Enabled if > 0 */
78 /*****************************************************************************/
80 /*****************************************************************************/
84 void NewListingLine (const char* Line, unsigned char File, unsigned char Depth)
85 /* Create a new ListLine struct and insert it */
87 /* Store only if listing is enabled */
92 /* Get the length of the line */
93 unsigned Len = strlen (Line);
95 /* Ignore trailing newlines */
96 while (Len > 0 && Line[Len-1] == '\n') {
100 /* Allocate memory */
101 L = xmalloc (sizeof (ListLine) + Len);
103 /* Initialize the fields. */
108 L->Reloc = RelocMode;
111 L->Output = (ListingEnabled > 0);
112 L->ListBytes = (unsigned char) ListBytes;
113 memcpy (L->Line, Line, Len);
114 L->Line [Len] = '\0';
116 /* Insert the line into the list of lines */
128 void EnableListing (void)
129 /* Enable output of lines to the listing */
132 /* If we're about to enable the listing, do this for the current line
133 * also, so we will see the source line that did this.
135 if (ListingEnabled++ == 0) {
143 void DisableListing (void)
144 /* Disable output of lines to the listing */
147 if (ListingEnabled == 0) {
148 /* Cannot switch the listing off once more */
149 Error (ERR_COUNTER_UNDERFLOW);
158 void SetListBytes (int Bytes)
159 /* Set the maximum number of bytes listed for one line */
162 Bytes = 0; /* Encode "unlimited" as zero */
169 void InitListingLine (void)
170 /* Initialize the current listing line */
173 /* Make the last loaded line the current line */
174 /* ###### This code is a hack! We really need to do it right
175 * as soon as we know, how:-(
177 if (LineCur && LineCur->Next && LineCur->Next != LineLast) {
178 ListLine* L = LineCur;
181 /* Set the values for this line */
184 L->Reloc = RelocMode;
185 L->Output = (ListingEnabled > 0);
186 L->ListBytes = (unsigned char) ListBytes;
187 } while (L->Next != LineLast);
191 /* Set the values for this line */
192 CHECK (LineCur != 0);
193 LineCur->PC = GetPC ();
194 LineCur->Reloc = RelocMode;
195 LineCur->Output = (ListingEnabled > 0);
196 LineCur->ListBytes = (unsigned char) ListBytes;
202 static char* AddHex (char* S, unsigned Val)
203 /* Add a hex byte in ASCII to the given string and return the new pointer */
205 static const char HexTab [16] = {
206 '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
209 *S++ = HexTab [(Val >> 4) & 0x0F];
210 *S++ = HexTab [Val & 0x0F];
217 static void PrintPageHeader (FILE* F, const ListLine* L)
218 /* Print the header for a new page. It is assumed that the given line is the
219 * last line of the previous page.
222 /* Print the header on the new page */
224 "ca65 V%u.%u.%u - (C) Copyright 1998-2000 Ullrich von Bassewitz\n"
228 VER_MAJOR, VER_MINOR, VER_PATCH,
230 GetFileName (L->File));
232 /* Count pages, reset lines */
239 static void PrintLine (FILE* F, const char* Header, const char* Line, const ListLine* L)
240 /* Print one line to the listing file, adding a newline and counting lines */
242 /* Print the given line */
243 fprintf (F, "%s%s\n", Header, Line);
245 /* Increment the current line */
248 /* Switch to a new page if needed. Do not switch, if the current line is
249 * the last one, to avoid pages that consist of just the header.
251 if (PageLength > 0 && PageLines >= PageLength && L->Next != 0) {
254 /* Print the header on the new page */
255 PrintPageHeader (F, L);
261 static char* AddMult (char* S, char C, unsigned Count)
262 /* Add multiple instances of character C to S, return updated S. */
264 memset (S, C, Count);
270 static char* MakeLineHeader (char* H, const ListLine* L)
271 /* Prepare the line header */
276 /* Setup the PC mode */
277 Mode = (L->Reloc)? 'r' : ' ';
279 /* Set up the include depth */
280 Depth = (L->Depth < 10)? L->Depth + '0' : '+';
282 /* Format the line */
283 sprintf (H, "%06lX%c %c", L->PC, Mode, Depth);
284 memset (H+9, ' ', LINE_HEADER_LEN-9);
286 /* Return the buffer */
292 void CreateListing (void)
293 /* Create the listing */
298 char HeaderBuf [LINE_HEADER_LEN+1];
300 /* Create the name of the listing file if needed */
302 ListFile = MakeFilename (InFile, ListExt);
305 /* Open the real listing file */
306 F = fopen (ListFile, "w");
308 Fatal (FAT_CANNOT_OPEN_LISTING, strerror (errno));
311 /* Reset variables, print the header for the first page */
313 PrintPageHeader (F, LineList);
315 /* Terminate the header buffer. The last byte will never get overwritten */
316 HeaderBuf [LINE_HEADER_LEN] = '\0';
318 /* Walk through all listing lines */
328 /* If we should not output this line, go to the next */
329 if (L->Output == 0) {
334 /* If we don't have a fragment list for this line, things are easy */
335 if (L->FragList == 0) {
336 PrintLine (F, MakeLineHeader (HeaderBuf, L), L->Line, L);
341 /* Count the number of bytes in the complete fragment list */
346 Frag = Frag->LineList;
349 /* Allocate memory for the given number of bytes */
350 Buf = xmalloc (Count*2+1);
352 /* Copy an ASCII representation of the bytes into the buffer */
357 /* Write data depending on the type */
358 switch (Frag->Type) {
361 for (I = 0; I < Frag->Len; ++I) {
362 B = AddHex (B, Frag->V.Data[I]);
368 B = AddMult (B, 'r', Frag->Len*2);
372 B = AddMult (B, 'x', Frag->Len*2);
376 Internal ("Invalid fragment type: %u", Frag->Type);
381 Frag = Frag->LineList;
385 /* Limit the number of bytes actually printed */
386 if (L->ListBytes != 0) {
388 if (Count > L->ListBytes) {
389 Count = L->ListBytes;
393 /* Output the data. The format of a listing line is:
395 * PPPPPPm I 11 22 33 44
400 * m is the mode ('r' or empty)
401 * I is the include level
402 * 11 .. are code or data bytes
411 /* Prepare the line header */
412 MakeLineHeader (HeaderBuf, L);
414 /* Get the number of bytes for the next line */
421 /* Increment the program counter. Since we don't need the PC stored
422 * in the LineList object for anything else, just increment this
427 /* Copy the bytes into the line */
429 for (I = 0; I < Chunk; ++I) {
435 /* Output this line */
436 PrintLine (F, HeaderBuf, Line, L);
438 /* Don't output a line twice */
443 /* Delete the temporary buffer */
451 /* Close the listing file */