***	PROFILE  ---  68020 version
***
***	Copyright © 1990  Glen McDiarmid
***
***	The source for this file is supplied to purchasers of Macro68
***	under the following conditions:
***	
***	1) The executable and the source for it may NOT be distributed in
***	   any manner whatsoever.
***						DigiSoft

**	Tabstops : variable
**	Assemble with Macro68
**	Requires resident maclib > AllSyms.mac (or equivilent includes)


	if1
		exeobj
		errfile	'ram:assem.output'
		MC68020
		super
		strict
		default	_adrbasedisp,_word
		default	_pcbasedisp,_word
		default	_outerdisp,_word
		default	_branch,_word
		default	_debug,prof,code
	endc

	objfile	'ram:profile_68020'


HUNK_UNIT	equ	999
HUNK_NAME	equ	1000
HUNK_CODE	equ	1001
HUNK_DATA	equ	1002
HUNK_BSS	equ	1003
HUNK_RELOC32	equ	1004
HUNK_RELOC16	equ	1005
HUNK_RELOC8	equ	1006
HUNK_EXT	equ	1007
HUNK_SYMBOL	equ	1008
HUNK_DEBUG	equ	1009
HUNK_END	equ	1010
HUNK_HEADER	equ	1011

**********************************************************************
ProgStart	jmp	(RealProgStart,PC)

	doscmd	'date >ram:date.bin'
	incbin	'ram:date.bin'
	even
	execute	'delete ram:date.bin'

RealProgStart:
	lea	(BssStart,PC),A1
	move.w	#(((BssEnd-BssStart)+3)/4)-1,D1
	moveq	#0,D2
2$	move.l	D2,(A1)+
	dbra	D1,2$

	move.l	SP,(SaveSP)
	move.w	#-1,(jsrtrap)
	clr.b	(-1,A0,D0.W)
	move.l	A0,(SaveA0)
	move.l	D0,(SaveD0)
	movea.l	(4),A6
	lea	(DosName,PC),A1
	moveq	#0,D0
	jsr	(_LVOOpenLibrary,A6)
	move.l	D0,(Dos_Base)
	movea.l	(4),A6
	movea.l	(ThisTask,A6),A0
	move.l	A0,(OurTask)
	move.l	($68),D0
	cmpi.l	#$FFFFFF,D0
	bhi	ErrorExit1
	cmpi.l	#$FBFFFF,D0
	bls	ErrorExit1
	move.l	D0,(poke1)
	movea.l	(4),A6
	movea.l	(SaveA0,PC),A0
	move.l	(SaveD0,PC),D0
	bsr	FindWordStart
	lea	(RealProgName,PC),A1
	moveq	#0,D1
1$	move.b	(A0)+,D0
	cmpi.b	#' ',D0
	bls.b	FoundNameEnd
	addq.l	#1,D1
	move.b	D0,(A1)+
	bra.b	1$

FoundNameEnd	subq.l	#1,A0
	clr.b	(A1)+
	move.l	D1,(InputFilenameLength)
	bsr	FindWordStart2
	move.l	A0,D1
	lea	(ProgParms,PC),A1
	clr.l	(InputParmsLength)
	move.b	(A0),D2	; get fence
	beq.b	FoundParmsEnd
	addq.l	#1,A0
2$	cmpi.b	#'A',D2
	bcc	ErrorExit18
1$	move.b	(A0)+,D0
	cmp.b	D0,D2
	beq.b	FoundParmsEnd
	addq.l	#1,(InputParmsLength)
	move.b	D0,(A1)+
	bne.b	1$
	subq.l	#1,A1
	subq.l	#1,(InputParmsLength)
FoundParmsEnd	move.b	#10,(A1)
	addq.l	#1,(InputParmsLength)
	move.l	A0,(OldCommandPointer)
	bsr	FindWordStart2
	lea	(DefaultWithFile,PC),A1
	beq.b	2$
	cmpi.b	#'-',(A0)+
	bne	ErrorExit2
	moveq	#$5F,D0
	and.b	(A0)+,D0
	cmpi.b	#'W',D0
	beq.b	1$
	subq.l	#2,A0
2$	move.l	A1,D1
	bra.b	JustWith

1$	cmpi.b	#' ',(A0)
	bls.b	PLBase2
	move.l	A0,(OldCommandPointer)
	move.l	A1,-(SP)
	bsr	SetNameJoin
	move.l	(SP)+,D1
JustWith	move.l	D1,D3
	move.l	#MODE_OLDFILE,D2
	move.l	A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOOpen,A6)
	movea.l	(SP)+,A6
	move.l	D0,(WithFilehandle)
	bne.b	1$
	cmpi.l	#DefaultWithFile,D3
	bne	ErrorExit20
1$	move.l	D0,D1
	lea	(WithFileBuf,PC),A0
	move.l	A0,D2
	move.l	#$3FFF,D3
	move.l	A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVORead,A6)
	movea.l	(SP)+,A6
	movea.l	D2,A0
	clr.b	(0,A0,D0.W)
	tst.l	D0
	beq	ErrorExit21
	st	(WithFlag)
; Remainder of command line is parameters for us!!

PLBase2	bsr	FindWordStart2
	bne.b	1$
	tst.b	(WithFlag)
	beq.b	NoParms
	movea.l	(OldCommandPointer,PC),A0
	clr.b	(WithFlag)
	bra.b	PLBase2

1$	cmpi.b	#'-',(A0)+
	bne	ErrorExit2
PLBase	bsr	FindWordStart2
	lea	(ParameterList,PC),A1
	move.b	(A0)+,D0
	beq.b	NoParms
CheckNextParm	move.w	(A1)+,D1
	beq	ErrorExit2
	move.w	(A1)+,D2
	cmp.b	D1,D0
	beq.b	FoundRightParm
	lsr.w	#8,D1
	cmp.b	D1,D0
	bne.b	CheckNextParm
FoundRightParm	pea	(PLBase2,PC)
	jmp	(PLBase,PC,D2.W)

NoParms	movea.l	(OurTask,PC),A0
	movea.l	(pr_CLI,A0),A0
	adda.l	A0,A0
	adda.l	A0,A0
	movea.l	(cli_CommandName,A0),A1
	adda.l	A1,A1
	adda.l	A1,A1
	move.b	(InputFilenameLength+3,PC),(A1)+
	lea	(RealProgName,PC),A0
1$	move.b	(A0)+,(A1)+
	bne.b	1$
3$	move.l	A1,D0
	andi.b	#3,D0
	beq.b	2$
	clr.b	(A1)+
	bra.b	3$

2$	lea	(ProgParms,PC),A0
	move.b	(InputParmsLength+3,PC),(A1)+
	move.l	A1,(SaveA0)
4$	move.b	(A0)+,(A1)+
	bne.b	4$
	clr.b	(A1)+
	clr.b	(A1)+
	clr.b	(A1)+
	lea	(RealSourceName,PC),A0
	tst.b	(A0)
	bne.b	5$
	lea	(RealProgName,PC),A0
5$	lea	(OutputFileName,PC),A1
	tst.b	(A1)
	bne.b	Pr3Label1
CopyMemLoop	move.b	(A0)+,(A1)+
	bne.b	CopyMemLoop
	subq.l	#1,A1
	movea.l	A1,A0
	moveq	#$5F,D0
	and.b	-(A0),D0
	cmpi.b	#'M',D0
	bne.b	1$
	moveq	#$5F,D0
	and.b	-(A0),D0
	cmpi.b	#'S',D0
	bne.b	1$
	moveq	#$5F,D0
	and.b	-(A0),D0
	cmpi.b	#'A',D0
	bne.b	1$
	moveq	#$5F,D0
	and.b	-(A0),D0
	cmpi.b	#'.',D0
	bne.b	1$
	movea.l	A0,A1
1$	move.b	#'.',(A1)+
	move.b	#'p',(A1)+
	move.b	#'r',(A1)+
	move.b	#'f',(A1)+
	clr.b	(A1)+
Pr3Label1	lea	(RealProgName,PC),A0
	move.l	A0,D1
	move.l	A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOLoadSeg,A6)
	movea.l	(SP)+,A6
	move.l	D0,(SegStart)
	beq	ErrorExit3
	lea	(4,D0.L*4),A0
	move.l	A0,(hunkstart)
	subq.l	#8,A0
	adda.l	(A0),A0
	move.l	A0,(hunkend)
***********************************************************************************
	lea	(RealProgName,PC),A0
	move.l	A0,D1
	move.l	#MODE_OLDFILE,D2
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOOpen,A6)
	move.l	D0,(InputFilehandle)
	beq	ErrorExit9
	moveq	#0,D2
	moveq	#OFFSET_END,D3
	jsr	(_LVOSeek,A6)
	move.l	(InputFilehandle,PC),D1
	moveq	#0,D2
	moveq	#OFFSET_BEGINNING,D3
	jsr	(_LVOSeek,A6)
	move.l	D0,(InputFileSize)
	beq	ErrorExit7
	addq.l	#4,D0
	moveq	#MEMF_PUBLIC,D1
	movea.l	(4),A6
	jsr	(_LVOAllocMem,A6)
	move.l	D0,(BigInputBuf)
	beq	ErrorExit4
	move.l	(InputFilehandle,PC),D1
	move.l	D0,D2
	move.l	(InputFileSize,PC),D3
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVORead,A6)	; read executable
	cmp.l	D0,D3
	bne	ErrorExit10
finddebuglvos	movea.l	D2,A2
	move.l	(InputFileSize,PC),D0
	clr.l	(A2,D0.L)
	cmpi.l	#HUNK_HEADER,(A2)+
	bne	ErrorExit11
2$	move.l	(A2)+,D0
	beq.b	1$
	lsl.l	#2,D0
	adda.l	D0,A2
	bra.b	2$
1$	addq.l	#4,A2
	move.l	(A2)+,D0
	move.l	(A2),D1
	sub.l	D0,D1
	lea	(8,A2,D1.L*4),A2
	move.l	(A2)+,D0
	and.l	#$3FFFFFFF,D0
	cmpi.l	#HUNK_CODE,D0
	beq.b	7$
	cmpi.l	#HUNK_DATA,D0
	bne	ErrorExit11
7$	move.l	(A2),D0
	lea	(4,A2,D0.L*4),A2
.hunksearchloop	move.l	(A2)+,D0
	cmpi.l	#HUNK_RELOC32,D0
	beq.b	3$
	cmpi.l	#HUNK_SYMBOL,D0
	bne.b	.notsymbolstuff
3$	move.l	(A2)+,D0
	beq.b	.hunksearchloop
	lea	(4,A2,D0.L*4),A2
	bra.b	3$
.notsymbolstuff	cmpi.l	#HUNK_DEBUG,D0
	bne	ErrorExit16
	move.l	(A2)+,D0
	cmpi.l	#1,(A2)+
	bne	ErrorExit17
	cmpi.l	#'PROF',(A2)+
	beq.b	8$
	lea	(-8,A2,D0.L*4),A2
	bra	.hunksearchloop

8$	move.l	(A2)+,D0
	lea	(A2,D0.L*4),A1
	move.l	A1,(debughunklimit)
	move.l	(A2)+,D0
	lsl.l	#2,D0
	lea	(RealSourceName,PC),A1
	tst.b	(A1)
	beq.b	.newsourcename
	adda.l	D0,A2
	bra.b	.sourcenameread

4$	move.b	(A2)+,(A1)+
.newsourcename	dbra	D0,4$
	subi.l	#$10000,D0
	bpl.b	4$
	clr.b	(A1)+
.sourcenameread	cmpa.l	(debughunklimit),A2
	bcc	finddebuglvosexit
	cmpi.l	#1,(A2)+
	bne	ErrorExit17
	move.l	(A2)+,D2
	move.l	(A2)+,D3
	lea	(codedebugptr,PC),A3
	cmpi.l	#'CODE',D2
	beq.b	.gotcorrectptr
	lea	(datadebugptr,PC),A3
	cmpi.l	#'DATA',D2
	beq.b	.gotcorrectptr
	lea	(_lvodebugptr,PC),A3
	cmpi.l	#'_LVO',D2
	bne	ErrorExit17
.gotcorrectptr	tst.l	(A3)
	bne	ErrorExit17
	move.l	D3,D0
	lsl.l	#2,D0
	addq.l	#8,D0
	move.l	D0,(4,A3)
	moveq	#MEMF_PUBLIC,D1
	movea.l	(4),A6
	jsr	(_LVOAllocMem,A6)
	move.l	D0,(A3)+
	beq	ErrorExit4
	movea.l	D0,A0
	bra.b	6$

5$	move.l	(A2)+,(A0)+
6$	dbra	D3,5$
	subi.l	#$10000,D3
	bpl.b	5$
	move.l	#-1,(A0)+
	move.l	#-1,(A0)
	bra	.sourcenameread

finddebuglvosexit	move.l	(BigInputBuf,PC),D0
	beq.b	1$
	movea.l	D0,A1
	move.l	(InputFileSize,PC),D0
	addq.l	#4,D0
	movea.l	(4),A6
	jsr	(_LVOFreeMem,A6)
1$	clr.l	(BigInputBuf)
***********************************************************************************
	move.l	(SegStart,PC),D0
	lsl.l	#2,D0
	movem.l	D0-D7/A0-A6,-(SP)
	moveq	#40,D1
timecountloop	movea.l	D0,A0
	move.l	(A0),D0
	beq.b	timecountdone
	lsl.l	#2,D0
	addq.l	#4,D1
	bra.b	timecountloop
timecountdone	cmpi.l	#$8000,D1
	bcs.b	withinrange
	move.w	#$8000,D1
withinrange	cmp.w	(Interval,PC),D1
	bls.b	highenough
	move.w	D1,(Interval)
highenough	movem.l	(SP)+,D0-D7/A0-A6
	movem.l	D0/D2,-(SP)
	tst.b	(oddflag)
	beq.b	nooddstuff
	move.l	($44),(Line1111Code)
	move.l	#JsrLineCode,($44)
	move.l	#callers,(callerspointer)
nooddstuff	movem.l	D0-D7/A0-A6,-(SP)
	move.l	(SegStart,PC),D0
	lsl.l	#2,D0
	movea.l	D0,A2
	move.l	(-4,A2),D0
	subq.l	#8,D0
	lsl.l	#2,D0
	move.l	D0,(BlockSize)
	lsr.l	#4,D0
	addq.l	#1,D0
	move.l	#MEMF_CLEAR,D1
	movea.l	(4),A6
	jsr	(_LVOAllocMem,A6)
	move.l	D0,(_BigBlock2)
	beq	ErrorExit4
	move.l	(BlockSize,PC),D0
	addq.l	#8,D0
	move.l	#MEMF_CLEAR,D1
	jsr	(_LVOAllocMem,A6)
	move.l	D0,(_BigBlock)
	beq	ErrorExit4
	movem.l	(SP),D0-D7/A0-A6
	tst.b	(BranchFlag,PC)
	bne	2$
	move.l	($28),(Line1010Code)
	move.l	#Line1010Handler,($28)
	move.l	(12),(OddAddressCode)
	move.l	#OddHandler,(12)
	move.l	(codedebugptr,PC),D1
	beq	6$
	movea.l	(_BigBlock2,PC),A2
	movea.l	D1,A0
	movea.l	D0,A1
	addq.l	#4,A1	; start of first hunk
5$	addq.l	#4,A0
	move.l	(A0)+,D0	; get next code ptr
	bmi	2$
	lea	(A1,D0.L),A3
	move.w	(A3),D1
	andi.w	#%1111000000000000,D1
	cmp.w	#%0110000000000000,D1
	beq.b	10$
	move.w	(A3),D1
	cmp.w	#$4E75,D1
	beq.b	11$
	andi.w	#%1111000011111000,D1
	cmp.w	#%0101000011001000,D1	;DBcc?
	bne.b	5$
	move.l	D0,D1
	moveq	#0,D3
	lsr.l	#2,D1
	bcc.b	12$
	moveq	#4,D3
12$	bfextu	(A3){4:4},D2	;get condition code
	sne	D2
	bfins	D2,(A2,D1.L){D3:4}
11$	moveq	#%1010,D2
	bfins	D2,(A3){0:4}	; make line 1010 emulator
	bra.b	5$

10$	move.l	D0,D1
	moveq	#0,D3
	lsr.l	#2,D1
	bcc.b	8$
	moveq	#4,D3
8$	bfextu	(A3){4:4},D2	;get condition code
	bfclr	(A3){4:4}	; make it BRA
	bfins	D2,(A2,D1.L){D3:4}
	move.w	(A3),D1
	tst.b	D1
	beq.b	.wordbranch
	addq.b	#1,D1
	bne.b	.bytebranch
.longbranch	bset	#0,(5,A3)
	bra.b	5$

.wordbranch	bset	#0,(3,A3)
	bra.b	5$

.bytebranch	addq.b	#1,D1
	beq.b	5$	; don't change to long branch!
	ori.w	#1,(A3)
	bra	5$

6$	movem.l	(SP)+,D0-D7/A0-A6
	bra	ErrorExit23

4$	movem.l	(SP)+,D0-D7/A0-A6
	bra	7$

2$	movem.l	(SP)+,D0-D7/A0-A6
	tst.b	(libraryflag,PC)
	beq	7$
	movem.l	D0-D7/A0-A6,-(SP)
	movea.l	(OurTask,PC),A0
	move.l	#TrapHandler,(TC_TRAPCODE,A0)
	moveq	#-1,D0
	move.w	D0,(jsrtrap)
	movea.l	(4),A6
	jsr	(_LVOAllocTrap,A6)
	tst.l	D0
	bmi	ErrorExit22
	move.l	D0,D1
	ori.w	#%0100111001000000,D1
	move.w	D1,(jsrtrap)
	lsl.b	#2,D0
	addi.l	#$80,D0	; address of trap
	move.l	D0,(trapaddress)
	movea.l	D0,A0
	bsr	disable
	move.l	(A0),(oldtrap)
	move.l	#newtrap,(A0)
	bsr	enable
	movem.l	(SP)+,D0-D7/A0-A6
	movea.l	D0,A0
	addq.l	#4,A0	;point to start of hunk
	move.l	(_lvodebugptr,PC),D1
	beq.b	7$
	movea.l	D1,A1
	bra.b	1$
9$	cmpi.w	#$4EAE,(A0,D0.L)
	beq.b	3$
	bclr	#7,(2,A0,D0.L)
3$	move.w	(jsrtrap,PC),(A0,D0.L)
1$	addq.l	#4,A1	; skip line number
	move.l	(A1)+,D0
	bpl.b	9$
7$	movem.l	(SP)+,D0/D2
	moveq	#0,D1	; total size
Pr3Label2	movea.l	(_BigBlock,PC),A0
	adda.l	(BlockSize,PC),A0
	move.l	#-1,(A0)+
	move.l	#-1,(A0)
	move.l	(SP)+,(ReturnAddress)
	lea	(MyReturn,PC),A0
	move.l	A0,D0
	move.l	D0,-(SP)
	move.l	(SegStart,PC),D0
	lsl.l	#2,D0
	addq.l	#4,D0
	move.l	D0,-(SP)
	bsr	disable
	lea	(lev3int,PC),A0
	move.l	A0,($68)
	tst.b	(libraryflag)
	bne.b	1$
	movea.l	(trapaddress,PC),A0
	move.l	(oldtrap,PC),D0
	beq.b	1$
	move.l	D0,(A0)
1$	bsr	enable
	movea.l	(4),A6
	moveq	#0,D0
	lea	(CiaName,PC),A1
	jsr	(_LVOOpenResource,A6)
	move.l	D0,(Cia_Base)
	movea.l	D0,A6
	lea	(intstructure,PC),A1
	moveq	#0,D0	; interrupt bit number
	jsr	(_LVOAddICRVector,A6)
	move.w	(Interval,PC),D0
	move.b	D0,($BFE401)	; low micros
	lsr.w	#8,D0
	move.b	D0,($BFE501)	; high micros
	moveq	#1,D0
	jsr	(_LVOSetICR,A6)
	movem.l	(SaveAllRegs,PC),D1-D7/A1-A6
	movea.l	(SaveA0,PC),A0
	move.l	(InputParmsLength,PC),D0
	bne.b	2$
	moveq	#1,D0
	move.b	#10,(A0)
	clr.b	(1,A0)
2$	tst.b	(BranchFlag,PC)
	beq.b	3$
	move.b	#$99,($BFEE01)
3$	rts

MyReturn	clr.b	(TimerGo)
	tst.b	(oddflag)
	beq.b	1$
	tst.b	(BranchFlag,PC)
	beq.b	1$
	move.l	(Line1111Code),($44)
1$	tst.b	(BranchFlag,PC)
	bne.b	3$
	move.l	(RealTotalTicks,PC),(ThisTaskTicks)
3$	move.l	(Cia_Base,PC),D0
	movea.l	D0,A6
	moveq	#1,D0
	jsr	(_LVOAbleICR,A6)	; cancel interrupts
	lea	(intstructure,PC),A1
	moveq	#0,D0
	jsr	(_LVORemICRVector,A6)
	clr.l	(Cia_Base)
	move.l	(Line1010Code,PC),D0
	beq.b	4$
	move.l	D0,($28)
4$	move.l	(OddAddressCode,PC),D0
	beq.b	2$
	move.l	D0,(12)
	clr.l	(OddAddressCode)
2$	move.l	(ReturnAddress,PC),D0
	move.l	D0,-(SP)
	move.l	(poke1,PC),D0
	bsr	disable
	move.l	D0,($68)
	movea.l	(trapaddress,PC),A0
	move.l	(oldtrap,PC),(A0)
	bsr	enable
skipprofile	movea.l	(_BigBlock,PC),A0
	move.l	(BlockSize,PC),D5
	lsr.l	#2,D5
	subq.l	#1,D5
	moveq	#0,D0
NextConv	add.l	(A0)+,D0
	dbra	D5,NextConv
	subi.l	#$10000,D5
	bcc.b	NextConv
	move.l	D0,(TotalTicks)
	tst.b	(BranchFlag,PC)
	bne.b	ConvAllDone
	move.l	D0,(RealTotalTicks)
	move.l	D0,(ThisTaskTicks)
ConvAllDone:
**********************************************************************
	move.l	(SegStart,PC),D1
	beq.b	1$
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOUnLoadSeg,A6)
	clr.l	(SegStart)
1$	move.l	(InputFilehandle,PC),D1
	beq.b	2$
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOClose,A6)
	clr.l	(InputFilehandle)
2$	lea	(RealSourceName,PC),A0
	tst.b	(A0)
	beq	ErrorExit13
	move.l	A0,D1
	move.l	#MODE_OLDFILE,D2
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOOpen,A6)
	move.l	D0,(RealSourceHandle)
	beq	ErrorExit14
	move.l	D0,D1
	moveq	#0,D2
	moveq	#OFFSET_END,D3
	jsr	(_LVOSeek,A6)
	move.l	(RealSourceHandle,PC),D1
	moveq	#0,D2
	moveq	#OFFSET_BEGINNING,D3
	jsr	(_LVOSeek,A6)
	move.l	D0,(RealSourceSize)
	beq	ErrorExit24
	move.l	D0,D1
	lsr.l	#1,D1
	add.l	D1,D0
	move.l	#MEMF_PUBLIC!MEMF_CLEAR,D1
	movea.l	(4),A6
	jsr	(_LVOAllocMem,A6)
	move.l	D0,(RealSourceBuf)
	beq	ErrorExit4
	movea.l	D0,A5	; output pointer
	move.l	D0,D2
	move.l	(RealSourceSize,PC),D3
	move.l	D3,D0
	lsr.l	#1,D0
	subq.l	#1,D0
	add.l	D0,D2
	movea.l	D2,A4	; input pointer
	move.l	(RealSourceHandle,PC),D1
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVORead,A6)
	cmp.l	D0,D3
	bne	ErrorExit25
	movea.l	(hunkstart,PC),A1
	movea.l	(_BigBlock2,PC),A2
	movea.l	(_BigBlock,PC),A3
	movea.l	(codedebugptr,PC),A6
	move.l	(TotalTicks,PC),D2
	moveq	#0,D4
	moveq	#0,D7	; line number
;D2  = TotalTicks
;D3  = extra info flag 0 = no info, -1 - info already
;D4  = offset into hunk
;D5  = total unsuccessful branches
;D6  = total normal/successful branches
;D7  = line number
;A1 -> hunkstart (to check for DBRA instructions)
;A2 -> _BigBlock2 (condition codes)
;A3 -> totals buffer
;A4 -> input buffer
;A5 -> output buffer
;A6 -> line number/offset table
mainloop	moveq	#0,D3
	moveq	#0,D5
	moveq	#0,D6
	addq.l	#1,D7
	move.b	(A4)+,D0
	move.b	D0,(A5)+
	beq	sourceexhausted
	cmp.b	#';',D0
	bne.b	1$
	move.b	(A4)+,D0
	move.b	D0,(A5)+
	cmp.b	#'_',D0
	bne.b	1$
	move.b	(A4)+,D0
	move.b	D0,(A5)+
	cmp.b	#'[',D0
	bne.b	1$
	cmpi.b	#']',(A4)
	bne.b	3$
	cmpi.b	#10,(1,A4)
	bne.b	3$
	addq.l	#2,A4
	bra.b	5$

3$	tst.b	(StripTotalsFlag,PC)
	bne.b	2$
4$	cmpi.b	#10,(A4)+
	bne.b	4$
5$	move.l	(TotalTicks,PC),D0
	bsr	ShowDecimal
	tst.b	(BranchFlag,PC)
	beq.b	22$
	move.b	#'/',(A5)+
	move.l	(ThisTaskTicks,PC),D0
	bsr	ShowDecimal
	move.b	#'/',(A5)+
	move.l	(RealTotalTicks,PC),D0
	bsr	ShowDecimal
22$	move.b	#']',(A5)+
	move.b	#10,(A5)+
	bra	.outputlinedone

2$	move.b	(A4)+,D0
	move.b	D0,(A5)+
	cmp.b	#10,D0
	bne.b	2$
	subq.l	#1,A5
	move.b	#',',(A5)+
	move.b	#'[',(A5)+
	bra.b	5$

1$	subq.l	#1,A4
	subq.l	#1,A5
6$	move.b	(A4)+,D0
	move.b	D0,(A5)+
	beq	sourceexhausted
	cmpi.b	#10,D0
	beq.b	.outputlinedone
	cmp.b	#9,D0
	bne.b	6$
	cmpi.b	#';',(A4)
	bne.b	6$
	cmpi.b	#' ',(1,A4)
	bne.b	6$
	cmpi.b	#'[',(2,A4)
	bne.b	6$
	cmpi.b	#'9',(3,A4)
	bhi.b	6$
	cmpi.b	#'0',(3,A4)
	bcs.b	6$
	tst.b	(StripFlag,PC)
	sne	D3
	bne.b	6$
	subq.l	#1,A5
7$	cmpi.b	#10,(A4)+
	bne.b	7$
	move.b	#10,(A5)+
.outputlinedone	cmp.l	(A6),D7	;anything for this line?
	bne	mainloop
	moveq	#0,D1
	move.b	D1,(conditionalflag)
9$	cmp.l	(12,A6),D4
	bcc.b	8$
	tst.l	(8,A3)
	bmi.b	8$
	move.w	(A1,D4.L),D0
	andi.w	#%1111111111111000,D0
	cmpi.w	#%0101000111001000,D0
	beq.b	19$
	move.l	D4,D0
	lsr.l	#2,D0
	bcc.b	18$
	bfextu	(A2,D0.L){4:4},D0
	bra.b	19$

18$	bfextu	(A2,D0.L){0:4},D0
19$	or.b	D0,D1
	bclr	#0,D1	; only interested in conditional branches
	or.b	D1,(conditionalflag)
	addq.l	#2,D4
	add.l	(A3)+,D5
	add.l	(A3)+,D6
	bra.b	9$


8$	addq.l	#8,A6
	cmp.l	(A6),D7
	beq.b	9$
	subq.l	#1,A5
	tst.l	D6
	bne.b	12$
	tst.l	D5
	beq	13$
12$	tst.b	D3	; info already on line?
	bne.b	10$
	move.b	#9,(A5)+
	move.b	#';',(A5)+
10$	move.b	#' ',(A5)+
	move.b	#'[',(A5)+
	tst.b	(conditionalflag,PC)
	beq.b	11$
	move.l	D5,D0
	add.l	D6,D0
	bsr	ShowDecimal
	move.b	#'|',(A5)+
11$	move.l	D6,D0
	bsr	ShowDecimal
	tst.b	(conditionalflag,PC)
	beq.b	21$
	move.b	#'/',(A5)+
	move.l	D5,D0
	bsr	ShowDecimal
21$	move.b	#']',(A5)+
	moveq	#'Z',D0
	move.l	D6,D1
	add.l	D5,D1
	beq.b	14$
	moveq	#'A',D0
	add.l	D1,D1
15$	add.l	D1,D1
	cmp.l	D2,D1
	bcc.b	14$
	addq.b	#1,D0
	bra.b	15$

14$	move.b	D0,(A5)+
	tst.b	(conditionalflag,PC)
	beq.b	13$
	move.b	#'}',(A5)+
	tst.b	(conditionalflag,PC)
	beq.b	20$
	moveq	#'A',D0
	tst.l	D6
	beq.b	16$
	tst.l	D5
	beq.b	16$
20$	moveq	#'Z',D0
	cmp.l	D6,D5
	bhi.b	16$
	moveq	#7,D0
	move.l	D6,D1
17$	lsr.l	#1,D1
	cmp.l	D1,D5
	dbhi	D0,17$
	add.w	#'B',D0
16$	move.b	D0,(A5)+
13$	move.b	#10,(A5)+
	bra	mainloop

sourceexhausted	subq.l	#1,A5
	move.l	#OutputFileName,D1
	move.l	#MODE_NEWFILE,D2
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOOpen,A6)
	move.l	D0,(Filehandle)
	beq	ErrorExit5
	move.l	D0,D1
	move.l	A5,D3
	move.l	(RealSourceBuf,PC),D2
	sub.l	D2,D3
	jsr	(_LVOWrite,A6)
	cmp.l	D0,D3
	bne	ErrorExit15
	bsr	CloseStuff
	tst.b	(CopyFlag)
	beq	NormalExit
	lea	(CopyMesg,PC),A0
	lea	(TempXName,PC),A1
	move.l	A1,D1
1$	move.b	(A0)+,(A1)+
	bne.b	1$
	lea	(OutputFileName,PC),A0
	move.b	#' ',(-1,A1)
2$	move.b	(A0)+,(A1)+
	bne.b	2$
	lea	(RealSourceName,PC),A0
	move.b	#' ',(-1,A1)
3$	move.b	(A0)+,(A1)+
	bne.b	3$
	moveq	#0,D2
	moveq	#0,D3
	move.l	A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOExecute,A6)
	movea.l	(SP)+,A6
	beq	ErrorExit19
	tst.b	(DeleteFlag)
	bne	NormalExit
	lea	(OutputFileName,PC),A0
	move.l	A0,D1
	move.l	A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVODeleteFile,A6)
	movea.l	(SP)+,A6
	bra	NormalExit

ErrorExit1	lea	(TrapVectorInUse,PC),A0
	bra	ExitExit

ErrorExit2	lea	(BadParameter,PC),A0
	bra	ExitExit

ErrorExit3	lea	(CantLoadExecutable,PC),A0
	bra	ExitExit

ErrorExit4	lea	(NotEnoughMemory,PC),A0
	bra.b	ExitExit

ErrorExit5	lea	(CantOpenOutput,PC),A0
	bra.b	ExitExit

ErrorExit6	lea	(CantFindExec,PC),A0
	bra.b	ExitExit

ErrorExit7	lea	(ExecFileEmpty,PC),A0
	bra.b	ExitExit

ErrorExit8	lea	(CouldntExamineExec,PC),A0
	bra.b	ExitExit

ErrorExit9	lea	(CouldntOpenExec,PC),A0
	bra.b	ExitExit

ErrorExit10	lea	(ReadErrorExec,PC),A0
	bra.b	ExitExit

ErrorExit11	lea	(BadHeaderExec,PC),A0
	bra.b	ExitExit

ErrorExit13	lea	(NoSourceName,PC),A0
	bra.b	ExitExit

ErrorExit14	lea	(CantOpenSource,PC),A0
	bra.b	ExitExit

ErrorExit15	lea	(WriteErrorOP,PC),A0
	bra.b	ExitExit

ErrorExit16	lea	(NoDebugHunk,PC),A0
	bra.b	ExitExit

ErrorExit17	lea	(BadDebugHunk,PC),A0
	bra.b	ExitExit

ErrorExit18	lea	(BadFence,PC),A0
	bra.b	ExitExit

ErrorExit19	lea	(CouldntCopy,PC),A0
	bra.b	ExitExit

ErrorExit20	lea	(CantOpenWith,PC),A0
	bra.b	ExitExit

ErrorExit21	lea	(CouldntReadWith,PC),A0
	bra.b	ExitExit

ErrorExit22	lea	(NoTraps,PC),A0
	bra.b	ExitExit

ErrorExit23	lea	(NoCodeInExec,PC),A0
	bra.b	ExitExit

ErrorExit24	lea	(EmptySourceFile,PC),A0
	bra.b	ExitExit

ErrorExit25	lea	(SourceReadError,PC),A0
	bra.b	ExitExit

NormalExit	lea	(ExecMesg,PC),A0
	bra.b	ExJoin

ExitExit	move.l	A0,(ErrorStringPointer)
	lea	(ErrorXMesg,PC),A0
ExJoin	clr.b	(TimerGo)
	tst.b	(A0)
	beq.b	NormalExit2
	move.l	A0,D1
	moveq	#0,D2
	moveq	#0,D3
	move.l	A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOExecute,A6)
	movea.l	(SP)+,A6
NormalExit2	suba.l	A0,A0
	move.l	(Cia_Base,PC),D0
	beq.b	NoCia
	movea.l	D0,A6
	moveq	#1,D0
	jsr	(_LVOAbleICR,A6)	; cancel interrupts
	lea	(intstructure,PC),A1
	moveq	#0,D0
	jsr	(_LVORemICRVector,A6)
	clr.l	(Cia_Base)
NoCia	tst.l	(ErrorStringPointer)
	beq.b	RealExit
	move.l	(OutputHandle,PC),D1
	bne.b	GotOPHandle
	move.l	A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOOutput,A6)
	movea.l	(SP)+,A6
	move.l	D0,(OutputHandle)
	move.l	D0,D1
GotOPHandle	move.l	(ErrorStringPointer,PC),D0
	movea.l	D0,A0
	moveq	#$7F,D2
1$	and.b	D2,(A0)+
	bne.b	1$
	suba.l	D0,A0
	subq.l	#1,A0
	move.l	A0,D3
	move.l	D0,D2
	move.l	A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOWrite,A6)
	movea.l	(SP)+,A6
RealExit	movea.l	(4),A6
	bsr	CloseStuff
	move.l	(ErrorStringPointer,PC),D0
	cmpi.l	#WriteErrorOP,D0
	bne.b	8$
	lea	(OutputFileName,PC),A0
	move.l	A0,D1
	move.l	A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVODeleteFile,A6)
	movea.l	(SP)+,A6
8$	moveq	#0,D0
	move.w	(jsrtrap,PC),D0
	bmi.b	1$
	andi.w	#15,D0
	movea.l	(4),A6
	jsr	(_LVOFreeTrap,A6)
1$	move.l	(Dos_Base,PC),D0
	beq.b	4$
	movea.l	(4),A6
	movea.l	D0,A1
	jsr	(_LVOCloseLibrary,A6)
4$	movea.l	(SaveSP,PC),SP
	moveq	#0,D0
	rts		; final exit
newtrap	move.l	(2,SP),(realtrapaddress)
	dw	$4EF9
oldtrap	dl	0
lev3int	move.l	(2,SP),(RealReturnAddress)
	dw	$4EF9
poke1	dl	0

InterruptHandler	tst.b	(interruptdisabler)
	bne	7$
	addq.l	#1,(RealTotalTicks)
	movem.l	D2-D4,(SaveIntRegs)
	movem.l	A0/A1,-(SP)
	lea	(callers,PC),A0
	move.l	(A0)+,D0
	beq.b	2$
5$	movea.l	(A0)+,A1
	addq.w	#1,(A1)
	bcs.b	11$
12$	move.l	(A0)+,D0
	bne.b	5$
2$	movem.l	(SP)+,A0/A1
	move.l	(OurTask,PC),D0
	tst.l	(librarycaller)
	beq.b	9$
	move.l	(librarycaller,PC),(A1)
	bra.b	10$
11$	subq.w	#1,(A1)
	bra.b	12$

9$	cmp.l	(ThisTask,A6),D0
	bne.b	6$
10$	addq.l	#1,(ThisTaskTicks)
6$	move.l	(A1),D0	; actual return address
	cmp2.l	(hunkstart,PC),D0
	bcs.b	3$
	sub.l	(hunkstart,PC),D0
	lea	([_BigBlock,PC],D0.L*4,4),A0
	addq.l	#1,(A0)
	bcs.b	1$
3$	movem.l	(SaveIntRegs,PC),D2-D4
7$	move.b	(TimerGo,PC),($BFEE01)	; get timer going again
	rts

1$	subq.l	#1,(A0)
	movem.l	(SaveIntRegs,PC),D2-D4
	move.b	(TimerGo,PC),($BFEE01)	; get timer going again
	rts
FindWordStart:
	move.l	D0,-(SP)
1$	move.b	(A0)+,D0
	beq	ErrorExit2
	cmpi.b	#' ',D0
	bls.b	1$
	subq.l	#1,A0
	move.l	(SP)+,D0
	rts
	
FindWordStart2	; okay if line runs out
	move.l	D0,-(SP)
1$	move.b	(A0)+,D0
	beq.b	2$
	cmpi.b	#' ',D0
	bls.b	1$
	move.l	(SP)+,D0
	cmpa.l	A0,SP
	subq.l	#1,A0
	rts
2$	move.l	(SP)+,D0
	subq.l	#1,A0
	cmp.w	D0,D0
	rts
	
ShowDecimal:
; A5 -> output buffer
; D0 = number
; A5 advanced, D0 trashed
	movem.l	D1/D2/D3/A1,-(SP)
	moveq	#0,D3	; leading zero flag
	lea	(DecimalTable,PC),A1
3$	move.l	(A1)+,D1
	beq.b	DecimalAllDone
	moveq	#-1,D2
1$	sub.l	D1,D0
	dbcs	D2,1$
	add.l	D1,D0
	neg.w	D2
	subq.w	#1,D2
	bne.b	2$
	tst.w	D3
	beq.b	3$
2$	st	D3
	addi.b	#'0',D2
	move.b	D2,(A5)+
	bra.b	3$
DecimalAllDone	tst.w	D3
	bne.b	1$
	move.b	#'0',(A5)+
1$	movem.l	(SP)+,D1/D2/D3/A1
	rts
**********************************************************************
SetInterval:
	moveq	#0,D2	; total
	moveq	#0,D0
1$	move.b	(A0)+,D0
	beq.b	SIVExit
	cmpi.b	#' ',D0
	beq.b	SIVExit
	cmpi.b	#'0'-1,D0
	bls	ErrorExit2
	cmpi.b	#'9',D0
	bhi	ErrorExit2
	subi.b	#'0',D0
	add.l	D2,D2
	move.l	D2,D1
	lsl.l	#2,D2
	add.l	D1,D2	; multiply by ten
	add.l	D0,D2
	bra.b	1$

SIVExit	cmpi.l	#$FFFF,D2
	bhi	ErrorExit2
	cmpi.w	#40,D2
	bls	ErrorExit2
	move.w	D2,(Interval)
	move.b	-(A0),D0
	rts
**********************************************************************
DoExecute	lea	(TempXName,PC),A1
	move.l	A1,-(SP)
	bsr.b	SetNameJoin
	move.l	(SP)+,D1
	moveq	#0,D2
	moveq	#0,D3
	movem.l	A0/A6,-(SP)
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOExecute,A6)
	movem.l	(SP)+,A0/A6
	rts
**********************************************************************
GetErrorString:
	lea	(ErrorXMesg,PC),A1
	bra.b	SetNameJoin
GetXString:
	lea	(ExecMesg,PC),A1
	bra.b	SetNameJoin
SetOuputName	lea	(OutputFileName,PC),A1
	bra.b	SetNameJoin
SetSourceName	lea	(RealSourceName,PC),A1
SetNameJoin	bsr	FindWordStart
	moveq	#' ',D1	; char to look for
	cmpi.b	#$27,(A0)
	bhi.b	1$
	move.b	(A0)+,D1
1$	move.b	(A0)+,D0
	beq.b	SSNExit
	cmp.b	D1,D0
	beq.b	SSNExit2
	move.b	D0,(A1)+
	bra.b	1$
SSNExit	move.b	-(A0),D0
SSNExit2	clr.b	(A1)
	rts
**********************************************************************
NoHandler:
NoBase	lea	(NoList,PC),A1
	move.b	(A0)+,D0
	beq.b	NoExit
	cmpi.b	#' ',D0
	beq.b	NoExit
CheckNextNo	move.w	(A1)+,D1
	beq	ErrorExit2
	move.w	(A1)+,D2
	cmp.b	D1,D0
	beq.b	1$
	lsr.w	#8,D1
	cmp.b	D1,D0
	bne.b	CheckNextNo
1$	lea	(NoBase,PC,D2.W),A1
	clr.b	(A1)
	bra.b	NoBase
NoExit	move.b	-(A0),D0
	rts
**********************************************************************
enable	move.l	A0,-(SP)
	movea.l	(4),A0
	subq.b	#1,(IDNestCnt,A0)
	bge.b	1$
	move.w	#$C000,($DFF09A)
1$	movea.l	(SP)+,A0
	rts
disable	move.l	A0,-(SP)
	movea.l	(4),A0
	move.w	#$4000,($DFF09A)
	addq.b	#1,(IDNestCnt,A0)
	movea.l	(SP)+,A0
	rts
**********************************************************************
CloseStuff	move.l	(Line1010Code,PC),D0
	beq.b	15$
	move.l	D0,($28)
15$	move.l	(OddAddressCode,PC),D0
	beq.b	13$
	move.l	D0,(12)
	clr.l	(OddAddressCode)
13$	movea.l	(4),A6
	movea.l	(RealSourceBuf,PC),A1
	move.l	(RealSourceSize,PC),D0
	beq.b	12$
	move.l	D0,D1
	lsr.l	#1,D1
	add.l	D1,D0
	jsr	(_LVOFreeMem,A6)
12$	clr.l	(RealSourceSize)
	lea	(codedebugptr,PC),A3
	movea.l	(A3)+,A1
	move.l	(A3),D0
	beq.b	4$
	jsr	(_LVOFreeMem,A6)
4$	clr.l	(A3)+
	movea.l	(A3)+,A1
	move.l	(A3),D0
	beq.b	8$
	jsr	(_LVOFreeMem,A6)
8$	clr.l	(A3)+
	movea.l	(A3)+,A1
	move.l	(A3),D0
	beq.b	11$
	jsr	(_LVOFreeMem,A6)
11$	clr.l	(A3)+
	move.l	(WithFilehandle,PC),D1
	beq.b	10$
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOClose,A6)
	clr.l	(WithFilehandle)
10$	move.l	(RealSourceHandle,PC),D1
	beq.b	9$
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOClose,A6)
	clr.l	(RealSourceHandle)
9$	move.l	(InputFilehandle,PC),D1
	beq.b	7$
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOClose,A6)
	clr.l	(InputFilehandle)
7$	move.l	(InputFileLock,PC),D1
	beq.b	5$
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOUnLock,A6)
	clr.l	(InputFileLock)
5$	movea.l	(4),A6
	move.l	(BigInputBuf,PC),D0
	beq.b	6$
	movea.l	D0,A1
	move.l	(InputFileSize,PC),D0
	addq.l	#4,D0
	jsr	(_LVOFreeMem,A6)
	clr.l	(BigInputBuf)
6$	move.l	(_BigBlock,PC),D0
	beq.b	1$
	movea.l	D0,A1
	move.l	(BlockSize,PC),D0
	addq.l	#8,D0
	jsr	(_LVOFreeMem,A6)
	clr.l	(_BigBlock)
1$	move.l	(_BigBlock2,PC),D0
	beq.b	14$
	movea.l	D0,A1
	move.l	(BlockSize,PC),D0
	lsr.l	#4,D0
	addq.l	#1,D0
	jsr	(_LVOFreeMem,A6)
	clr.l	(_BigBlock2)
14$	move.l	(SegStart,PC),D1
	beq.b	2$
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOUnLoadSeg,A6)
	clr.l	(SegStart)
2$	move.l	(Filehandle,PC),D1
	beq.b	3$
	movea.l	(Dos_Base,PC),A6
	jsr	(_LVOClose,A6)
	clr.l	(Filehandle)
3$	rts
**********************************************************************
TrapHandler:
	st	(interruptdisabler)
	addq.l	#4,SP
	movem.l	D0-D1/A0/A1/A6,-(SP)
	movea.l	(realtrapaddress,PC),A0
	move.l	USP,A1
	tst.b	(A0)	; jsr or jmp?
	bpl.b	1$	; branch if jmp
	move.l	A0,D0
	addq.l	#2,D0
	move.l	D0,-(A1)
1$	move.l	#CancelTrap,-(A1)
	move.l	A1,USP
	move.w	(A0),D0
	bset	#15,D0
	cmpi.b	#NT_LIBRARY,(LN_TYPE,A6)	; is this REALLY a library?
	beq.b	3$
	move.w	#$4EAE,(-2,A0)	; turn back into JSR
	tst.b	(A0)
	bmi.b	4$
	move.w	#$4EEE,(-2,A0)
4$	move.w	D0,(A0)
	suba.l	A0,A0
	addq.l	#2,A0
3$	adda.w	D0,A6
	move.l	A6,(22,SP)	; address of library vector
	subq.l	#2,A0
	tst.b	(TimerGo)
	beq.b	2$
	move.l	A0,(librarycaller)
2$	clr.b	(interruptdisabler)
	movem.l	(SP)+,D0-D1/A0/A1/A6
	rte
CancelTrap:
	movem.l	A0/A0,-(SP)
	lea	(0),A0
	movem.l	A0/A0,(librarycaller)
	movem.l	(SP)+,A0/A0
	rts
***********************************************************************************
Line1010Handler	movem.l	D0-D7/A0-A3,(callerregs)
	move.l	(2,SP),D0	; odd branch
	movea.l	D0,A1
	tst.b	(1,A1)	;RTS?
	bpl.b	.rts
	lea	(2,A1),A2
	move.w	(A2)+,D2
	lea	(-2,A2,D2.W),A3	; success address
	bfextu	(A1){4:4},D2	; condition code
	sub.l	(hunkstart,PC),D0	; find offset into hunk
	lea	([_BigBlock,PC],D0.L*4),A0
	move.l	D2,D0
	move.l	A3,D2
	move.w	(SP),D1	; get condition codes
	jmp	([1$,PC,D0.W*4])

1$	dl	.bra
	dl	.bsr
	dl	.bhi
	dl	.bls
	dl	.bcc
	dl	.bcs
	dl	.bne
	dl	.beq
	dl	.bvc
	dl	.bvs
	dl	.bpl
	dl	.bmi
	dl	.bge
	dl	.blt
	dl	.bgt
	dl	.ble

.rts	move.l	USP,A0
	movea.l	(A0)+,A1	; get return address
	move.l	A0,USP
	move.l	A1,(2,SP)	; new return address
	sub.l	(hunkstart,PC),D0	; find offset into hunk
	lea	([_BigBlock,PC],D0.L*4,4),A0
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.bls	btst	#0,D1
	bne.b	.SuccessBranch2
	btst	#2,D1
	bne.b	.SuccessBranch2
	bra.b	.FailBranch

.bcc	btst	#0,D1
	bne.b	.FailBranch
	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.bcs	btst	#0,D1
	beq.b	.FailBranch
.SuccessBranch2	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.bne	btst	#2,D1
	bne.b	.FailBranch
	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.beq	btst	#2,D1
	beq.b	.FailBranch
	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.bvc	btst	#1,D1
	bne.b	.FailBranch
	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.bhi	btst	#0,D1
	bne.b	.FailBranch
	btst	#2,D1
	beq.b	.SuccessBranch
.bsr
.FailBranch	bfextu	(A1){13:3},D1	; data reg number
	lea	(callerregs,PC),A1
	move.w	(2,A1,D1.W*4),D0	; get word contents
	subq.w	#1,D0
	bcs.b	2$
	move.w	D0,(2,A1,D1.W*4)
	move.l	A3,(2,SP)	;successful
	addq.l	#1,(4,A0)
	movem.l	(A1),D0-D7/A0-A3
	rte

2$	move.w	D0,(2,A1,D1.W*4)
.bra
.SuccessBranch	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.bvs	btst	#1,D1
	beq.b	.FailBranch
	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.bpl	btst	#3,D1
	bne.b	.FailBranch
	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.bmi	btst	#3,D1
	beq.b	.FailBranch
	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.bgt	btst	#2,D1
	bne.b	.FailBranch
.bge	btst	#3,D1
	beq.b	4$
	btst	#1,D1
	beq.b	.FailBranch2
	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.FailBranch2	bfextu	(A1){13:3},D1	; data reg number
	lea	(callerregs,PC),A1
	move.w	(2,A1,D1.W*4),D0	; get word contents
	subq.w	#1,D0
	bcs.b	2$
	move.w	D0,(2,A1,D1.W*4)
	move.l	A3,(2,SP)	;successful
	addq.l	#1,(4,A0)
	movem.l	(A1),D0-D7/A0-A3
	rte

4$	btst	#1,D1
	bne.b	.FailBranch2
	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

.ble	btst	#2,D1
	bne.b	3$
.blt	btst	#3,D1
	bne.b	4$
	btst	#1,D1
	beq.b	.FailBranch2
3$	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D7/A0-A3
	rte

***********************************************************************************
OddHandler	movem.l	D0-D2/A0-A3,(callerregs)
	move.l	(2,SP),D0	; odd branch
	move.l	D0,D1
	sub.l	(hunkstart,PC),D1	; get offset
	move.l	#12,($5A,SP)
	move.l	(2,SP),($56,SP)
	move.w	(SP),($54,SP)
	lea	($54,SP),SP
	moveq	#0,D2
	lsr.l	#2,D1
	bcc.b	5$
	moveq	#4,D2
5$	bfextu	([_BigBlock2,PC],D1.L){D2:4},D2	; actual condition code
	movea.l	D0,A1
	lea	(2,A1),A2	; fail address
	bfexts	(A1){8:8},D1
	beq.b	.wordbranch
	cmp.b	#-1,D1
	beq.b	.longbranch
	lea	(A2,D1.L),A3	; success address
	bra.b	.afterbranchstuff

.wordbranch	move.w	(A2),D1
	lea	(A2,D1.W),A3
	addq.l	#2,A2
	bra.b	.afterbranchstuff

.longbranch	move.l	(A2),D1
	lea	(A2,D1.L),A3	; success address
	addq.l	#4,A2
.afterbranchstuff	subq.l	#1,A3	; clear odd address bit
	sub.l	(hunkstart,PC),D0	; find offset into hunk
	lea	([_BigBlock,PC],D0.L*4),A0
	move.l	D2,D0
	move.l	A3,D2
	move.w	(SP),D1	; get condition codes
	jmp	([1$,PC,D0.W*4])

1$	dl	.bra
	dl	.bsr
	dl	.bhi
	dl	.bls
	dl	.bcc
	dl	.bcs
	dl	.bne
	dl	.beq
	dl	.bvc
	dl	.bvs
	dl	.bpl
	dl	.bmi
	dl	.bge
	dl	.blt
	dl	.bgt
	dl	.ble

.bra	addq.l	#1,(4,A0)
	move.l	A3,(2,SP)	; always successful
	movem.l	(callerregs,PC),D0-D2/A0-A3
	rte

.bsr	addq.l	#1,(4,A0)
	move.l	USP,A0
	move.l	A2,-(A0)
	move.l	A0,USP
	move.l	A3,(2,SP)	; always successful
	movem.l	(callerregs,PC),D0-D2/A0-A3
	rte

.bls	btst	#0,D1
	bne.b	.SuccessBranch
	btst	#2,D1
	bne.b	.SuccessBranch
	bra.b	.FailBranch

.bcc	btst	#0,D1
	bne.b	.FailBranch
	bra.b	.SuccessBranch

.bcs	btst	#0,D1
	beq.b	.FailBranch
	bra.b	.SuccessBranch

.bne	btst	#2,D1
	bne.b	.FailBranch
	move.l	A3,(2,SP)	;successful
	addq.l	#1,(4,A0)
	movem.l	(callerregs,PC),D0-D2/A0-A3
	rte

.beq	btst	#2,D1
	beq.b	.FailBranch
	move.l	A3,(2,SP)	;successful
	addq.l	#1,(4,A0)
	movem.l	(callerregs,PC),D0-D2/A0-A3
	rte

.bvc	btst	#1,D1
	bne.b	.FailBranch
	bra.b	.SuccessBranch

.bhi	btst	#0,D1
	bne.b	.FailBranch
	btst	#2,D1
	bne.b	.FailBranch
.SuccessBranch	move.l	A3,(2,SP)	;successful
	addq.l	#1,(4,A0)
	movem.l	(callerregs,PC),D0-D2/A0-A3
	rte

.FailBranch	move.l	A2,(2,SP)	;unsuccessful
	addq.l	#1,(A0)
	movem.l	(callerregs,PC),D0-D2/A0-A3
	rte

.bvs	btst	#1,D1
	beq.b	.FailBranch
	bra.b	.SuccessBranch

.bpl	btst	#3,D1
	bne.b	.FailBranch
	bra.b	.SuccessBranch

.bmi	btst	#3,D1
	beq.b	.FailBranch
	bra.b	.SuccessBranch

.bgt	btst	#2,D1
	bne.b	.FailBranch
.bge	btst	#3,D1
	beq.b	4$
	btst	#1,D1
	beq.b	.FailBranch
	bra.b	.SuccessBranch

4$	btst	#1,D1
	bne.b	.FailBranch
	bra.b	.SuccessBranch

.ble	btst	#2,D1
	bne.b	.SuccessBranch
.blt	btst	#3,D1
	bne.b	4$
	btst	#1,D1
	beq.b	.FailBranch
	bra.b	.SuccessBranch

***********************************************************************************
jsrreturn	movea.l	D4,A0
	addq.l	#2,A0
	adda.w	(instructionlength,PC),A0	; return address
	move.l	A0,D4
	subq.l	#2,D4
	movea.l	(callerregs+60),A1
	move.l	A0,-(A1)
	move.l	A1,(callerregs+60)
	move.l	(jsrdest),(2,SP)	; effective address of subroutine
	bra	jsrlinelabel6

JsrLineCode
	st	(interruptdisabler)
	movem.l	D0-D7/A0-A6,(callerregs)
	move.l	USP,A0
	move.l	A0,(callerregs+60)
	movea.l	(2,SP),A0
	cmpi.w	#$F999,(A0)
	bne.b	jsrlinelabel9
	move.l	USP,A0
	move.l	(A0)+,D0
	move.l	D0,(2,SP)
	move.l	A0,USP
	movea.l	(callerspointer,PC),A0
	subq.l	#2,D0
	bra.b	3$

2$	cmpa.l	#callers,A0
	beq.b	4$
	subq.l	#8,A0
3$	cmp.l	(A0),D0
	bne.b	2$
5$	clr.l	(A0)
	move.l	A0,(callerspointer)
1$	movem.l	(callerregs),D0-D7/A0-A6
	clr.b	(interruptdisabler)
	rte

4$	movea.l	(callerspointer,PC),A0
	cmpa.l	#callers,A0
	beq.b	1$
	subq.l	#8,A0
	bra.b	5$

jsrlinelabel9	move.l	USP,A0
	move.l	A0,(callerregs+60)
	move.l	(2,SP),D4
	movea.l	D4,A0
	btst	#0,(A0)	; BSR?
	bne.b	jsrlinelabel2	; branch if BSR
	lea	(jsrreturn,PC),A3
	moveq	#0,D0
	move.w	(A0)+,D0
	move.l	D0,D2
	andi.w	#7,D2
	lsl.l	#2,D2
	moveq	#0,D1
	move.w	(A0),D1
	andi.w	#%0000000000111111,D0
	add.w	D0,D0
	lea	(callerregs,PC),A1
	clr.w	(instructionlength)
	lea	(jsrjumptable,PC),A2
	move.w	(0,A2,D0.W),D0
	jmp	(0,A2,D0.W)

jsrlinelabel2	moveq	#0,D0
	addq.l	#2,(2,SP)	; allow for opcode
	move.l	(2,SP),D1	; return address
	move.b	(1,A0),D0	; short branch?
	ext.w	D0
	bne.b	jsrlinelabel7
	move.w	(2,A0),D0
	addq.l	#2,D1	; return address for BSR.L
	addq.l	#2,D4
jsrlinelabel7	ext.l	D0
	add.l	D0,(2,SP)
	movea.l	(callerregs+60),A0
	move.l	D1,-(A0)
	move.l	A0,(callerregs+60)
jsrlinelabel6	move.l	D4,(lastjsr)
	move.l	(SegStart,PC),D0
	lsl.l	#2,D0
	movea.l	D0,A0
	moveq	#0,D3	; total offset
jsrlinelabel4	move.l	(A0),D0	; top of loop
	lsl.l	#2,D0
	move.l	-(A0),D1
	subq.l	#8,D1
	addq.l	#8,A0
	move.l	A0,D2
	add.l	D1,D2	; points to end of hunk
	cmp.l	D2,D4
	bcc.b	jsrlinelabel1
	cmp.l	A0,D4
	bcs.b	jsrlinelabel1
	sub.l	A0,D4
	add.l	D3,D4
	add.l	D4,D4	; longwords now!
	add.l	(_BigBlock,PC),D4
	addq.l	#2,D4	; make it easier for interrupt code
	lea	(callers,PC),A0
	tst.l	(A0)
	beq.b	1$
2$	addq.l	#4,A0
	cmp.l	(A0)+,D0
	beq.b	jsrlinelabel3
	tst.l	(A0)
	bne.b	2$
1$	move.l	(lastjsr),(A0)+
	move.l	D4,(A0)+
	move.l	A0,(callerspointer)
	cmpa.l	#callersend,A0
	bne.b	jsrlinelabel3
	clr.l	-(A0)
	clr.l	-(A0)
	move.l	A0,(callerspointer)
jsrlinelabel3	movea.l	(callerregs+60),A0
	move.l	A0,USP
	movem.l	(callerregs),D0-D7/A0-A6
	clr.b	(interruptdisabler)
	rte

jsrlinelabel1	tst.l	D0
	beq.b	jsrlinelabel5
	add.l	D1,D3
	movea.l	D0,A0
	bra.b	jsrlinelabel4

jsrlinelabel5	movea.l	(callerregs+60),A0
	move.l	A0,USP
	movem.l	(callerregs),D0-D7/A0-A6
	move.l	(Line1111Code,PC),-(SP)
	clr.b	(interruptdisabler)
	rts
***********************************************************************************
jsrjumptable
	dw	0	; D0
	dw	0	; D1
	dw	0	; D2
	dw	0	; D3
	dw	0	; D4
	dw	0	; D5
	dw	0	; D6
	dw	0	; D7
	dw	0	; A0
	dw	0	; A1
	dw	0	; A2
	dw	0	; A3
	dw	0	; A4
	dw	0	; A5
	dw	0	; A6
	dw	0	; A7
	dw	a0indirect-jsrjumptable	; (A0)
	dw	a1indirect-jsrjumptable	; (A1)
	dw	a2indirect-jsrjumptable	; (A2)
	dw	a3indirect-jsrjumptable	; (A3)
	dw	a4indirect-jsrjumptable	; (A4)
	dw	a5indirect-jsrjumptable	; (A5)
	dw	a6indirect-jsrjumptable	; (A6)
	dw	a7indirect-jsrjumptable	; (A7)
	dw	0	; (A0)+
	dw	0	; (A1)+
	dw	0	; (A2)+
	dw	0	; (A3)+
	dw	0	; (A4)+
	dw	0	; (A5)+
	dw	0	; (A6)+
	dw	0	; (A7)+
	dw	0	; -(A0)
	dw	0	; -(A1)
	dw	0	; -(A2)
	dw	0	; -(A3)
	dw	0	; -(A4)
	dw	0	; -(A5)
	dw	0	; -(A6)
	dw	0	; -(A7)
	dw	a0index-jsrjumptable	; (x,A0)
	dw	a1index-jsrjumptable	; (x,A1)
	dw	a2index-jsrjumptable	; (x,A2)
	dw	a3index-jsrjumptable	; (x,A3)
	dw	a4index-jsrjumptable	; (x,A4)
	dw	a5index-jsrjumptable	; (x,A5)
	dw	a6index-jsrjumptable	; (x,A6)
	dw	a7index-jsrjumptable	; (x,A7)
	dw	a0indirectindex-jsrjumptable	; (,A0,Xi)
	dw	a1indirectindex-jsrjumptable	; (,A1,Xi)
	dw	a2indirectindex-jsrjumptable	; (,A2,Xi)
	dw	a3indirectindex-jsrjumptable	; (,A3,Xi)
	dw	a4indirectindex-jsrjumptable	; (,A4,Xi)
	dw	a5indirectindex-jsrjumptable	; (,A5,Xi)
	dw	a6indirectindex-jsrjumptable	; (,A6,Xi)
	dw	a7indirectindex-jsrjumptable	; (,A7,Xi)
	dw	absword-jsrjumptable	; XXXX.w
	dw	abslong-jsrjumptable	; XXXXXXXX.l
	dw	pcrelative-jsrjumptable	; (,PC)
	dw	pcrelativeindex-jsrjumptable	; (,PC,Xi)
	dw	0
	dw	0
	dw	0
	dw	0
***********************************************************************************
a0indirect
a1indirect
a2indirect
a3indirect
a4indirect
a5indirect
a6indirect
a7indirect
	move.l	(32,A1,D2.W),(jsrdest)
	jmp	(A3)
***********************************************************************************
a0index
a1index
a2index
a3index
a4index
a5index
a6index
a7index
	movea.l	(32,A1,D2.W),A0
	adda.w	D1,A0
	move.l	A0,(jsrdest)
	addq.w	#2,(instructionlength)
	jmp	(A3)
***********************************************************************************
a0indirectindex
a1indirectindex
a2indirectindex
a3indirectindex
a4indirectindex
a5indirectindex
a6indirectindex
a7indirectindex
	movea.l	(32,A1,D2.W),A0
pcrelativeindex	move.w	D1,D2
	ext.w	D2
	adda.w	D2,A0
	tst.w	D1	; D/A?
	beq.b	1$	; branch if data
	lea	(16,A1),A1
1$	move.w	D1,D2
	andi.w	#%0111000000000000,D2
	rol.w	#6,D2
	ror.w	#8,D1
	ror.w	#4,D1
	bcs.b	2$	; carry if long
	adda.w	(2,A1,D2.W),A0
	bra.b	3$
2$	adda.l	(0,A1,D2.W),A0
3$	move.l	A0,(jsrdest)
	addq.w	#2,(instructionlength)
	jmp	(A3)
***********************************************************************************
absword	movea.w	D1,A0
	move.l	A0,(jsrdest)
	addq.w	#2,(instructionlength)
	jmp	(A3)
***********************************************************************************
abslong	move.l	(A0),(jsrdest)
	addq.w	#4,(instructionlength)
	jmp	(A3)
***********************************************************************************
pcrelative	lea	(0,A0,D1.W),A0
	move.l	A0,(jsrdest)
	addq.w	#2,(instructionlength)
	jmp	(A3)
***********************************************************************************
DecimalTable:
	dl	1000000000
	dl	100000000
	dl	10000000
	dl	1000000
	dl	100000
	dl	10000
	dl	1000
	dl	100
	dl	10
	dl	1
	dl	0
**********************************************************************
TimerGo	db	$99
StripTotalsFlag	db	$FF
CopyFlag	db	$FF
StripFlag	db	$FF
DeleteFlag	db	$FF
libraryflag	db	$FF
oddflag	db	$FF
BranchFlag	db	$FF
FoundDebugHunkFlag	db	0
	even
NextPtr	dl	$FC0000
intstructure	dl	0
	dl	0
	db	2
	db	-128
	dl	myname
	dl	RealReturnAddress
	dl	InterruptHandler
Interval	dw	2000
ParameterList	dw	'Tt'
	dw	SetInterval-PLBase
	dw	'Ss'
	dw	SetSourceName-PLBase
	dw	'Oo'
	dw	SetOuputName-PLBase
	dw	'Cc'
	dw	NoHandler-PLBase
	dw	'Gg'
	dw	GetXString-PLBase
	dw	'Ee'
	dw	GetErrorString-PLBase
	dw	'Xx'
	dw	DoExecute-PLBase
	dw	0
NoList	dw	'Ss'
	dw	StripFlag-NoBase
	dw	'Cc'
	dw	CopyFlag-NoBase
	dw	'Bb'
	dw	BranchFlag-NoBase
	dw	'Dd'
	dw	DeleteFlag-NoBase
	dw	'Tt'
	dw	StripTotalsFlag-NoBase
	dw	'lL'
	dw	libraryflag-NoBase
	dw	'Oo'
	dw	oddflag-NoBase
	dw	0
DefaultWithFile	db	's:Profiler.wth',0
DosName	db	'dos.library',0
myname	db	'Glen''s timer interrupt',0
CiaName	db	'ciaa.resource',0
OutputFileName	db	't:PRSource.backup',0
CommentString	db	';_[',0
ExtraCommentString	db	',[',0
CopyMesg	db	'copy',0
TrapVectorInUse	db	'Level 2 interrupt vector in use - try again later',10,0
BadParameter	db	'Invocation Error - Please check manual for syntax',10,0
CantLoadExecutable	db	'Couldn''t run the executable!',10,0
NotEnoughMemory	db	'Not enough memory!',10,0
CantOpenOutput	db	'Couldn''t open output file',10,0
CantFindExec	db	'Couldn''t find executable!',10,0
ExecFileEmpty	db	'Executable file empty!',10,0
CouldntExamineExec	db	'Couldn''t examine executable!',10,0
CouldntOpenExec	db	'Couldn''t open executable',10,0
ReadErrorExec	db	'Error while reading executable',10,0
BadHeaderExec	db	'Unexpected hunk type in executable',10,0
NoSourceName	db	'Source code filename required!',10,0
CantOpenSource	db	'Can''t open source code file!',10,0
WriteErrorOP	db	'Write Error on output file - deleted',10,0
NoDebugHunk	db	'No debug hunk found in executable!',10,0
BadDebugHunk	db	'Debug hunk not of required type!',10,0
BadFence	db	'Quotes are required around parameters for target program',10,0
CouldntCopy	db	'Error while copying back to source code file!',10,0
CantOpenWith	db	'Couldn''t open WITH file!',10,0
CouldntReadWith	db	'Couldn''t read WITH file!',10,0
NoTraps	db	'Could not allocate traps',10,0
NoCodeInExec	db	'No code in executable!',10,0
EmptySourceFile	db	'Source file empty!',10,0
SourceReadError	db	'Error while reading source file',10,0
	quad
BssStart:
lastlong	dx.l	1
callers	dx.l	200
callersend
tracecode	dx.l	1
Line1010Code	dx.l	1
Line1111Code	dx.l	1
jsrtrap	dx.w	1
RealProgName	dx.b	240
ProgParms	dx.b	240
SaveAllRegs	dx.b	60
totalhunkcount	dx.l	1
RealSourceBuf	dx.l	1
WithFileBuf	dx.b	$2000
InSourceEnd:
OutSourceBuf	dx.b	$2000
OutSourceEnd:
instructionlength	dx.w	2
jsrdest	dx.l	1
SaveIntRegs	dx.b	28
RealReturnAddress	dx.l	1
OutputHandle	dx.l	1
callerspointer	dx.l	1
ErrorStringPointer	dx.l	1
Cia_Base	dx.l	1
InputFilenameLength	dx.l	1
InputParmsLength	dx.l	1
SaveSP	dx.l	1
LastHunk	dx.l	1
OurTask	dx.l	1
MaxTicks	dx.l	1
RealTotalTicks	dx.l	1
ThisTaskTicks	dx.l	1
TotalTicks	dx.l	1
debughunklimit	dx.l	1
SaveA0	dx.l	1
SaveD0	dx.l	1
Dos_Base	dx.l	1
SegStart	dx.l	1
_BigBlock	dx.l	1
_BigBlock2	dx.l	1	; store condition codes
BlockSize	dx.l	1
hunkstart	dx.l	1
hunkend	dx.l	1
codedebugptr	dx.l	1
codedebugsize	dx.l	1
datadebugptr	dx.l	1
datadebugsize	dx.l	1
_lvodebugptr	dx.l	1
_lvodebugsize	dx.l	1
ReturnAddress	dx.l	1
Filehandle	dx.l	1
librarycaller	dx.l	1
trapaddress	dx.l	1
realtrapaddress	dx.l	1
OddAddressCode	dx.l	1
callerregs	dx.l	20
lastjsr	dx.l	1
realaddress	dx.l	1
RealSourceSize	dx.l	1
StripFlag2	dx.b	2
lasthunktype	dx.l	1
LineNumber	dx.l	1
RealSourceHandle	dx.l	1
RealSourceName	dx.b	108
BigInputBuf	dx.l	1
InputFileSize	dx.l	1
InputFileLock	dx.l	1
InputFilehandle	dx.l	1
hunksize	dx.l	1
ExecMesg	dx.b	240
ErrorXMesg	dx.b	240
OldCommandPointer	dx.l	1
WithFlag	dx.l	1
TempXName	dx.b	240
WithFilehandle	dx.l	1
interruptdisabler	dx.b	1
conditionalflag	dx.b	1
BssEnd:
**********************************************************************
	END