Jamrules

# Whitespace around ; is significant in Jam so watch out.

SPACE				= " " ;

if $(OS) = NT
{
	# I've put my tools here:
	TOOL_PATH		= [ FDirName c: Programs ] ;

	# tool paths
	LWTOOLS_PATH	= [ FDirName $(TOOL_PATH) lwtools-4.24c ] ;
	TOOLSHED_PATH	= [ FDirName $(TOOL_PATH) toolshed-2.4.2 ] ;
	VCC_PATH		= [ FDirName $(TOOL_PATH) vcc-2.1.9.1 ] ;
	XROAR_PATH		= [ FDirName $(TOOL_PATH) xroar-1.8.1 ] ;
}
else
{
	TOOL_PATH		= [ FDirName usr local bin ] ;
	TOOL_PATH		= /$(TOOL_PATH) ;

	# tools assumed to be in /usr/local/bin
	LWTOOLS_PATH	= $(TOOL_PATH) ;
	TOOLSHED_PATH	= $(TOOL_PATH) ;
	VCC_PATH		= $(TOOL_PATH) ;
	XROAR_PATH		= $(TOOL_PATH) ;

	#JAMSHELL ?= bash -c % ;
}


# tools
DECB				= [ FDirName $(TOOLSHED_PATH) decb$(SUFEXE) ] ;
VCC					= [ FDirName $(VCC_PATH) vcc$(SUFEXE) ] ;
XROAR       		= [ FDirName $(XROAR_PATH) xroar$(SUFEXE) ] ;
LWASM				= [ FDirName $(LWTOOLS_PATH) lwasm$(SUFEXE) ] ;

# shorthands
SHORT on xroar 	= x ;
SHORT on vcc 	= v ;


#
# Exists f - is true if 'f' exists.
#
rule Exists
{
	local p = <checked>$(<:P) ;

	if $(VERBOSE) >= 5
	{
		Echo $(p) ;
	}

	if ! $($(p))
	{
		local files = [ Glob $(<:P) : * ] ;
		$(p) = $(files:BS) ;
	}

	if $(<:BS) in $($(p))
	{
		if $(VERBOSE) >= 5
		{
			Echo Found $(<:BS) ;
		}
		return 1 ;
	}

	return ;
}

if ! [ Exists $(DECB) ]
{
	Echo toolshed not found at path: $(TOOLSHED_PATH) ;
}

if ! [ Exists $(LWASM) ]
{
	Echo lwtools not found at path: $(LWTOOLS_PATH) ;
}

if [ Exists $(VCC) ]
{
	HAVE_VCC = vcc ;
}

if [ Exists $(XROAR) ]
{
	HAVE_XROAR = xroar ;
}

EMULATORS = VCC XROAR ;
HAVE_EMULATOR = $(HAVE_$(EMULATORS)) ;

if ! $(HAVE_EMULATOR)
{
	Exit No emulator found at path: $(VCC) or $(XROAR) ;
}

if $(VERBOSE) > 1
{
	Echo Have emulators: $(HAVE_EMULATOR) ;
}

rule Assembly
{
	local target = $(<:US=.BIN) ;
	local listing = $(<:US=.LST) ;
	MakeLocate $(listing) : $(LOCATE_TARGET) ;
	Assemble $(target) : $(<) ;
	NoCare $(listing) ;
	LISTING on $(target) = $(listing) ;
	Clean clean : $(listing) ;
	return $(target) ;
}

rule Assemble
{
	MakeLocate $(<) : $(LOCATE_TARGET) ;
	Depends $(<) : $(>) ;
	Clean clean : $(<) ;
	Depends asm : $(<) ;
	NotFile asm ;
}

actions Assemble
{
	$(LWASM) --6809 --list=$(LISTING) --symbols --6800compat --output=$(<[1]:U) --format=decb $(>)
}

rule DecbCopy
{
	Decb $(<) : $(>) ;
}

rule Decb
{
	Depends $(<) : $(>) ;
	Depends disk : $(<) ;
	NotFile disk ;
}

actions Decb
{
	$(DECB) copy -2 -b $(>) -r $(<),$(>:U)
}

rule DecbCopyAll disk : files
{
	local file ;
	for file in $(files:BS)
	{
		DecbCopy $(disk) : $(file) ;
	}
}

rule MakeDisk disk
{
	if ! $($(<)-mkdsk)
	{
		$(<)-mkdsk = true ;
		MakeDisk1 $(<) ;
		Clean clean : $(<) ;
		Depends dsk : $(<) ;
	}
}

actions MakeDisk1
{
	$(DECB) dskini -4 $(<)
}

rule RunToolOn tool : binary : disk : disk2
{
	local run = run-$(tool:L) run-$(SHORT:L) ;
	NotFile $(run) ;
	Always $(run) ;

	local run_target = $(SHORT:L)-$(binary:BL) ;
	$(tool:U) on $(run_target) = $(tool:U) ;
	$(tool) $(run_target) : $(binary:U) : $(disk) : $(disk2) ;
}

rule RunTool tool : binary : disk : disk2
{
	if $(HAVE_$(tool:U))
	{
		on $(tool:L) RunToolOn $(tool) : $(binary) : $(disk) : $(disk2) ;
	}
}

rule Run binary : disk : extrafiles : disk2
{
	MakeLocate $(disk) : $(LOCATE_TARGET) ;
	MakeDisk $(disk) ;

	DecbCopyAll $(disk) : $(binary) $(extrafiles) ;

	RunTool Vcc : $(binary) : $(disk) : $(disk2) ;
	RunTool XRoar : $(binary) : $(disk) : $(disk2) ;
}

rule Vcc target : binary : disk : disk2
{
	Depends $(<) : $(disk) ;
	NotFile $(<) ;
	Always $(<) ;
	VCC on $(<) = $(VCC) ;
}

actions ignore Vcc
{
	$(VCC) $(>)
}

rule XRoar target : binary : disk : disk2
{
	DISK on $(target) = $(disk) ;
	Depends $(target) : $(disk) ;
	if $(disk2)
	{
		DISK2 on $(target) = $(disk2) ;
		Depends $(target) : $(disk2) ;
	}

	Depends $(target) : $(disk) ;
	NotFile $(target) ;
	Always $(target) ;
	XROAR on $(<) = $(XROAR) ;
}

actions ignore XRoar bind DISK DISK2
{
	$(XROAR) -m coco3p -tv-type ntsc -gdb -joy-right mjoy0 -load-fd0$(SPACE)$(DISK) -load-fd1$(SPACE)$(DISK2) -run $(>)
}

rule Ball
{
	NotFile balls ;
	Depends balls : $(<) ;
	Depends $(<) : $(>) ;
	switch $(<) 
	{
		case *.tgz : Tarz $(<) : $(>) ;
		case *.shar : Shar $(<) : $(>) ;
		case *.zip : Zip $(<) : $(>) ;
	}
}

actions Tarz
{
	tar czvhf $(<) --transform 's,^,$(VERSION)/,' $(>)
}

actions Tar
{
	tar cvhf $(<) --transform 's,^,$(VERSION)/,' $(>)
}

actions Shar
{
	shar $(>) > $(<)
}

actions Zip
{
	zip $(<) $(>) 
}