pEpACIDLang/idl/idl_api.ysl2

include standardlib.ysl2
// ----------------------------------------------------------------------
// stdlib candidates
// ----------------------------------------------------------------------
def "func:autocomma" {
    result if "position()!=last()" > ,
}

def "func:exists" {
    param "xpath";

    choose {
        when "$xpath"
            result "true()";
        otherwise
            result "false()";
    }
}

// ----------------------------------------------------------------------
// idl-api (ysl2)
// ----------------------------------------------------------------------

template "/" {
    choose {
        when "func:idl_static_analysis_is_ok()"
            apply "/pEpACIDLang", 0
    }
}

def "func:idl_static_analysis_is_ok" {
    const "pepacidlang_count", "count(/pEpACIDLang)";
    const "idl_count", "count(/pEpACIDLang/idl)";

    choose {
        when "$pepacidlang_count < 1"
            error > idl_static_analysis_is_ok - root node pEpACIDLang not found
        when "$idl_count < 1"
            error > idl_static_analysis_is_ok - pEpACIDLang idl data not found, include pEpACIDLang.yml2 exactly once.
        when "$idl_count < 1"
            error > idl_static_analysis_is_ok - ambiguous idl data, include pEpACIDLang.yml2 exactly once.
        otherwise
            result "true()";
    }
}

def "func:idl_get_package_name" {
    result "/pEpACIDLang/package/@name"
}

def "func:idl_get_package_version" {
    result "/pEpACIDLang/package/version/text()"
}

def "func:idl_get_package_license" {
    result "/pEpACIDLang/package/license/text()"
}

def "func:idl_get_basetypes" {
    result "///basetypes/*"
};


def "func:idl_typekind_is_defined" {
    param "typekind";
    result "func:exists(/pEpACIDLang/idl/typekinds//*[name()=$typekind])"
}

def "func:idl_typekind_is_generic" {
    param "typekind";
    result "func:exists(/pEpACIDLang/idl/typekinds/generics/*[name()=$typekind])"
}

def "func:idl_type_is_defined" {
    param "idltype";
    choose {
    when "func:idl_type_get_typekind_of_type($idltype)"
        result "true()";
    otherwise
        result "false()";
    }
}

def "func:idl_type_is_of_typekind_basetype" {
    param "idltype";
    result "func:exists(/pEpACIDLang/idl/basetypes/*[name()=$idltype])";
}

def "func:idl_type_is_of_typekind_deftype" {
    param "idltype";
    result "func:exists(//deftype[@name=$idltype])";
}

def "func:idl_type_is_of_typekind_enum" {
    param "idltype";
    result "func:exists(//enum[@name=$idltype])";
}

def "func:idl_type_is_of_typekind_struct" {
    param "idltype";
    result "func:exists(//struct[@name=$idltype])";
}

def "func:idl_type_is_generic" {
    param "idltype";
    result "contains($idltype,'<') and contains($idltype,'>')"
}


// TODO: generic is actually not a typekid, this should return the generic typekind like list/map/pair
def "func:idl_type_get_typekind_of_type" {
    param "idltype";
    choose {
        when "func:idl_type_is_of_typekind_basetype($idltype)"
            result > basetype
        when "func:idl_type_is_of_typekind_deftype($idltype)"
            result > deftype
        when "func:idl_type_is_of_typekind_enum($idltype)"
            result > enum
        when "func:idl_type_is_of_typekind_struct($idltype)"
            result > struct
        when "func:idl_type_is_generic($idltype)"
            result > generic
        otherwise
            result "false()";

    }
}

def "func:idl_type_get_resolved_type" {
    param "idltype";
    const "idltypekind", "func:idl_type_get_typekind_of_type($idltype)";

    choose {
        when "$idltypekind = 'deftype'"
            result "func:idl_type_get_resolved_type(func:idl_type_get_type_of_deftype($idltype))";
        otherwise
            result "$idltype";
    }
}

def "func:idl_type_get_type_of_deftype" {
    param "idltype";
    const "deftype", "//deftype[@name=$idltype]";
    const "type_or_typekind", "$deftype/as/@type";

    choose {
        when "func:idl_type_is_of_typekind_deftype($idltype)"
            choose {
                when "func:idl_typekind_is_generic($type_or_typekind)"
                    result call "idl_type_of_generic_deftype" with "deftype", "$deftype";
                otherwise
                    result "$type_or_typekind";
            }
        otherwise
            error > idl_resolve_deftype - is not a deftype: «$idltype»;
    }
}

function "idl_type_of_generic_deftype" {
    param "deftype";
    const "generic_type", "$deftype/as/@type";

    > «$generic_type»
    > <
    for "$deftype/as/generic/*" {
        const "param_type", "name()";
        > «$param_type»«func:autocomma()»
    }
    > >
}