# Copyright 2001, 2002 Dave Abrahams 
# Copyright 2002, 2003, 2004, 2005 Vladimir Prus 
# Distributed under the Boost Software License, Version 1.0. 
# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) 

import "class" : is-instance ;
import errors ;

rule ungrist ( names * )
{
    local result ;
    for local name in $(names)
    {
        local stripped = [ MATCH ^<(.*)>$ : $(name) ] ;
        if ! $(stripped)
        {
            errors.error "in ungrist" $(names) : $(name) is not of the form <.*> ;
        }
        result += $(stripped) ;
    }
    return $(result) ;
}

# Return the file of the caller of the rule that called caller-file.
rule caller-file ( )
{
    local bt = [ BACKTRACE ] ;
    return $(bt[9]) ;
}

# Returns the textual representation of argument. If it is a class
# instance, class its 'str' method. Otherwise, returns the argument.
rule str ( value )
{
    if [ is-instance $(value) ] 
    {
        return [ $(value).str ] ;
    }
    else
    {
        return $(value) ;
    }            
}

# Tests if 'a' is equal to 'b'. If 'a' is a class instance,
# calls its 'equal' method. Uses ordinary jam's comparison otherwise.
rule equal ( a b )
{
    if [ is-instance $(a) ] 
    {
        return [ $(a).equal $(b) ] ;
    }
    else
    {
        if $(a) = $(b) 
        {
            return true ;
        }
    }
}

# Tests if 'a' is less than 'b'. If 'a' is a class instance, 
# calls its 'less' method. Uses ordinary jam's comparison otherwise.
rule less ( a b )
{
    if [ is-instance $(a) ]
    {
        return [ $(a).less $(b) ] ;
    }
    else
    {
        if $(a) < $(b)
        {
            return true ;
        }
    }
}

# For all elements of 'list' which do not already have 'suffix',
# add 'suffix'.
rule apply-default-suffix ( suffix : list * )
{
    local result ;
    for local i in $(list)
    {
        if $(i:S) = $(suffix)
        {
            result += $(i) ;
        }
        else
        {
            result += $(i)$(suffix) ;
        }        
    }
    return $(result) ;    
}

# If 'name' contains a dot, returns the part before the last dot.
# If 'name' contains no dot, returns it unmodified.
rule basename ( name )
{    
    if $(name:S)
    {
        name = $(name:B) ;
    }
    return $(name) ;
}



local rule __test__ ( )
{
    import assert ;
    import "class" : new ;
    assert.result foo bar : ungrist <foo> <bar> ;

    assert.result 123 : str 123 ;

    class test-class__ 
    {
        rule __init__ ( )
        {            
        }
        
        rule str ( )
        {
            return "str-test-class" ;
        }

        rule less ( a )
        {
            return "yes, of course!" ;
        }

        rule equal ( a )
        {
            return "not sure" ;
        }
    }

    assert.result "str-test-class" : str [ new test-class__ ] ;
    assert.true less 1 2 ;
    assert.false less 2 1 ;
    assert.result "yes, of course!" : less [ new test-class__ ] 1 ;
    assert.true equal 1 1 ;
    assert.false equal 1 2 ;
    assert.result "not sure" : equal [ new test-class__ ] 1 ;
    
    assert.result foo.lib foo.lib : apply-default-suffix .lib : foo.lib foo.lib ;
    
    assert.result foo : basename foo ;
    assert.result foo : basename foo.so ;
    assert.result foo.so : basename foo.so.1 ;
}