#!/usr/bin/env omake
#----------------------------------------------------------------------------
# Project: Horizon
# File:    debuggerdefs.partner.om
#
# Copyright 2007-2009 Nintendo.  All rights reserved.
#
# These coded instructions, statements, and computer programs contain
# proprietary information of Nintendo of America Inc. and/or Nintendo
# Company Ltd., and are protected by Federal copyright law.  They may
# not be disclosed to third parties or copied or duplicated in any form,
# in whole or in part, without the prior written consent of Nintendo.
#
# $Date:: 2011-01-28#$
# $Rev: 33911 $
# $Author: takiguchi_shinichi $
#----------------------------------------------------------------------------

PYTHON = python
RUBY   = ruby
PARTNER_PARTNER = $(absname $(ROOT_TOOLS)$(DIRSEP)CommandLineTools$(DIRSEP)partner_partner.rb)
private.RUNNER_CORE_0_2   = $(file $(ROOT_BUILD)/runner/run-core_0_2.py)
LOADRUN = $(absname $(ROOT_TOOLS)$(DIRSEP)CommandLineTools$(DIRSEP)ctr_loadrunf32.exe)
LOADRUN_SPI = $(absname $(ROOT_TOOLS)$(DIRSEP)CommandLineTools$(DIRSEP)ctr_loadrun32.exe)

public.PartnerMCR(axf, process) =
    export depend_files
    depend_files = 
    if $(not $(SKIP_BUILD))
        depend_files += $(axf) $(process)

    export basefile
    export axf_symbol
    if $(not $(equal $(process), $(EMPTY)))
        basefile = $(process)
        axf_symbol = $(removesuffix $(process)).axf
    else
        basefile = $(axf)

    mcr     = $(addsuffix .mcr,$(removesuffix $(basefile)))
    log     = $(removesuffix $(absname $(basefile))).log
    basedir = $(dirname $(absname $(basefile)))

    $(mcr): $(dirname $(mcr)) $(ROOT_OMAKE)/debuggerdefs.partner.om $(depend_files)
        section
            f = $(fopen $(@), w)
            fprintln($(f),ESC)
            fprintln($(f),INITA)
            fprintln($(f),CORE 0)
            fprintln($(f),L "$(absname $(axf))")
            if $(axf_symbol)
                fprintln($(f),LSA "$(absname $(axf_symbol))")

            fprintln($(f),CD "$(basedir)")
            if $(not $(equal $(log),$(EMPTY)))
                fprintln($(f),$">" "$(absname $(log))")
            fprintln($(f),G)
            close($(f))

    if $(and $(defined TEST_ENVIRONMENT_PROCESSLIST), $(TEST_ENVIRONMENT_PROCESSLIST))
        $(log): $(mcr) $(depend_files) $(RUNNER) :effects: $(RUNNER_LOCK)
            bash $(RUNNER) $(mcr)

    return $(mcr)

private.IsEmpty(seq) =
    return $(eq 0, $(length $(seq)))

public.FilterTestAttributes(process) =

    if $(not $(defined TEST_ATTRIBUTES))
        TEST_ATTRIBUTES =
        export

    if $(not $(defined TEST_INCLUDE))
        TEST_INCLUDE = BASIC
        export
    else
        TEST_INCLUDE = $(split  $",",$(TEST_INCLUDE))
        export

    if $(not $(defined TEST_EXCLUDE))
        TEST_EXCLUDE =
        export
    else
        TEST_EXCLUDE = $(split  $",",$(TEST_EXCLUDE))
        export

    attributes = $(ParseDependProcess null, $(rootname $(process)), $(TEST_ATTRIBUTES))

    if $(IsEmpty $(attributes))
        attributes = BASIC
        export

    has_includes = $(filter $(TEST_INCLUDE), $(attributes))
    has_excludes = $(filter $(TEST_EXCLUDE), $(attributes))

    if $(and $(IsEmpty $(has_excludes)), $(not $(IsEmpty $(has_includes))))
        return $(process)

    return $(EMPTY)

public.FilterTest(sources) =

    filtered_sources = $(sources)

    if $(defined TEST_FILTER)
        regex = $"^\("$(compileToRegex $(TEST_FILTER))$"\)"\$
        filtered_sources =

        foreach( source, $(sources) )
            if $(isFilterMatch $(regex), $(rootname $(basename $(source))))
                filtered_sources += $(source)
                export filtered_sources
            export filtered_sources
        export filtered_sources

    return $(filtered_sources)

private.RunProgramBeforeTest(options, logfile) =
    if $(defined BEFORE_TEST)
        foreach(runner, $(BEFORE_TEST))
            runner.run($(options), logfile)

private.GetDependsBeforeTest() =
    ret =
        if $(defined BEFORE_TEST)
            foreach(runner, $(BEFORE_TEST))
                value $(runner.GetDepends)
    return $(ret)

private.RunProgramAfterTest(options, logfile) =
    if $(defined AFTER_TEST)
        foreach(runner, $(AFTER_TEST))
            runner.run($(options), logfile)

private.GetDependsAfterTest() =
    ret =
        if $(defined AFTER_TEST)
            foreach(runner, $(AFTER_TEST))
                value $(runner.GetDepends)
    return $(ret)

private.ParseDependProcesses(process, processlist) = 
    processes =
    basedir = $(dirname $(absname $(process)))

    foreach(proc, $(DEPEND_PROCESSES))
        if $(not $(proc))
            continue

        if $(findstring $(proc),$"^@")
            processes += $(absname $(file $(removeprefix $"@", $(proc))))
            export

        elseif $(findstring $(proc),$"^\.")
            processes += $(file $(absname $(proc)))
            export

        else
            tmp_image_dir = $(dirname $(proc))
            tmp_image_dir = $(absname $(addprefix $(basedir)$(DIRSEP)..$(DIRSEP)..$(DIRSEP),$(tmp_image_dir)))
            tmp_image     = $(addsuffix $(EXT_CDI),$(basename $(proc)))
            tmp_image     = $(addprefix $(config.getTargetSubDirectory false)$(DIRSEP),$(tmp_image))
            processes += $(file $(addprefix $(tmp_image_dir)$(DIRSEP),$(tmp_image)))
            export
        export

    return $(processes)

public.GetLoadrunOptions() =
    options =
    
    if $(and $(not $(defined RUN_TIMEOUT)), $(not $(IsEmpty $(filter dotests-%, $(TARGETS)))))
        RUN_TIMEOUT = 60
        export RUN_TIMEOUT

    if $(and $(not $(defined EXIT_PATTERN)), $(not $(IsEmpty $(filter dotests-%, $(TARGETS)))))
        EXIT_PATTERN=$"CU_TEST_EXIT|KernelPanic|nn::svc::Break\("
        export EXIT_PATTERN

    if $(and $(defined RUN_NOWAIT), $(RUN_NOWAIT))
        options += --no-wait
        export options

    if $(defined EXIT_PATTERN)
        options += --exit-pattern $(string $(EXIT_PATTERN))
        export options
    
    if $(defined RUN_TIMEOUT)
        options += --timeout $(RUN_TIMEOUT)
        export options

    if $(and $(defined-env CTR_RUN_DEVICE), $(not $(defined RUN_DEVICE)))
        RUN_DEVICE = $(getenv CTR_RUN_DEVICE)
        export

    if $(defined RUN_DEVICE)
        options += -d $(RUN_DEVICE)
        export options

    if $(and $(defined RUN_VARBOSE), $(RUN_VARBOSE))
        options += --varbose
        export options

    return $(options)

public.GetLoadrunOptionsForTool() =
    options =
    
    if $(and $(defined RUN_NOWAIT), $(RUN_NOWAIT))
        options += --no-wait
        export options

    return $(options)

public.FilesToRunProcessList(config, process) =
    process = $(filter %.cdi,$(process))
    if $(eq 0,$(length $(process)))
        return
    process = $(nth 0,$(process))

    export depend_files 
    depend_files = 

    export processes
    processes =

    kernel = $(config.getSuitableKernelFilename)
    kernel_core0 = $(gsub $(kernel),Kernel\.ARM946ES\.,Kernel.MPCore.)
    kernel_core2 = $(gsub $(kernel),Kernel\.MPCore\.,Kernel.ARM946ES.)

    if $(not $(and $(defined TEST_DEBUG_ARM9), $(TEST_DEBUG_ARM9)))
        kernel_core2 = $(gsub $(kernel_core2),Development,Release)
        kernel_core2 = $(gsub $(kernel_core2),Debug,Release)
        export

    log     = $(addsuffix .proclist.log,$(removesuffix $(process)))
    setuplog = $(addsuffix .proclist.setup.log,$(removesuffix $(process)))
    teardownlog = $(addsuffix .proclist.teardown.log,$(removesuffix $(process)))
    basedir = $(dirname $(absname $(process)))

    if $(defined DEPEND_PROCESSES)
        DEPEND_PROCESSES = $(ParseDependProcess $(config), $(removesuffix $(basename $(process))), $(DEPEND_PROCESSES))
        processes += $(ParseDependProcesses $(process), $(DEPEND_PROCESSES))
        export
    processes += $(absname $(process))

    if $(not $(SKIP_BUILD))
        depend_files += $(kernel_core0) $(kernel_core2)
        depend_files += $(processes)

    processes = $(addprefix @,$(processes))

    process_list = $(dirname $(kernel_core0))$(DIRSEP)process.list

    tooloptions = -c0 esc -c0 init -k11 $(kernel_core0) -k9 $(kernel_core2) -pl $(process_list) $(GetLoadrunOptionsForTool)

    if $(not $(and $(defined SKIP_RUN), $(SKIP_RUN)))
        if $(and $(defined TEST_ENVIRONMENT_PROCESSLIST), $(TEST_ENVIRONMENT_PROCESSLIST))
            $(log): $(LOADRUN) $(depend_files) $(GetDependsBeforeTest) $(GetDependsAfterTest) :effects: $(LOADRUN)  :value: $(random)
                if $(and $(defined LOGLIST), $(LOGLIST))
                    echo $(log) >> $(LOGLIST)
                if $(defined RUN_HOSTPROGRAM)
                    RUN_HOSTPROGRAM.run()
                RunProgramBeforeTest($(tooloptions), $(setuplog))
                section
                    f = $(fopen $(process_list), w)
                    foreach(filename, $(processes))
                        fprintln($(f), $(filename))
                    close($(f))

                $(LOADRUN) -c0 esc -c0 init -k11 $(kernel_core0) -k9 $(kernel_core2) $(GetLoadrunOptions) | tee $(absname $(log))
                RunProgramAfterTest($(tooloptions), $(teardownlog))
            depend_files += $(log)

        if $(filter run-proclist, $(TARGETS))
            $(log): $(LOADRUN) $(depend_files) $(GetDependsBeforeTest) $(GetDependsAfterTest) :effects: $(LOADRUN) :value: $(random)
                section
                    f = $(fopen $(process_list), w)
                    foreach(filename, $(processes))
                        fprintln($(f), $(filename))
                    close($(f))
                $(LOADRUN) -c0 esc -c0 init -k11 $(kernel_core0) -k9 $(kernel_core2) $(GetLoadrunOptions) | tee $(absname $(log))
            depend_files += $(log)
            export
        export
    return $(depend_files)

public.FilesToRunEmulationMemory(config, process) =

    process = $(filter %.cci %.csu,$(process))
    if $(eq 0,$(length $(process)))
        return
    process = $(nth 0,$(process))

    kernel = $(config.getSuitableKernelFilename)
    kernel_core0 = $(gsub $(kernel),Kernel\.ARM946ES\.,Kernel.MPCore.)
    kernel_core2 = $(gsub $(kernel),Kernel\.MPCore\.,Kernel.ARM946ES.)

    if $(not $(and $(defined TEST_DEBUG_ARM9), $(TEST_DEBUG_ARM9)))
        kernel_core2 = $(gsub $(kernel_core2),Development,Release)
        kernel_core2 = $(gsub $(kernel_core2),Debug,Release)
        export

    if $(and $(defined RUN_FAST_KERNEL), $(RUN_FAST_KERNEL))
        kernel_core0 = $(gsub $(kernel_core0),.small,.fast)
        kernel_core2 = $(gsub $(kernel_core2),.small,.fast)
        export

    export processes
    processes =

    export options
    options =

    export depend_files
    depend_files = 

    if $(defined DEPEND_PROCESSES)
        DEPEND_PROCESSES = $(ParseDependProcess $(config), $(removesuffix $(basename $(process))), $(DEPEND_PROCESSES))
        processes += $(ParseDependProcesses $(process), $(DEPEND_PROCESSES))
        export

    if $(not $(SKIP_BUILD))
        depend_files += $(process) $(kernel_core0) $(kernel_core2)
        depend_files += $(processes)

    foreach(proc, $(processes))
        options += -rp $(proc)

    if $(and $(defined RUN_FROMTESTMENU), $(RUN_FROMTESTMENU))
        options += -c0 "rdc $(process),0"
        options += -c0 "zn ID2_2=0x20"
        options += -rid 0004013000008002
        export
    else
        options += -re $(process)
        export

    log     = $(addsuffix .emumem.log,$(removesuffix $(process)))
    setuplog = $(addsuffix .proclist.setup.log,$(removesuffix $(process)))
    teardownlog = $(addsuffix .proclist.teardown.log,$(removesuffix $(process)))
    basedir = $(dirname $(absname $(process)))

    process_list = $(dirname $(kernel_core0))$(DIRSEP)process.list

    tooloptions = -c0 esc -c0 init -k11 $(kernel_core0) -k9 $(kernel_core2) -pl $(process_list) $(GetLoadrunOptionsForTool)

    if $(not $(and $(defined SKIP_RUN), $(SKIP_RUN)))
        if $(or $(and $(defined TEST_ENVIRONMENT_EMUMEM), $(TEST_ENVIRONMENT_EMUMEM))\
                $(and $(defined TEST_ENVIRONMENT_IMPORT), $(TEST_ENVIRONMENT_IMPORT)))
            $(log): $(LOADRUN) $(depend_files) $(GetDependsBeforeTest) $(GetDependsAfterTest) :effects: $(LOADRUN) :value: $(random)
                if $(and $(defined LOGLIST), $(LOGLIST))
                    echo $(log) >> $(LOGLIST)
                if $(defined RUN_HOSTPROGRAM)
                    RUN_HOSTPROGRAM.run()
                RunProgramBeforeTest($(tooloptions), $(setuplog))
                echo $(LOADRUN) -c0 esc -c0 init -k11 $(kernel_core0) -k9 $(kernel_core2) -pl $(process_list) $(options) $(GetLoadrunOptions)
                $(LOADRUN) -c0 esc -c0 init -k11 $(kernel_core0) -k9 $(kernel_core2) -pl $(process_list) $(options) $(GetLoadrunOptions) | tee $(absname $(log))
                RunProgramAfterTest($(tooloptions), $(teardownlog))
            depend_files += $(log)
            export
        export

        if $(filter run-emumem, $(TARGETS))
            $(log): $(LOADRUN) $(depend_files) $(GetDependsBeforeTest) $(GetDependsAfterTest) :effects: $(LOADRUN) :value: $(random)
                 $(LOADRUN) -c0 esc -c0 init -k11 $(kernel_core0) -k9 $(kernel_core2) -pl $(process_list) $(options) $(GetLoadrunOptions) | tee $(absname $(log))
            depend_files += $(log)
            export
        export

    return $(depend_files)

public.FilesToRunSPI(config, process) =
    process = $(filter %.cci,$(process))
    if $(eq 0,$(length $(process)))
        return
    process = $(nth 0,$(process))

    export depend_files
    depend_files = 
    if $(not $(SKIP_BUILD))
        depend_files += $(process)

    log     = $(addsuffix .spi.log,$(removesuffix $(process)))

    commands = -c esc -c reset
    commands += -c "RDC \"$(process)\",0"
    commands += -c NEWP

    if $(and $(defined TEST_ENVIRONMENT_SPI), $(TEST_ENVIRONMENT_SPI))
        $(log): $(LOADRUN_SPI) $(depend_files) :effects: $(LOADRUN_SPI) :value: $(random)
            $(LOADRUN_SPI) $(commands) $(GetLoadrunOptions) | tee $(absname $(log))
        depend_files += $(log)

    if $(filter run-spi, $(TARGETS))
        $(log): $(LOADRUN_SPI) $(depend_files) :effects: $(LOADRUN_SPI) :value: $(random)
            $(LOADRUN_SPI) $(commands) $(GetLoadrunOptions) | tee $(absname $(log))
        depend_files += $(log)

    return $(depend_files)

public.UserRunProcess(config, name, files) =
    TARGET_FILE = $(UserProcess $(config), $(name), $(files))
    LIST_PREFIX = $(removesuffix $(basename $(TARGET_FILE)))
    CCIFile = $(replacesuffixes $(EXT_ELF), $(EXT_CCI), $(TARGET_FILE))
    CIPFile = $(replacesuffixes $(EXT_ELF), $(EXT_CIP), $(TARGET_FILE))

    RUN_PROCLIST_FILES  = $(FilesToRunProcessList $(config),$(absname $(TARGET_FILE)))
    RUN_EMUMEM_FILES    = $(FilesToRunEmulationMemory $(config),$(absname $(TARGET_FILE)))
    RUN_SPI_FILES       = $(FilesToRunSPI $(config),$(absname $(TARGET_FILE)))

    if $(not $(defined RUN_FILTER))
        RUN_FILTER= *
        export

    if $(isFilterMatch $(compileToRegex $(RUN_FILTER)), $(config.getScannerName))
        run-proclist:   $(RUN_PROCLIST_FILES)
        run-scripts:    $(RUN_PROCLIST_FILES)
        run-emumem:     $(RUN_EMUMEM_FILES)
        run-spi:        $(RUN_SPI_FILES)

    return $(TARGET_FILE)