From 724262fb904828bcafc03ab689ce64b9986ee81f Mon Sep 17 00:00:00 2001
From: cuz <cuz@b7a2c559-68d2-44c3-8de9-860c34a00d81>
Date: Sat, 3 Mar 2001 12:01:46 +0000
Subject: [PATCH] Fixed a bug with different load/run areas, where a segment
 was marked as dumped if the run area preceeded the load area, so it was not
 output into the file for the load area (and not for the run area either).

git-svn-id: svn://svn.cc65.org/cc65/trunk@603 b7a2c559-68d2-44c3-8de9-860c34a00d81
---
 src/ld65/bin.c    | 24 ++++++++++++++--
 src/ld65/config.c | 70 +++++++++++++++++++++++++++--------------------
 2 files changed, 62 insertions(+), 32 deletions(-)

diff --git a/src/ld65/bin.c b/src/ld65/bin.c
index 48bc5d65b..f6f7425fa 100644
--- a/src/ld65/bin.c
+++ b/src/ld65/bin.c
@@ -102,13 +102,21 @@ static unsigned BinWriteExpr (ExprNode* E, int Signed, unsigned Size,
 /* Called from SegWrite for an expression. Evaluate the expression, check the
  * range and write the expression value to the file.
  */
-{	      
+{
     /* There's a predefined function to handle constant expressions */
     return SegWriteConstExpr (((BinDesc*)Data)->F, E, Signed, Size);
 }
 
 
 
+static void PrintBoolVal (const char* Name, int B)
+/* Print a boolean value for debugging */
+{
+    printf ("      %s = %s\n", Name, B? "true" : "false");
+}
+
+
+
 static void BinWriteMem (BinDesc* D, Memory* M)
 /* Write the segments of one memory area to a file */
 {
@@ -134,6 +142,14 @@ static void BinWriteMem (BinDesc* D, Memory* M)
 		   S->Load == M 		&&	/* LOAD segment */
 		   S->Seg->Dumped == 0;			/* Not already written */
 
+	/* Output the DoWrite flag for debugging */
+	if (Verbose > 1) {
+       	    PrintBoolVal ("bss", S->Flags & SF_BSS);
+	    PrintBoolVal ("LoadArea", S->Load == M);
+       	    PrintBoolVal ("Dumped", S->Seg->Dumped);
+	    PrintBoolVal ("DoWrite", DoWrite);
+	}
+
 	/* Check if we would need an alignment */
 	if (S->Seg->Align > S->Align) {
 	    /* Segment itself requires larger alignment than configured
@@ -175,7 +191,11 @@ static void BinWriteMem (BinDesc* D, Memory* M)
 	} else if (M->Flags & MF_FILL) {
 	    WriteMult (D->F, M->FillVal, S->Seg->Size);
 	}
-	S->Seg->Dumped = 1;
+
+	/* If this was the load memory area, mark the segment as dumped */
+	if (S->Load == M) {
+  	    S->Seg->Dumped = 1;
+       	}
 
 	/* Calculate the new address */
 	Addr += S->Seg->Size;
diff --git a/src/ld65/config.c b/src/ld65/config.c
index ee963de1d..be31d6fdb 100644
--- a/src/ld65/config.c
+++ b/src/ld65/config.c
@@ -1367,48 +1367,58 @@ void CfgWriteTarget (void)
     /* Walk through the files list */
     File* F = FileList;
     while (F) {
-	/* We don't need to look at files with no memory areas */
-	if (F->MemList) {
+  	/* We don't need to look at files with no memory areas */
+  	if (F->MemList) {
 
-	    /* Is there an output file? */
-	    if (strlen (F->Name) > 0) {
+  	    /* Is there an output file? */
+  	    if (strlen (F->Name) > 0) {
 
-		/* Assign a proper binary format */
-		if (F->Format == BINFMT_DEFAULT) {
-	    	    F->Format = DefaultBinFmt;
+  		/* Assign a proper binary format */
+  		if (F->Format == BINFMT_DEFAULT) {
+  	    	    F->Format = DefaultBinFmt;
      		}
 
      		/* Call the apropriate routine for the binary format */
-		switch (F->Format) {
+  		switch (F->Format) {
 
-		    case BINFMT_BINARY:
-			BinWriteTarget (BinFmtDesc, F);
-			break;
+  		    case BINFMT_BINARY:
+  		      	BinWriteTarget (BinFmtDesc, F);
+  		      	break;
 
-		    case BINFMT_O65:
-			O65WriteTarget (O65FmtDesc, F);
-			break;
+  		    case BINFMT_O65:
+  		      	O65WriteTarget (O65FmtDesc, F);
+  		      	break;
 
-		    default:
-		        Internal ("Invalid binary format: %u", F->Format);
+  		    default:
+  		        Internal ("Invalid binary format: %u", F->Format);
 
-		}
+  		}
 
-	    } else {
+  	    } else {
 
-		/* No output file. Walk through the list and mark all segments
-		 * assigned to the memory areas in this file as dumped.
-		 */
-		M = F->MemList;
-		while (M) {
-		    /* Walk throught the segments */
-		    MemListNode* N = M->SegList;
-		    while (N) {
-			/* Mark the segment as dumped */
-       	       	       	N->Seg->Seg->Dumped = 1;
+  		/* No output file. Walk through the list and mark all segments
+       	       	 * loading into these memory areas in this file as dumped.
+  		 */
+  		M = F->MemList;
+  		while (M) {
 
-			/* Next segment node */
-			N = N->Next;
+		    MemListNode* N;
+
+		    /* Debugging */
+		    if (Verbose > 1) {
+			printf ("Skipping `%s'...\n", M->Name);
+		    }
+
+  		    /* Walk throught the segments */
+  		    N = M->SegList;
+  		    while (N) {
+		      	if (N->Seg->Load == M) {
+  		      	    /* Load area - mark the segment as dumped */
+  		      	    N->Seg->Seg->Dumped = 1;
+  		      	}
+
+		      	/* Next segment node */
+		      	N = N->Next;
 		    }
 		    /* Next memory area */
 		    M = M->FNext;