X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=sect.c;h=21591a0219146b127a7321dbd07dcea4cab0ba1f;hp=3fd627a409560ea80ad3c38f5fc47ac1db93ffa1;hb=9fb8931331db981c04e062a3ad36c0d79acb30ae;hpb=233e5e908f5a865233f775520dc35917f13d2d26

diff --git a/sect.c b/sect.c
index 3fd627a..21591a0 100644
--- a/sect.c
+++ b/sect.c
@@ -17,52 +17,54 @@
 #include "symbol.h"
 #include "token.h"
 
+
 // Section descriptors
-SECT sect[NSECTS];						// All sections... 
-int cursect;							// Current section number
+SECT sect[NSECTS];				// All sections... 
+int cursect;					// Current section number
 
 // These are copied from the section descriptor, the current code chunk
 // descriptor and the current fixup chunk descriptor when a switch is made into
 // a section.  They are copied back to the descriptors when the section is left.
-WORD scattr;							// Section attributes 
-LONG sloc;								// Current loc in section 
+WORD scattr;					// Section attributes 
+LONG sloc;						// Current loc in section 
 
-CHUNK * scode;							// Current (last) code chunk 
-LONG challoc;							// # bytes alloc'd to code chunk 
-LONG ch_size;							// # bytes used in code chunk 
-char * chptr;							// Deposit point in code chunk buffer 
+CHUNK * scode;					// Current (last) code chunk 
+LONG challoc;					// # bytes alloc'd to code chunk 
+LONG ch_size;					// # bytes used in code chunk 
+char * chptr;					// Deposit point in code chunk buffer 
 
-CHUNK * sfix;							// Current (last) fixup chunk
-LONG fchalloc;							// # bytes alloc'd to fixup chunk
-LONG fchsize;							// # bytes used in fixup chunk
-PTR fchptr;								// Deposit point in fixup chunk buffer
+CHUNK * sfix;					// Current (last) fixup chunk
+LONG fchalloc;					// # bytes alloc'd to fixup chunk
+LONG fchsize;					// # bytes used in fixup chunk
+PTR fchptr;						// Deposit point in fixup chunk buffer
 
-unsigned fwdjump[MAXFWDJUMPS];			// forward jump check table
-unsigned fwindex = 0;					// forward jump index
+// BOLLOCKS
+//unsigned fwdjump[MAXFWDJUMPS];	// forward jump check table
+//unsigned fwindex = 0;			// forward jump index
 
 // Return a size (SIZB, SIZW, SIZL) or 0, depending on what kind of fixup is
 // associated with a location.
 static char fusiztab[] = {
-   0,						// FU_QUICK
-   1,						// FU_BYTE
-   2,						// FU_WORD
-   2,						// FU_WBYTE
-   4,						// FU_LONG
-   1,						// FU_BBRA
-   0,						// (unused)
-   1,						// FU_6BRA
+   0,	// FU_QUICK
+   1,	// FU_BYTE
+   2,	// FU_WORD
+   2,	// FU_WBYTE
+   4,	// FU_LONG
+   1,	// FU_BBRA
+   0,	// (unused)
+   1,	// FU_6BRA
 };
 
 // Offset to REAL fixup location
 static char fusizoffs[] = {
-   0,						// FU_QUICK
-   0,						// FU_BYTE
-   0,						// FU_WORD
-   1,						// FU_WBYTE
-   0,						// FU_LONG
-   1,						// FU_BBRA
-   0,						// (unused)
-   0,						// FU_6BRA
+   0,	// FU_QUICK
+   0,	// FU_BYTE
+   0,	// FU_WORD
+   1,	// FU_WBYTE
+   0,	// FU_LONG
+   1,	// FU_BBRA
+   0,	// (unused)
+   0,	// FU_6BRA
 };
 
 
@@ -71,9 +73,7 @@ static char fusizoffs[] = {
 //
 void mksect(int sno, WORD attr)
 {
-	SECT * p;                                                 // Section pointer
-
-	p = &sect[sno];
+	SECT * p = &sect[sno];
 	p->scattr = attr;
 	p->sloc = 0;
 	p->scode = p->sfcode = NULL;
@@ -125,13 +125,13 @@ void savsect(void)
 {
 	SECT * p = &sect[cursect];
 
-	p->scattr = scattr;                                      // Bailout section vars
+	p->scattr = scattr;						// Bailout section vars
 	p->sloc = sloc;
 
-	if (scode != NULL)                                        // Bailout code chunk
+	if (scode != NULL)						// Bailout code chunk
 		scode->ch_size = ch_size;
 
-	if (sfix != NULL)                                         // Bailout fixup chunk
+	if (sfix != NULL)						// Bailout fixup chunk
 		sfix->ch_size = fchsize;
 }
 
@@ -212,6 +212,7 @@ int fixtest(int sno, LONG loc)
 //
 int chcheck(LONG amt)
 {
+	DEBUG { printf("chcheck(%u)\n", amt); }
 	// If in BSS section, no allocation required
 	if (scattr & SBSS)
 		return 0;
@@ -219,12 +220,14 @@ int chcheck(LONG amt)
 	if (!amt)
 		amt = CH_THRESHOLD;
 
+	DEBUG { printf("    challoc=%i, ch_size=%i, diff=%i\n", challoc, ch_size, challoc-ch_size); }
 	if ((int)(challoc - ch_size) >= (int)amt) 
 		return 0;
 
 	if (amt < CH_CODE_SIZE)
 		amt = CH_CODE_SIZE;
 
+	DEBUG { printf("    amt (adjusted)=%u\n", amt); }
 	SECT * p = &sect[cursect];
 	CHUNK * cp = malloc(sizeof(CHUNK) + amt);
 
@@ -267,6 +270,7 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr)
 	CHUNK * cp;
 	SECT * p;
 	// Shamus: Expression lengths are voodoo ATM (varibale "i"). Need to fix this.
+#warning "!!! fixup() is filled with VOODOO !!!"
 	DEBUG printf("FIXUP@$%X: $%X\n", loc, attr);
 
 	// Compute length of expression (could be faster); determine if it's the
@@ -383,7 +387,9 @@ int ResolveAllFixups(void)
 	ResolveFixups(TEXT);
 	DEBUG printf("Resolving DATA sections...\n");
 	ResolveFixups(DATA);
-	
+
+//No, no we don't.
+#if 0	
 	// We need to do a final check of forward 'jump' destination addresses that
 	// are external
 	for(i=0; i<MAXFWDJUMPS; i++)
@@ -402,6 +408,7 @@ int ResolveAllFixups(void)
 				printf("%s\n", buf);
 		}
 	}
+#endif
 
 	return 0;
 }
@@ -453,6 +460,10 @@ int ResolveFixups(int sno)
 			loc = *fup.lp++;
 			cfileno = *fup.wp++;
 			curlineno = (int)*fup.wp++;
+DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
+			// This is based on global vars cfileno, curfname :-P
+			// This approach is kinda meh as well. I think we can do better than this.
+			SetFilenameForErrorReporting();
 
 			esym = NULL;
 
@@ -581,7 +592,7 @@ int ResolveFixups(int sno)
 				break;
 			// Fixup one-byte value at locp + 1.
 			case FU_WBYTE:
-				++locp;
+				locp++;
 				// FALLTHROUGH
 			// Fixup one-byte forward references
 			case FU_BYTE:
@@ -614,19 +625,16 @@ int ResolveFixups(int sno)
 			// the word could be unaligned in the section buffer, so we have to
 			// be careful.
 			case FU_WORD:
-				if (((w & 0x0F00) == FU_JR) || ((w & 0x0F00) == FU_MJR))
+				if ((w & 0x0F00) == FU_JR)// || ((w & 0x0F00) == FU_MJR))
 				{
 					oaddr = *fup.lp++;
 
 					if (oaddr)
-					{
 						reg2 = (signed)((eval - (oaddr + 2)) / 2);// & 0x1F;
-					}
 					else
-					{
 						reg2 = (signed)((eval - (loc + 2)) / 2);// & 0x1F;
-					}
 
+#if 0
 					if ((w & 0x0F00) == FU_MJR)
 					{
 						// Main code destination alignment checking here for
@@ -663,6 +671,7 @@ int ResolveFixups(int sno)
 							}
 						}
 					}
+#endif
 
 					if ((reg2 < -16) || (reg2 > 15))
 					{
@@ -790,6 +799,7 @@ int ResolveFixups(int sno)
 			case FU_LONG:
 				if ((w & 0x0F00) == FU_MOVEI)
 				{
+#if 0
 					address = loc + 4;
 
 					if (eattr & DEFINED)
@@ -839,27 +849,33 @@ int ResolveFixups(int sno)
 							}
 						}
 					}
+#endif
 
 					eval = ((eval >> 16) & 0x0000FFFF) | ((eval << 16) & 0xFFFF0000);
-					flags = (MLONG|MMOVEI);
+					flags = (MLONG | MMOVEI);
 				}
 				else
 					flags = MLONG;
 
 				if (!(eattr & DEFINED))
 				{
+//printf("Fixup (long): Symbol undefined. loc = $%X, long = $%X, flags = $%x\n", loc, eval, flags);
 					rmark(sno, loc, 0, flags, esym);
 				}
 				else if (tdb)
 				{
+//printf("Fixup (long): TDB = $%X. loc =$%X, long = $%X, flags = $%x\n", tdb, loc, eval, flags);
 					rmark(sno, loc, tdb, flags, NULL);
 				}
+//else
+//printf("Fixup (long): TDB = $%X. loc =$%X, long = $%X, flags = $%x\n", tdb, loc, eval, flags);
 
 				*locp++ = (char)(eval >> 24);
 				*locp++ = (char)(eval >> 16);
 				*locp++ = (char)(eval >> 8);
 				*locp = (char)eval;
 				break;
+
 			// Fixup a 3-bit "QUICK" reference in bits 9..1
 			// (range of 1..8) in a word.  Really bits 1..3 in a byte.
 			case FU_QUICK:
@@ -874,6 +890,7 @@ int ResolveFixups(int sno)
 
 				*locp |= (eval & 7) << 1;
 				break;
+
 			// Fix up 6502 funny branch
 			case FU_6BRA:
 				eval -= (loc + 1);
@@ -883,6 +900,7 @@ int ResolveFixups(int sno)
 
 				*locp = (char)eval;
 				break;
+
 			default:
 				interror(4);                                 // Bad fixup type
 				// NOTREACHED
@@ -898,3 +916,4 @@ range:
 
 	return 0;
 }
+