From baebdbe0962bb38d09518c089ab9d8632ef906f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carl-Henrik=20Sk=C3=A5rstedt?= <cskarstedt@gmail.com>
Date: Sat, 24 Dec 2016 13:23:01 -0800
Subject: [PATCH] Label Pool changes

Pool are extended to:
* A pool label can be any size by using POOL <label>.<size> where <size>
is a decimal number
* A pool can define a pool within itself <pool> pool <name> <size> where
<pool> is the name of a pool that would fit another pool and <name> is
the name of the new pool and <size> is the size of the new pool
* pool labels are local if they are preceeded by . or ! or $ or @
* pool labels can be global
---
 x65.cpp | 159 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 93 insertions(+), 66 deletions(-)

diff --git a/x65.cpp b/x65.cpp
index e6b3e45..23ad4fa 100644
--- a/x65.cpp
+++ b/x65.cpp
@@ -55,8 +55,8 @@
 #define MAX_EVAL_OPER 64
 
 // Max capacity of each label pool
-#define MAX_POOL_RANGES 4
-#define MAX_POOL_BYTES 128
+#define MAX_POOL_RANGES 1
+#define MAX_POOL_BYTES 255
 
 // Max number of exported binary files from a single source
 #define MAX_EXPORT_FILES 64
@@ -878,6 +878,7 @@ static const strref import_c64("c64");
 static const strref import_text("text");
 static const strref import_object("object");
 static const strref import_symbols("symbols");
+static const strref pool_subpool("pool");
 static const char* aAddrModeFmt[] = {
 	"%s ($%02x,x)",			// 00
 	"%s $%02x",				// 01
@@ -1344,13 +1345,16 @@ typedef struct sLocalLabelRecord {
 	bool scope_reserve;		// not released for global label, only scope	
 } LocalLabelRecord;
 
+
+
+
 // Label pools allows C like stack frame label allocation
 typedef struct sLabelPool {
 	strref pool_name;
 	int16_t numRanges;		// normally 1 range, support multiple for ease of use
 	int16_t scopeDepth;		// Required for scope closure cleanup
 	uint16_t ranges[MAX_POOL_RANGES*2];		// 2 shorts per range
-	uint32_t usedMap[(MAX_POOL_BYTES+15)>>4];	// 2 bits per byte to store byte count of label
+	uint8_t allocated[MAX_POOL_BYTES][2];	// 1 byte offset, 1 byte length, in-order array
 	StatusCode Reserve(int numBytes, uint32_t &addr);
 	StatusCode Release(uint32_t addr);
 } LabelPool;
@@ -3940,32 +3944,65 @@ StatusCode Asm::AddLabelPool(strref name, strref args)
 	pool.pool_name = name;
 	pool.numRanges = (int16_t)(ranges>>1);
 	pool.scopeDepth = (int16_t)scope_depth;
+	memset( pool.allocated, 0, sizeof( pool.allocated ) );
 
-	memset(pool.usedMap, 0, sizeof(uint32_t) * num32);
 	for (int r = 0; r<ranges; r++)
 		pool.ranges[r] = aRng[r];
 
 	labelPools.insert(ins, pool_hash);
 	LabelPool &poolValue = labelPools.getValue(ins);
-
 	poolValue = pool;
 
 	return STATUS_OK;
 }
 
+
 StatusCode Asm::AssignPoolLabel(LabelPool &pool, strref label)
 {
+	// declaring a pool within another pool?
+	if (pool_subpool.is_prefix_word(label)) {
+		label += pool_subpool.get_len();
+		label.skip_whitespace();
+		strref size = label;
+		label = size.split_label();
+		if (strref::is_number(size.get_first())) {
+			uint32_t bytes = (uint32_t)size.atoi();
+			if (!bytes) { return ERROR_POOL_RANGE_EXPRESSION_EVAL; }
+			if (!GetLabelPool(label)) {
+				uint32_t addr;
+				StatusCode error = pool.Reserve(bytes, addr);
+				if( error == STATUS_OK ) {
+					uint32_t pool_hash = label.fnv1a();
+					uint32_t ins = FindLabelIndex(pool_hash, labelPools.getKeys(), labelPools.count());
+					labelPools.insert(ins, pool_hash);
+					LabelPool &subPool = labelPools.getValue(ins);
+					subPool.pool_name = label;
+					subPool.numRanges = 1;
+					subPool.scopeDepth = (int16_t)scope_depth;
+					memset( subPool.allocated, 0, sizeof( subPool.allocated ) );
+					subPool.ranges[ 0 ] = (uint16_t)addr;
+					subPool.ranges[ 1 ] = uint16_t(addr+bytes);
+				}
+				return error;
+			} else { return ERROR_LABEL_POOL_REDECLARATION; }
+		}
+		return ERROR_POOL_RANGE_EXPRESSION_EVAL;
+	}
 	strref type = label;
 	int bytes = 1;
 	int sz = label.find_at( '.', 1 );
 	if (sz > 0) {
 		label = type.split( sz );
 		++type;
-		switch (strref::tolower(type.get_first())) {
-			case 'l': bytes = 4; break;
-			case 't': bytes = 3; break;
-			case 'd':
-			case 'w': bytes = 2; break;
+		if (strref::is_number(type.get_first())) {
+			bytes = (int)type.atoi();
+		} else {
+			switch (strref::tolower(type.get_first())) {
+				case 'l': bytes = 4; break;
+				case 't': bytes = 3; break;
+				case 'd':
+				case 'w': bytes = 2; break;
+			}
 		}
 	}
 	if (GetLabel(label)) { return ERROR_POOL_LABEL_ALREADY_DEFINED; }
@@ -3973,9 +4010,7 @@ StatusCode Asm::AssignPoolLabel(LabelPool &pool, strref label)
 	StatusCode error = pool.Reserve(bytes, addr);
 	if (error != STATUS_OK)
 		return error;
-
 	Label *pLabel = AddLabel(label.fnv1a());
-
 	pLabel->label_name = label;
 	pLabel->pool_name = pool.pool_name;
 	pLabel->evaluated = true;
@@ -3996,67 +4031,59 @@ StatusCode Asm::AssignPoolLabel(LabelPool &pool, strref label)
 // Request a label from a pool
 StatusCode LabelPool::Reserve(int numBytes, uint32_t &ret_addr)
 {
-	uint32_t *map = usedMap;
-	uint16_t *pRanges = ranges;
-	for (int r = 0; r<numRanges; r++) {
-		int sequence = 0;
-		uint32_t a0 = *pRanges++, a1 = *pRanges++;
-		uint32_t addr = a1-1, *range_map = map;
-		while (addr>=a0 && sequence<numBytes) {
-			uint32_t chk = *map++, m = 3;
-			while (m && addr >= a0) {
-				if ((m & chk)==0) {
-					sequence++;
-					if (sequence == numBytes)
-						break;
-				} else
-					sequence = 0;
-				--addr;
-				m <<= 2;
-			}
-		}
-		if (sequence == numBytes) {
-			uint32_t index = (a1-addr-numBytes);
-			uint32_t *addr_map = range_map + (index>>4);
-			uint32_t m = numBytes << (index << 1);
-			for (int b = 0; b<numBytes; b++) {
-				*addr_map |= m;
-				uint32_t _m = m << 2;
-				if (!_m) { m >>= 30; addr_map++; } else { m = _m; }
-			}
-			ret_addr = addr;
-			return STATUS_OK;
+	uint8_t num8 = ( uint8_t )numBytes;
+	uint32_t bestSlot = 0;
+	uint32_t bestSize = allocated[0][1] ? allocated[0][0] : (uint32_t)(ranges[1]-ranges[0]);
+	uint8_t bestEnd = (uint8_t)bestSize;
+	uint8_t offs = 0;
+	uint32_t slot = 0;
+	uint32_t last = 0;
+	for(;;)
+	{
+		if( allocated[ slot ][ 1 ] == 0 ) { last = slot; break; }
+		uint8_t end = allocated[ slot ][ 0 ];
+		uint8_t size = end - offs;
+		if( size >= num8 )
+		{
+			if( size < bestSize ) { bestSlot = slot; bestEnd = end; }
 		}
+		offs = allocated[ slot ][ 0 ] + allocated[ slot ][ 1 ];
+		++slot;
+		if( slot == MAX_POOL_BYTES ) { last = slot;  break; }
 	}
-	return ERROR_OUT_OF_LABELS_IN_POOL;
+	if( last == MAX_POOL_BYTES || bestSize < num8 ) { return ERROR_OUT_OF_LABELS_IN_POOL; }
+
+	for( uint32_t m = last; m > bestSlot; --m )
+	{
+		allocated[ m ][ 0 ] = allocated[ m - 1 ][ 0 ];
+		allocated[ m ][ 1 ] = allocated[ m - 1 ][ 1 ];
+	}
+	allocated[ bestSlot ][0] = bestEnd - num8;
+	allocated[ bestSlot ][ 1 ] = num8;
+	ret_addr = ranges[ 0 ] + allocated[ bestSlot ][ 0 ];
+	return STATUS_OK;
 }
 
 // Release a label from a pool (at scope closure)
 StatusCode LabelPool::Release(uint32_t addr) {
-	uint32_t *map = usedMap;
-	uint16_t *pRanges = ranges;
-	for (int r = 0; r<numRanges; r++) {
-		uint16_t a0 = *pRanges++, a1 = *pRanges++;
-		if (addr>=a0 && addr<a1) {
-			uint32_t index = (a1-addr-1);
-			map += index>>4;
-			index &= 0xf;
-			uint32_t u = *map, m = 3 << (index << 1);
-			uint32_t b = u & m, bytes = b >> (index << 1);
-			if (bytes) {
-				for (uint32_t f = 0; f<bytes; f++) {
-					u &= ~m;
-					uint32_t _m = m>>2;
-					if (!_m) { m <<= 30; *map-- = u; } else { m = _m; }
-				}
-				*map = u;
-				return STATUS_OK;
-			} else
-				return ERROR_INTERNAL_LABEL_POOL_ERROR;
-		} else
-			map += (a1-a0+15)>>4;
+	uint32_t offs = addr - ranges[ 0 ];
+	if( offs > uint32_t(ranges[ 1 ]-ranges[0]) ) { return ERROR_INTERNAL_LABEL_POOL_ERROR; }
+	uint32_t slot = 0;
+	for(;;)
+	{
+		if( allocated[ slot ][ 1 ] == 0 ) { break; }
+		if( allocated[ slot ][ 0 ] == offs ) {
+			for(;;) {
+				allocated[ slot ][ 1 ] = 0;
+				if( slot == 0x100 || !allocated[ slot + 1 ][ 1 ] ) { break; }
+				allocated[ slot ][ 0 ] = allocated[ slot + 1 ][ 0 ];
+				allocated[ slot ][ 1 ] = allocated[ slot + 1 ][ 1 ];
+				++slot;
+			}
+			return STATUS_OK;
+		}
 	}
-	return STATUS_OK;
+	return ERROR_INTERNAL_LABEL_POOL_ERROR;
 }
 
 // Check if a label is marked as an xdef