; Storm C Compiler
; Work2:Mesa3/Mesa-3.0/src/hash.c
	mc68030
	mc68881
	XREF	_printf
	XREF	_free
	XREF	_calloc
	XREF	_std__in
	XREF	_std__out
	XREF	_std__err

	SECTION "_NewHashTable:0",CODE


;struct HashTable *NewHashTable(void)
	XDEF	_NewHashTable
_NewHashTable
L35
	pea	1.w
	pea	$FA8.w
	jsr	_calloc
	addq.w	#$8,a7
	rts

	SECTION "_DeleteHashTable:0",CODE

	rts

;void DeleteHashTable(struct HashTable *table)
	XDEF	_DeleteHashTable
_DeleteHashTable
	movem.l	d2/a2/a3,-(a7)
	move.l	$10(a7),a3
L36
;   for (i=0;
	moveq	#0,d2
	bra.b	L41
L37
;      struct HashEntry *entry = table->Table[i];
	move.l	0(a3,d2.l*4),a0
;      while (entry) 
	bra.b	L39
L38
;	 struct HashEntry *next = entry->Next;
	move.l	$8(a0),a2
;	 free(entry);
	move.l	a0,-(a7)
	jsr	_free
	addq.w	#4,a7
;	 entry = next;
	move.l	a2,a0
L39
	cmp.w	#0,a0
	bne.b	L38
L40
	addq.l	#1,d2
L41
	cmp.l	#$3E9,d2
	blo.b	L37
L42
;   free(table);
	move.l	a3,-(a7)
	jsr	_free
	addq.w	#4,a7
	movem.l	(a7)+,d2/a2/a3
	rts

	SECTION "_HashLookup:0",CODE


;void *HashLookup(const struct HashTable *table, GLuint key)
	XDEF	_HashLookup
_HashLookup
	move.l	d2,-(a7)
	move.l	$C(a7),d1
	move.l	$8(a7),a0
L43
;   pos = key % TABLE_SIZE;
	move.l	d1,d0
	divul.l	#$3E9,d2:d0
;   entry = table->Table[pos];
	move.l	d2,d0
	move.l	0(a0,d0.l*4),a0
;   while (entry) 
	bra.b	L47
L44
;      if (entry->Key == key) 
	move.l	(a0),d0
	cmp.l	d1,d0
	bne.b	L46
L45
	move.l	4(a0),d0
	move.l	(a7)+,d2
	rts
L46
;      entry = entry->Next;
	move.l	$8(a0),a0
L47
	cmp.w	#0,a0
	bne.b	L44
L48
	moveq	#0,d0
	move.l	(a7)+,d2
	rts

	SECTION "_HashInsert:0",CODE


;void HashInsert(struct HashTable *table, GLuint key, void *data)
	XDEF	_HashInsert
_HashInsert
	movem.l	d2/d3/a2/a3,-(a7)
	movem.l	$18(a7),d2/a2
	move.l	$14(a7),a3
L49
;   if (key > table->MaxKey)
	move.l	a3,a0
	cmp.l	$FA4(a0),d2
	bls.b	L51
L50
;      table->MaxKey = key;
	move.l	a3,a0
	move.l	d2,$FA4(a0)
L51
;   pos = key % TABLE_SIZE;
	move.l	d2,d3
	divul.l	#$3E9,d0:d3
	move.l	d0,d3
;   entry = table->Table[pos];
	move.l	0(a3,d3.l*4),a0
;   while (entry) 
	bra.b	L55
L52
;      if (entry->Key == key) 
	move.l	(a0),d0
	cmp.l	d2,d0
	bne.b	L54
L53
;	 entry->Data = data;
	move.l	a2,4(a0)
	movem.l	(a7)+,d2/d3/a2/a3
	rts
L54
;      entry = entry->Next;
	move.l	$8(a0),a0
L55
	cmp.w	#0,a0
	bne.b	L52
L56
;   entry = (struct HashEntry *) calloc(sizeof(struct HashEntry), 
	pea	1.w
	pea	$C.w
	jsr	_calloc
	addq.w	#$8,a7
	move.l	d0,a0
;   entry->Key = key;
	move.l	d2,(a0)
;   entry->Data = data;
	move.l	a2,4(a0)
;   entry->Next = table->Table[pos];
	move.l	0(a3,d3.l*4),$8(a0)
;   table->Table[pos] = entry;
	move.l	a0,0(a3,d3.l*4)
	movem.l	(a7)+,d2/d3/a2/a3
	rts

	SECTION "_HashRemove:0",CODE


;void HashRemove(struct HashTable *table, GLuint key)
	XDEF	_HashRemove
_HashRemove
	movem.l	d2/a2/a3,-(a7)
	move.l	$14(a7),d2
	move.l	$10(a7),a3
L57
;   pos = key % TABLE_SIZE;
	move.l	d2,d1
	divul.l	#$3E9,d0:d1
	move.l	d0,d1
;   prev = NULL;
	sub.l	a1,a1
;   entry = table->Table[pos];
	move.l	0(a3,d1.l*4),a0
;   while (entry) 
	bra.b	L64
L58
;      if (entry->Key == key) 
	move.l	(a0),d0
	cmp.l	d2,d0
	bne.b	L63
L59
;         if (prev) 
	cmp.w	#0,a1
	beq.b	L61
L60
;            prev->Next = entry->Next;
	move.l	$8(a0),$8(a1)
	bra.b	L62
L61
;            table->Table[pos] = entry->Next;
	move.l	$8(a0),0(a3,d1.l*4)
L62
;         free(entry);
	move.l	a0,-(a7)
	jsr	_free
	addq.w	#4,a7
	movem.l	(a7)+,d2/a2/a3
	rts
L63
;      prev = entry;
	move.l	a0,a1
;      entry = entry->Next;
	move.l	$8(a0),a0
L64
	cmp.w	#0,a0
	bne.b	L58
L65
	movem.l	(a7)+,d2/a2/a3
	rts

	SECTION "_HashFirstEntry:0",CODE


;GLuint HashFirstEntry(const struct HashTable *table)
	XDEF	_HashFirstEntry
_HashFirstEntry
	move.l	4(a7),a1
L66
;   for (pos=0;
	moveq	#0,d0
	bra.b	L70
L67
;      if (table->Table[pos])
	tst.l	0(a1,d0.l*4)
	beq.b	L69
L68
	move.l	0(a1,d0.l*4),a0
	move.l	(a0),d0
	rts
L69
	addq.l	#1,d0
L70
	cmp.l	#$3E9,d0
	blo.b	L67
L71
;         return 
	moveq	#0,d0
	rts

	SECTION "_HashPrint:0",CODE


;void HashPrint(const struct HashTable *table)
	XDEF	_HashPrint
_HashPrint
	movem.l	d2/a2/a3,-(a7)
	move.l	$10(a7),a3
L73
;   for (i=0;
	moveq	#0,d2
	bra.b	L78
L74
;      struct HashEntry *entry = table->Table[i];
	move.l	0(a3,d2.l*4),a2
;      while (entry) 
	bra.b	L76
L75
;	 printf("%u %p\n", entry->Key, entry->Data);
	move.l	4(a2),-(a7)
	move.l	(a2),-(a7)
	move.l	#L72,-(a7)
	jsr	_printf
	add.w	#$C,a7
;	 entry = entry->Next;
	move.l	$8(a2),a2
L76
	cmp.w	#0,a2
	bne.b	L75
L77
	addq.l	#1,d2
L78
	cmp.l	#$3E9,d2
	blo.b	L74
L79
	movem.l	(a7)+,d2/a2/a3
	rts

L72
	dc.b	'%u %p',$A,0

	SECTION "_HashFindFreeKeyBlock:0",CODE


;GLuint HashFindFreeKeyBlock(const struct HashTable *table, GLuint nu
	XDEF	_HashFindFreeKeyBlock
_HashFindFreeKeyBlock
	movem.l	d2-d6/a2,-(a7)
	move.l	$20(a7),d6
	move.l	$1C(a7),a2
L80
;   GLuint maxKey = ~((GLuint) 0);
	moveq	#-1,d5
;   if (maxKey - numKeys > table->MaxKey) 
	move.l	d5,d1
	sub.l	d6,d1
	cmp.l	$FA4(a2),d1
	bls.b	L82
L81
	move.l	$FA4(a2),d0
	addq.l	#1,d0
	movem.l	(a7)+,d2-d6/a2
	rts
L82
;      GLuint freeCount = 0;
	moveq	#0,d3
;      GLuint freeStart = 0;
	moveq	#0,d4
;      for (key=0;
	moveq	#0,d2
	bra.b	L88
L83
;	 if (HashLookup(table, key)) 
	move.l	d2,-(a7)
	move.l	a2,-(a7)
	jsr	_HashLookup
	addq.w	#$8,a7
	tst.l	d0
	beq.b	L85
L84
;	    freeCount = 0;
	moveq	#0,d3
;	    freeStart = key+1;
	move.l	d2,d4
	addq.l	#1,d4
	bra.b	L87
L85
;	    freeCount++;
	addq.l	#1,d3
;	    if (freeCount == numKeys) 
	cmp.l	d6,d3
	bne.b	L87
L86
	move.l	d4,d0
	movem.l	(a7)+,d2-d6/a2
	rts
L87
	addq.l	#1,d2
L88
	cmp.l	d5,d2
	bne.b	L83
L89
;	       return 
	moveq	#0,d0
	movem.l	(a7)+,d2-d6/a2
	rts

	END