4

#include <assert.h>

     6

const struct config_option* config_lookup (const struct config_option *options, const char *name, struct error_info *err)

     8

    const struct config_option *option;

    13

            return option;

    14

    }

    15

    16

    // not found

    17

    SET_ERROR_STR(err, ERR_MODULE_CONF, "unknown configuration option");

    18

    19

    return NULL;

    20

}

    21

    22

/**

    23

 * Parse a raw value for a CONFIG_IRC_CHAN into an irc_chan

    24

 */

    25

static struct irc_chan* config_parse_irc_chan (struct nexus *nexus, char *raw_value, struct error_info *err)

    26

{

    27

    const char *network, *channel;

    28

    struct irc_chan *chan;

    29

    30

    // parse required args

    31

    if ((network = strsep(&raw_value, "/")) == NULL)

    32

        JUMP_SET_ERROR_STR(err, ERR_MODULE_CONF, "invalid <network> for CONFIG_IRC_CHAN value");

    33

    34

    if ((channel = strsep(&raw_value, "/")) == NULL)

    35

        JUMP_SET_ERROR_STR(err, ERR_MODULE_CONF, "invalid <channel> for CONFIG_IRC_CHAN value");

    36

    37

    // extraneous stuff?

    38

    if (raw_value)

    39

        JUMP_SET_ERROR_STR(err, ERR_MODULE_CONF, "trailing data for CONFIG_IRC_CHAN value");

    40

    41

    // get the channel?

    42

    if ((chan = irc_client_get_chan(nexus->client, network, channel)) == NULL)

    43

        JUMP_SET_ERROR_STR(err, ERR_MODULE_CONF, "unknown network/channel name for CONFIG_IRC_CHAN value");

    44

    45

    // ok

    46

    return chan;

    47

    48

error:

    49

    return NULL;    

    50

}

    51

    52

err_t config_parse (const struct config_option *option, struct nexus *nexus, struct config_value *value, char *raw_value, struct error_info *err)

    53

{

    54

    // parse the value 

    55

    switch (option->type) {

    56

        case CONFIG_STRING:

    57

            // simple!

    58

            value->string = raw_value;

    60

    61

        case CONFIG_IRC_CHAN:

    62

            // parse the value

    63

            if (!(value->irc_chan = config_parse_irc_chan(nexus, raw_value, err)))

    64

                return ERROR_CODE(err);

    65

    66

            break;

    67

    68

        default:

    69

            NOT_REACHED();

    72

    // copy the type

    73

    value->type = option->type;

    74

    75

    // ok

    76

    return SUCCESS; 

    77

}

    78

    79

err_t config_apply_opt (const struct config_option *option, void *ctx, const struct config_value *value, struct error_info *err)

    80

{

    81

    // wrong type?

    82

    if (option->type != value->type)

    83

        // XXX: info about type names

    84

        return SET_ERROR(err, ERR_CONFIG_TYPE);

    85

    86

    // null?

    87

    if (!value)

    88

        RETURN_SET_ERROR_STR(err, ERR_CONFIG_REQUIRED, option->name);

    89

    90

    // call the handler

    91

    switch (option->type) {

    92

        case CONFIG_STRING:     return option->func.string(ctx, value->string, err);

    93

        case CONFIG_IRC_CHAN:   return option->func.irc_chan(ctx, value->irc_chan, err);

    94

        default:                NOT_REACHED();

    95

    }

    96

}

    97

    98

err_t config_apply (const struct config_option *options, void *ctx, const char *name, const struct config_value *value, struct error_info *err)

    99

{

   100

    const struct config_option *option;

   101

   103

    if (!(option = config_lookup(options, name, err)))

   104

        return ERROR_CODE(err);

   105

   106

    // apply it    

   107

    return config_apply_opt(option, ctx, value, err);

   108

}

   110

err_t config_apply_string (const struct config_option *options, void *ctx, const char *name, char *value, struct error_info *err)

   111

{

   112

    struct config_value conf_value = { CONFIG_STRING, { .string = value } };

   113

   114

    return config_apply(options, ctx, name, &conf_value, err);

   116

   117

err_t config_apply_irc_chan (const struct config_option *options, void *ctx, const char *name, struct irc_chan *value, struct error_info *err)

   118

{

   119

    struct config_value conf_value = { CONFIG_STRING, { .irc_chan = value } };

   120

   121

    return config_apply(options, ctx, name, &conf_value, err);

   122

}

   123

   124

err_t config_apply_raw (const struct config_option *options, struct nexus *nexus, void *ctx, const char *name, char *raw_value, struct error_info *err)

   125

{

   126

    const struct config_option *option;

   127

    struct config_value value;

   128

   129

    // no matching option found?

   130

    if (!(option = config_lookup(options, name, err)))

   131

        return ERROR_CODE(err);

   132

   133

    // parse it

   134

    if (config_parse(option, nexus, &value, raw_value, err))

   135

        return ERROR_CODE(err);

   136

   137

    // apply it

   138

    return config_apply_opt(option, ctx, &value, err);

   139

}

   140