libs/alsa-lib-1.0.13/src/confmisc.c

Go to the documentation of this file.

/*
 *  Miscellaneous configuration helper functions
 *  Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>,
 *                        Jaroslav Kysela <perex@suse.cz>
 *
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as
 *   published by the Free Software Foundation; either version 2.1 of
 *   the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "local.h"

int snd_config_get_bool_ascii(const char *ascii)
{
        unsigned int k;
        static struct {
                const char *str;
                int val;
        } b[] = {
                { "0", 0 },
                { "1", 1 },
                { "false", 0 },
                { "true", 1 },
                { "no", 0 },
                { "yes", 1 },
                { "off", 0 },
                { "on", 1 },
        };
        for (k = 0; k < sizeof(b) / sizeof(*b); k++) {
                if (strcasecmp(b[k].str, ascii) == 0)
                        return b[k].val;
        }
        return -EINVAL;
}

int snd_config_get_bool(const snd_config_t *conf)
{
        long v;
        const char *str, *id;
        int err;

        err = snd_config_get_id(conf, &id);
        if (err < 0)
                return err;
        err = snd_config_get_integer(conf, &v);
        if (err >= 0) {
                if (v < 0 || v > 1) {
                _invalid_value:
                        SNDERR("Invalid value for %s", id);
                        return -EINVAL;
                }
                return v;
        }
        err = snd_config_get_string(conf, &str);
        if (err < 0) {
                SNDERR("Invalid type for %s", id);
                return -EINVAL;
        }
        err = snd_config_get_bool_ascii(str);
        if (err < 0)
                goto _invalid_value;
        return err;
}

int snd_config_get_ctl_iface_ascii(const char *ascii)
{
        long v;
        snd_ctl_elem_iface_t idx;
        if (isdigit(ascii[0])) {
                if (safe_strtol(ascii, &v) >= 0) {
                        if (v < 0 || v > SND_CTL_ELEM_IFACE_LAST)
                                return -EINVAL;
                        return v;
                }
        }
        for (idx = 0; idx <= SND_CTL_ELEM_IFACE_LAST; idx++) {
                if (strcasecmp(snd_ctl_elem_iface_name(idx), ascii) == 0)
                        return idx;
        }
        return -EINVAL;
}

int snd_config_get_ctl_iface(const snd_config_t *conf)
{
        long v;
        const char *str, *id;
        int err;

        err = snd_config_get_id(conf, &id);
        if (err < 0)
                return err;
        err = snd_config_get_integer(conf, &v);
        if (err >= 0) {
                if (v < 0 || v > SND_CTL_ELEM_IFACE_LAST) {
                _invalid_value:
                        SNDERR("Invalid value for %s", id);
                        return -EINVAL;
                }
                return v;
        }
        err = snd_config_get_string(conf, &str);
        if (err < 0) {
                SNDERR("Invalid type for %s", id);
                return -EINVAL;
        }
        err = snd_config_get_ctl_iface_ascii(str);
        if (err < 0)
                goto _invalid_value;
        return err;
}

/*
 *  Helper functions for the configuration file
 */

int snd_func_getenv(snd_config_t **dst, snd_config_t *root, snd_config_t *src,
                    snd_config_t *private_data)
{
        snd_config_t *n, *d;
        snd_config_iterator_t i, next;
        char *res, *def = NULL;
        int idx = 0, err, hit;
        
        err = snd_config_search(src, "vars", &n);
        if (err < 0) {
                SNDERR("field vars not found");
                goto __error;
        }
        err = snd_config_evaluate(n, root, private_data, NULL);
        if (err < 0) {
                SNDERR("error evaluating vars");
                goto __error;
        }
        err = snd_config_search(src, "default", &d);
        if (err < 0) {
                SNDERR("field default not found");
                goto __error;
        }
        err = snd_config_evaluate(d, root, private_data, NULL);
        if (err < 0) {
                SNDERR("error evaluating default");
                goto __error;
        }
        err = snd_config_get_ascii(d, &def);
        if (err < 0) {
                SNDERR("error getting field default");
                goto __error;
        }
        do {
                hit = 0;
                snd_config_for_each(i, next, n) {
                        snd_config_t *n = snd_config_iterator_entry(i);
                        const char *id, *ptr, *env;
                        long i;
                        if (snd_config_get_id(n, &id) < 0)
                                continue;
                        if (snd_config_get_type(n) != SND_CONFIG_TYPE_STRING) {
                                SNDERR("field %s is not a string", id);
                                err = -EINVAL;
                                goto __error;
                        }
                        err = safe_strtol(id, &i);
                        if (err < 0) {
                                SNDERR("id of field %s is not an integer", id);
                                err = -EINVAL;
                                goto __error;
                        }
                        if (i == idx) {
                                idx++;
                                err = snd_config_get_string(n, &ptr);
                                if (err < 0) {
                                        SNDERR("invalid string for id %s", id);
                                        err = -EINVAL;
                                        goto __error;
                                }
                                env = getenv(ptr);
                                if (env != NULL && *env != '\0') {
                                        res = strdup(env);
                                        goto __ok;
                                }
                                hit = 1;
                        }
                }
        } while (hit);
        res = def;
        def = NULL;
      __ok:
        err = res == NULL ? -ENOMEM : 0;
        if (err >= 0) {
                const char *id;
                err = snd_config_get_id(src, &id);
                if (err >= 0)
                        err = snd_config_imake_string(dst, id, res);
                free(res);
        }
      __error:
        free(def);
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_getenv, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

int snd_func_igetenv(snd_config_t **dst, snd_config_t *root, snd_config_t *src,
                     snd_config_t *private_data)
{
        snd_config_t *d;
        const char *str, *id;
        int err;
        long v;

        err = snd_func_getenv(&d, root, src, private_data);
        if (err < 0)
                return err;
        err = snd_config_get_string(d, &str);
        if (err < 0) {
                snd_config_delete(d);
                return err;
        }
        err = safe_strtol(str, &v);
        if (err < 0) {
                snd_config_delete(d);
                return err;
        }
        snd_config_delete(d);
        err = snd_config_get_id(src, &id);
        if (err < 0)
                return err;
        err = snd_config_imake_integer(dst, id, v);
        if (err < 0)
                return err;
        return 0;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_igetenv, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif
                
int snd_func_concat(snd_config_t **dst, snd_config_t *root, snd_config_t *src,
                    snd_config_t *private_data)
{
        snd_config_t *n;
        snd_config_iterator_t i, next;
        const char *id;
        char *res = NULL, *tmp;
        int idx = 0, len = 0, len1, err, hit;
        
        err = snd_config_search(src, "strings", &n);
        if (err < 0) {
                SNDERR("field strings not found");
                goto __error;
        }
        err = snd_config_evaluate(n, root, private_data, NULL);
        if (err < 0) {
                SNDERR("error evaluating strings");
                goto __error;
        }
        do {
                hit = 0;
                snd_config_for_each(i, next, n) {
                        snd_config_t *n = snd_config_iterator_entry(i);
                        char *ptr;
                        const char *id;
                        long i;
                        if (snd_config_get_id(n, &id) < 0)
                                continue;
                        err = safe_strtol(id, &i);
                        if (err < 0) {
                                SNDERR("id of field %s is not an integer", id);
                                err = -EINVAL;
                                goto __error;
                        }
                        if (i == idx) {
                                idx++;
                                err = snd_config_get_ascii(n, &ptr);
                                if (err < 0) {
                                        SNDERR("invalid ascii string for id %s", id);
                                        err = -EINVAL;
                                        goto __error;
                                }
                                len1 = strlen(ptr);
                                tmp = realloc(res, len + len1 + 1);
                                if (tmp == NULL) {
                                        free(ptr);
                                        free(res);
                                        err = -ENOMEM;
                                        goto __error;
                                }
                                memcpy(tmp + len, ptr, len1);
                                free(ptr);
                                len += len1;
                                tmp[len] = '\0';
                                res = tmp;
                                hit = 1;
                        }
                }
        } while (hit);
        if (res == NULL) {
                SNDERR("empty string is not accepted");
                err = -EINVAL;
                goto __error;
        }
        err = snd_config_get_id(src, &id);
        if (err >= 0)
                err = snd_config_imake_string(dst, id, res);
        free(res);
      __error:
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_concat, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

int snd_func_datadir(snd_config_t **dst, snd_config_t *root ATTRIBUTE_UNUSED,
                     snd_config_t *src, snd_config_t *private_data ATTRIBUTE_UNUSED)
{
        int err;
        const char *id;
        
        err = snd_config_get_id(src, &id);
        if (err < 0)
                return err;
        return snd_config_imake_string(dst, id, "/share" "/alsa");
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_datadir, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

static int open_ctl(long card, snd_ctl_t **ctl)
{
        char name[16];
        snprintf(name, sizeof(name), "hw:%li", card);
        name[sizeof(name)-1] = '\0';
        return snd_ctl_open(ctl, name, 0);
}

#if 0
static int string_from_integer(char **dst, long v)
{
        char str[32];
        char *res;
        sprintf(str, "%li", v);
        res = strdup(str);
        if (res == NULL)
                return -ENOMEM;
        *dst = res;
        return 0;
}
#endif

int snd_func_private_string(snd_config_t **dst, snd_config_t *root ATTRIBUTE_UNUSED,
                            snd_config_t *src, snd_config_t *private_data)
{
        int err;
        const char *str, *id;

        if (private_data == NULL)
                return snd_config_copy(dst, src);
        err = snd_config_test_id(private_data, "string");
        if (err) {
                SNDERR("field string not found");
                return -EINVAL;
        }
        err = snd_config_get_string(private_data, &str);
        if (err < 0) {
                SNDERR("field string is not a string");
                return err;
        }
        err = snd_config_get_id(src, &id);
        if (err >= 0)
                err = snd_config_imake_string(dst, id, str);
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_private_string, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

#ifndef DOC_HIDDEN
int snd_determine_driver(int card, char **driver)
{
        snd_ctl_t *ctl = NULL;
        snd_ctl_card_info_t *info;
        char *res = NULL;
        int err;

        assert(card >= 0 && card <= 32);
        err = open_ctl(card, &ctl);
        if (err < 0) {
                SNDERR("could not open control for card %li", card);
                goto __error;
        }
        snd_ctl_card_info_alloca(&info);
        err = snd_ctl_card_info(ctl, info);
        if (err < 0) {
                SNDERR("snd_ctl_card_info error: %s", snd_strerror(err));
                goto __error;
        }
        res = strdup(snd_ctl_card_info_get_driver(info));
        if (res == NULL)
                err = -ENOMEM;
        else {
                *driver = res;
                err = 0;
        }
      __error:
        if (ctl)
                snd_ctl_close(ctl);
        return err;
}
#endif

int snd_func_private_card_driver(snd_config_t **dst, snd_config_t *root ATTRIBUTE_UNUSED, snd_config_t *src,
                                 snd_config_t *private_data)
{
        char *driver;
        const char *id;
        int err;
        long card;

        err = snd_config_test_id(private_data, "card");
        if (err) {
                SNDERR("field card not found");
                return -EINVAL;
        }
        err = snd_config_get_integer(private_data, &card);
        if (err < 0) {
                SNDERR("field card is not an integer");
                return err;
        }
        if ((err = snd_determine_driver(card, &driver)) < 0)
                return err;
        err = snd_config_get_id(src, &id);
        if (err >= 0)
                err = snd_config_imake_string(dst, id, driver);
        free(driver);
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_private_card_driver, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

int snd_func_card_driver(snd_config_t **dst, snd_config_t *root, snd_config_t *src,
                         snd_config_t *private_data)
{
        snd_config_t *n, *val;
        char *str;
        long v;
        int err;
        
        err = snd_config_search(src, "card", &n);
        if (err < 0) {
                SNDERR("field card not found");
                return err;
        }
        err = snd_config_evaluate(n, root, private_data, NULL);
        if (err < 0) {
                SNDERR("error evaluating card");
                return err;
        }
        err = snd_config_get_ascii(n, &str);
        if (err < 0) {
                SNDERR("field card is not an integer or a string");
                return err;
        }
        v = snd_card_get_index(str);
        if (v < 0) {
                SNDERR("cannot find card '%s'", str);
                free(str);
                return v;
        }
        free(str);
        err = snd_config_imake_integer(&val, "card", v);
        if (err < 0)
                return err;
        err = snd_func_private_card_driver(dst, root, src, val);
        snd_config_delete(val);
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_card_driver, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

int snd_func_card_id(snd_config_t **dst, snd_config_t *root, snd_config_t *src,
                     snd_config_t *private_data)
{
        snd_config_t *n;
        char *res = NULL;
        snd_ctl_t *ctl = NULL;
        snd_ctl_card_info_t *info;
        const char *id;
        long v;
        int err;
        
        err = snd_config_search(src, "card", &n);
        if (err < 0) {
                SNDERR("field card not found");
                goto __error;
        }
        err = snd_config_evaluate(n, root, private_data, NULL);
        if (err < 0) {
                SNDERR("error evaluating card");
                goto __error;
        }
        err = snd_config_get_integer(n, &v);
        if (err < 0) {
                SNDERR("field card is not an integer");
                goto __error;
        }
        err = open_ctl(v, &ctl);
        if (err < 0) {
                SNDERR("could not open control for card %li", v);
                goto __error;
        }
        snd_ctl_card_info_alloca(&info);
        err = snd_ctl_card_info(ctl, info);
        if (err < 0) {
                SNDERR("snd_ctl_card_info error: %s", snd_strerror(err));
                goto __error;
        }
        res = strdup(snd_ctl_card_info_get_id(info));
        if (res == NULL) {
                err = -ENOMEM;
                goto __error;
        }
        err = snd_config_get_id(src, &id);
        if (err >= 0)
                err = snd_config_imake_string(dst, id, res);
        free(res);
      __error:
        if (ctl)
                snd_ctl_close(ctl);
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_card_id, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

int snd_func_pcm_id(snd_config_t **dst, snd_config_t *root, snd_config_t *src, void *private_data)
{
        snd_config_t *n;
        snd_ctl_t *ctl = NULL;
        snd_pcm_info_t *info;
        const char *id;
        long card, device, subdevice = 0;
        int err;
        
        err = snd_config_search(src, "card", &n);
        if (err < 0) {
                SNDERR("field card not found");
                goto __error;
        }
        err = snd_config_evaluate(n, root, private_data, NULL);
        if (err < 0) {
                SNDERR("error evaluating card");
                goto __error;
        }
        err = snd_config_get_integer(n, &card);
        if (err < 0) {
                SNDERR("field card is not an integer");
                goto __error;
        }
        err = snd_config_search(src, "device", &n);
        if (err < 0) {
                SNDERR("field device not found");
                goto __error;
        }
        err = snd_config_evaluate(n, root, private_data, NULL);
        if (err < 0) {
                SNDERR("error evaluating device");
                goto __error;
        }
        err = snd_config_get_integer(n, &device);
        if (err < 0) {
                SNDERR("field device is not an integer");
                goto __error;
        }
        if (snd_config_search(src, "subdevice", &n) >= 0) {
                err = snd_config_evaluate(n, root, private_data, NULL);
                if (err < 0) {
                        SNDERR("error evaluating subdevice");
                        goto __error;
                }
                err = snd_config_get_integer(n, &subdevice);
                if (err < 0) {
                        SNDERR("field subdevice is not an integer");
                        goto __error;
                }
        }
        err = open_ctl(card, &ctl);
        if (err < 0) {
                SNDERR("could not open control for card %li", card);
                goto __error;
        }
        snd_pcm_info_alloca(&info);
        snd_pcm_info_set_device(info, device);
        snd_pcm_info_set_subdevice(info, subdevice);
        err = snd_ctl_pcm_info(ctl, info);
        if (err < 0) {
                SNDERR("snd_ctl_pcm_info error: %s", snd_strerror(err));
                goto __error;
        }
        err = snd_config_get_id(src, &id);
        if (err >= 0)
                err = snd_config_imake_string(dst, id, snd_pcm_info_get_id(info));
      __error:
        if (ctl)
                snd_ctl_close(ctl);
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_pcm_id, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

int snd_func_pcm_args_by_class(snd_config_t **dst, snd_config_t *root, snd_config_t *src, void *private_data)
{
        snd_config_t *n;
        snd_ctl_t *ctl = NULL;
        snd_pcm_info_t *info;
        const char *id;
        int card = -1, dev;
        long class, index;
        int idx = 0;
        int err;

        err = snd_config_search(src, "class", &n);
        if (err < 0) {
                SNDERR("field class not found");
                goto __out;
        }
        err = snd_config_evaluate(n, root, private_data, NULL);
        if (err < 0) {
                SNDERR("error evaluating class");
                goto __out;
        }
        err = snd_config_get_integer(n, &class);
        if (err < 0) {
                SNDERR("field class is not an integer");
                goto __out;
        }
        err = snd_config_search(src, "index", &n);
        if (err < 0) {
                SNDERR("field index not found");
                goto __out;
        }
        err = snd_config_evaluate(n, root, private_data, NULL);
        if (err < 0) {
                SNDERR("error evaluating index");
                goto __out;
        }
        err = snd_config_get_integer(n, &index);
        if (err < 0) {
                SNDERR("field index is not an integer");
                goto __out;
        }

        snd_pcm_info_alloca(&info);
        while(1) {
                err = snd_card_next(&card);
                if (err < 0) {
                        SNDERR("could not get next card");
                        goto __out;
                }
                if (card < 0)
                        break;
                err = open_ctl(card, &ctl);
                if (err < 0) {
                        SNDERR("could not open control for card %li", card);
                        goto __out;
                }
                dev = -1;
                memset(info, 0, snd_pcm_info_sizeof());
                while(1) {
                        err = snd_ctl_pcm_next_device(ctl, &dev);
                        if (err < 0) {
                                SNDERR("could not get next pcm for card %li", card);
                                goto __out;
                        }
                        if (dev < 0)
                                break;
                        snd_pcm_info_set_device(info, dev);
                        err = snd_ctl_pcm_info(ctl, info);
                        if (err < 0)
                                continue;
                        if (snd_pcm_info_get_class(info) == (snd_pcm_class_t)class &&
                                        index == idx++)
                                goto __out;
                }
                snd_ctl_close(ctl);
                ctl = NULL;
        }
        err = -ENODEV;

      __out:
        if (ctl)
                snd_ctl_close(ctl);
        if (err < 0)
                return err;
        if((err = snd_config_get_id(src, &id)) >= 0) {
                char name[32], *s;
                snprintf(name, sizeof(name), "CARD=%i,DEV=%i", card, dev);
                if (!(s = strdup(name)))
                        return -ENOMEM;
                err = snd_config_imake_string(dst, id, s);
        }
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_pcm_args_by_class, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

int snd_func_private_pcm_subdevice(snd_config_t **dst, snd_config_t *root ATTRIBUTE_UNUSED,
                                   snd_config_t *src, snd_config_t *private_data)
{
        snd_pcm_info_t *info;
        const char *id;
        const void *data;
        snd_pcm_t *pcm;
        int err;

        if (private_data == NULL)
                return snd_config_copy(dst, src);
        err = snd_config_test_id(private_data, "pcm_handle");
        if (err) {
                SNDERR("field pcm_handle not found");
                return -EINVAL;
        }
        err = snd_config_get_pointer(private_data, &data);
        pcm = (snd_pcm_t *)data;
        if (err < 0) {
                SNDERR("field pcm_handle is not a pointer");
                return err;
        }
        snd_pcm_info_alloca(&info);
        err = snd_pcm_info(pcm, info);
        if (err < 0) {
                SNDERR("snd_ctl_pcm_info error: %s", snd_strerror(err));
                return err;
        }
        err = snd_config_get_id(src, &id);
        if (err >= 0)
                err = snd_config_imake_integer(dst, id, snd_pcm_info_get_subdevice(info));
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_private_pcm_subdevice, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

int snd_func_refer(snd_config_t **dst, snd_config_t *root, snd_config_t *src,
                   snd_config_t *private_data)
{
        snd_config_t *n;
        const char *file = NULL, *name = NULL;
        int err;
        
        err = snd_config_search(src, "file", &n);
        if (err >= 0) {
                err = snd_config_evaluate(n, root, private_data, NULL);
                if (err < 0) {
                        SNDERR("error evaluating file");
                        goto _end;
                }
                err = snd_config_get_string(n, &file);
                if (err < 0) {
                        SNDERR("file is not a string");
                        goto _end;
                }
        }
        err = snd_config_search(src, "name", &n);
        if (err >= 0) {
                err = snd_config_evaluate(n, root, private_data, NULL);
                if (err < 0) {
                        SNDERR("error evaluating name");
                        goto _end;
                }
                err = snd_config_get_string(n, &name);
                if (err < 0) {
                        SNDERR("name is not a string");
                        goto _end;
                }
        }
        if (!name) {
                err = -EINVAL;
                SNDERR("name is not specified");
                goto _end;
        }
        if (file) {
                snd_input_t *input;
                err = snd_input_stdio_open(&input, file, "r");
                if (err < 0) {
                        SNDERR("Unable to open file %s: %s", file, snd_strerror(err));
                        goto _end;
                }
                err = snd_config_load(root, input);
                snd_input_close(input);
                if (err < 0)
                        goto _end;
        }
        err = snd_config_search_definition(root, NULL, name, dst);
        if (err >= 0) {
                const char *id;
                err = snd_config_get_id(src, &id);
                if (err >= 0)
                        err = snd_config_set_id(*dst, id);
        } else {
                err = snd_config_search(src, "default", &n);
                if (err < 0)
                        SNDERR("Unable to find definition '%s'", name);
                else {
                        const char *id;
                        err = snd_config_evaluate(n, root, private_data, NULL);
                        if (err < 0)
                                return err;
                        if ((err = snd_config_copy(dst, n)) >= 0) {
                                if ((err = snd_config_get_id(src, &id)) < 0 ||
                                    (err = snd_config_set_id(*dst, id)) < 0)
                                        snd_config_delete(*dst);
                        }
                }
        }
 _end:
        return err;
}
#ifndef DOC_HIDDEN
SND_DLSYM_BUILD_VERSION(snd_func_refer, SND_CONFIG_DLSYM_VERSION_EVALUATE);
#endif

---