Ticket #3798: Jamfile

SubDir HAIKU_TOP ;


rule FSplitString string : delimiterChar
{
    local result ;

    while $(string) {
        local split = [ Match $(delimiterChar)*([^$(delimiterChar)]+)(.*)
            : $(string) ] ;
        result += $(split[1]) ;
        string = $(split[2-]) ;
    }

    return $(result) ;
}


HAIKU_ARCH = x86 ;
HAIKU_BUILD_FEATURES = ;

rule FMatchesSet elements : set
{
    local hasPositive ;
    local hasNegative ;
    local positiveMatch ;
    local element ;
    for element in $(elements) {
        switch $(element) {
            case !* :
            {
                hasNegative = 1 ;
                element = [ Match "!(.*)" : $(element) ] ;
                if $(element) in $(set) {
                    return ;
                }
            }
            case * :
            {
                hasPositive = 1 ;
                if $(element) in $(set) {
                    positiveMatch = 1 ;
                }
            }
        }
    }

    if $(hasPositive) {
        return $(positiveMatch) ;
    }
    return $(hasNegative) ;
}

rule FIsBuildFeatureEnabled feature
{
    if $(feature) in $(HAIKU_BUILD_FEATURES) {
        return 1 ;
    }

    return ;
}

rule FMatchesBuildFeatures specification
{
    local splitSpecification ;
    local element ;
    for element in $(specification) {
        splitSpecification += [ FSplitString $(element) : "," ] ;
    }
    return [ FMatchesSet $(splitSpecification) : $(HAIKU_BUILD_FEATURES) ] ;
}

rule FFilterByBuildFeatures list
{
    local filteredList ;

    # Since we must look ahead one element to be able to decide whether an
    # element is a regular list element or a features specification for a
    # subsequent "@{". Hence we always process an element other than "@{" and
    # "}@" in the next iteration. We append a dummy element to the list so we
    # don't need special handling for the last element.
    local evaluationStack = 1 ;
    local previousElement ;
    local element ;
    for element in $(list) dummy {
        local stackTop = $(evaluationStack[1]) ;
        local processElement = $(previousElement) ;
        switch $(element) {
            case }@ :
            {
                # Pop the topmost specificaton off the stack.
                evaluationStack = $(evaluationStack[2-]) ;
                if ! $(evaluationStack) {
                    Exit "FFilterByBuildFeatures: Unbalanced @( in: " $(list) ;
                }

                processElement = $(previousElement) ;
                previousElement = ;
            }
            case @{ :
            {
                if ! $(previousElement) {
                    Exit "FFilterByBuildFeatures: No feature specification"
                        "after )@ in: " $(list) ;
                }

                if $(evaluationStack[1]) = 1
                    && [ FMatchesBuildFeatures $(previousElement) ] {
                    evaluationStack = 1 $(evaluationStack) ;
                } else {
                    evaluationStack = 0 $(evaluationStack) ;
                }

                processElement = ;
                previousElement = ;
            }
            case * :
            {
                processElement = $(previousElement) ;
                previousElement = $(element) ;
            }
        }

        if $(processElement) && $(stackTop) = 1 {
            local splitElement = [ Match "(.*)@([^@]*)" : $(processElement) ] ;
            if $(splitElement) {
                if [ FMatchesBuildFeatures $(splitElement[2]) ] {
                    filteredList += $(splitElement[1]) ;
                }
            } else {
                filteredList += $(processElement) ;
            }
        }
    }

    if $(evaluationStack[2-]) {
        Exit "FFilterByBuildFeatures: Unbalanced )@ in: " $(list) ;
    }

    return $(filteredList) ;
}

rule EnableBuildFeatures features : architectures
{
    if ! $(architectures)
        || [ FMatchesSet $(architectures) : $(HAIKU_BUILD_FEATURES) ] {
        local feature ;
        for feature in $(features) {
            HAIKU_BUILD_FEATURES += $(feature) ;
            HAIKU_$(feature:U)_ENABLED = 1 ;
        }
    }
}

EnableBuildFeatures $(HAIKU_ARCH) ;

EnableBuildFeatures opengl ffmpeg freebsd_network : x86 ;

Echo HAIKU_BUILD_FEATURES: $(HAIKU_BUILD_FEATURES) ;

local testSpecifications =
    x86
    !x86
    ppc
    !ppc
    !ppc,!arm
    !ppc,!x86
    opengl
    !ffmpeg,x86
    freebsd_network,!ppc,!arm
;

local testSpecification ;
for testSpecification in $(testSpecifications) {
    Echo $(testSpecification) "->"
        [ FMatchesBuildFeatures $(testSpecification) ] ;
}

local testList1 =
    foo
    bar@ppc
    foobar@x86
;

local testList2 =
    foo
    opengl @(
        bar@ppc
        foobar@x86
    )@
;

local testList3 =
    a
    b

    opengl @{
        c
        !ppc @{
            d@x86
            e
        }@ #
        f
    }@  # opengl

    arm @{
        g
        h
    }@ # arm

    i
    j
;

local i ;
for i in 1 2 3 {
    local testList = $(testList$(i)) ;
    Echo testList$(i): $(testList) ;
    Echo "  ->" [ FFilterByBuildFeatures $(testList) ] ;
}