paramset.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "paramset.h"
#include "mymalloc.h"
#include "endrun.h"

Include dependency graph for paramset.c:

Go to the source code of this file.

Classes
struct	ParameterValue
struct	ParameterSchema
struct	ParameterSet

Macros
#define	INT   1
#define	DOUBLE   3
#define	STRING   5
#define	ENUM   10
#define	NAMESIZE   128

Typedefs
typedef struct ParameterValue	ParameterValue
typedef struct ParameterSchema	ParameterSchema

Functions
static int	parse_enum (ParameterEnum *table, const char *strchoices)
static char *	format_enum (ParameterEnum *table, int value)
static ParameterSchema *	param_get_schema (ParameterSet *ps, const char *name)
static void	param_set_from_string (ParameterSet *ps, const char *name, char *value, int lineno)
static int	param_emit (ParameterSet *ps, char *start, int size, int lineno)
int	param_validate (ParameterSet *ps)
void	param_dump (ParameterSet *ps, FILE *stream)
int	param_parse (ParameterSet *ps, char *content)
int	param_parse_file (ParameterSet *ps, const char *filename)
static ParameterSchema *	param_declare (ParameterSet *ps, const char *name, const int type, const enum ParameterFlag required, const char *help)
void	param_declare_int (ParameterSet *ps, const char *name, const enum ParameterFlag required, const int defvalue, const char *help)
void	param_declare_double (ParameterSet *ps, const char *name, const enum ParameterFlag required, const double defvalue, const char *help)
void	param_declare_string (ParameterSet *ps, const char *name, const enum ParameterFlag required, const char *defvalue, const char *help)
void	param_declare_enum (ParameterSet *ps, const char *name, ParameterEnum *enumtable, const enum ParameterFlag required, const char *defvalue, const char *help)
void	param_set_action (ParameterSet *ps, const char *name, ParameterAction action, void *userdata)
int	param_is_nil (ParameterSet *ps, const char *name)
double	param_get_double (ParameterSet *ps, const char *name)
char *	param_get_string (ParameterSet *ps, const char *name)
void	param_get_string2 (ParameterSet *ps, const char *name, char *dst, size_t len)
int	param_get_int (ParameterSet *ps, const char *name)
int	param_get_enum (ParameterSet *ps, const char *name)
char *	param_format_value (ParameterSet *ps, const char *name)
ParameterSet *	parameter_set_new ()
void	parameter_set_free (ParameterSet *ps)

Macro Definition Documentation

DOUBLE

#define DOUBLE   3

Definition at line 12 of file paramset.c.

ENUM

#define ENUM   10

Definition at line 14 of file paramset.c.

INT

#define INT   1

Definition at line 11 of file paramset.c.

NAMESIZE

#define NAMESIZE   128

Definition at line 15 of file paramset.c.

STRING

#define STRING   5

Definition at line 13 of file paramset.c.

Typedef Documentation

ParameterSchema

typedef struct ParameterSchema ParameterSchema

ParameterValue

typedef struct ParameterValue ParameterValue

Function Documentation

format_enum()

static char* format_enum ( ParameterEnum *  table, int  value  )

static

Definition at line 44 of file paramset.c.

                                                            {
    int btotal = 200;
    int bleft = btotal;
    char * buffer = ta_malloc("formatbuffer", char, bleft);
    ParameterEnum * p;
    char * c = buffer;
    int first = 1;
    for(p = table; p->name && p->name[0]; p++) {
        if((value & p->value) == p->value) {
            if(!first) {
                *(c++) = ' ';
                *(c++) = '|';
                *(c++) = ' ';
            }
            first = 0;
            bleft-= strlen(p->name);
            if (bleft <= 0) {
                int extra = (- bleft) + btotal;
                buffer = (char *) myrealloc(buffer, btotal + extra);
                btotal += extra;
                bleft += extra;
                break;
            }
            /* The above ensures a large enough buffer*/
            strcpy(c, p->name);
            c += strlen(p->name);
        }
    }
    return buffer;
}

References myrealloc, ParameterEnum::name, ta_malloc, and ParameterEnum::value.

Referenced by param_format_value().

Here is the caller graph for this function:

param_declare()

static ParameterSchema* param_declare ( ParameterSet *  ps, const char *  name, const int  type, const enum ParameterFlag  required, const char *  help  )

static

Definition at line 247 of file paramset.c.

{
    int free = ps->size;
    strncpy(ps->p[free].name, name, NAMESIZE);
    //Make sure null terminated
    ps->p[free].name[NAMESIZE-1] = '\0';
    ps->p[free].required = required;
    ps->p[free].type = type;
    ps->p[free].index = free;
    ps->p[free].defvalue.nil = 1;
    ps->p[free].action = NULL;
    ps->p[free].defvalue.s = NULL;
    ps->p[free].defvalue.lineno = -1;
    if(help)
        ps->p[free].help = help;
    ps->size ++;
    return &ps->p[free];
}

References ParameterSchema::action, ParameterSchema::defvalue, ParameterSchema::help, ParameterSchema::index, ParameterValue::lineno, name, ParameterSchema::name, NAMESIZE, ParameterValue::nil, ParameterSet::p, ParameterSchema::required, ParameterValue::s, ParameterSet::size, and ParameterSchema::type.

Referenced by param_declare_double(), param_declare_enum(), param_declare_int(), and param_declare_string().

Here is the caller graph for this function:

param_declare_double()

void param_declare_double	(	ParameterSet *	ps,
		const char *	name,
		const enum ParameterFlag	required,
		const double	defvalue,
		const char *	help
	)

Definition at line 278 of file paramset.c.

{
    ParameterSchema * p = param_declare(ps, name, DOUBLE, required, help);
    if(required == OPTIONAL) {
        p->defvalue.d = defvalue;
        p->defvalue.nil = 0;
    } else {
        p->defvalue.nil = 1;
    }
}

References ParameterValue::d, ParameterSchema::defvalue, DOUBLE, name, ParameterValue::nil, OPTIONAL, and param_declare().

Referenced by create_gadget_parameter_set(), and create_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

param_declare_enum()

void param_declare_enum	(	ParameterSet *	ps,
		const char *	name,
		ParameterEnum *	enumtable,
		const enum ParameterFlag	required,
		const char *	defvalue,
		const char *	help
	)

Definition at line 307 of file paramset.c.

{
    ParameterSchema * p = param_declare(ps, name, ENUM, required, help);
    p->enumtable = enumtable;
    if(required == OPTIONAL) {
        p->defvalue.i = parse_enum(enumtable, defvalue);
        /* Watch out, if enumtable is malloced we may core dump if it gets freed */
        p->defvalue.nil = 0;
    } else {
        p->defvalue.nil = 1;
    }
}

References ParameterSchema::defvalue, ENUM, ParameterSchema::enumtable, ParameterValue::i, name, ParameterValue::nil, OPTIONAL, param_declare(), and parse_enum().

Referenced by create_gadget_parameter_set().

Here is the call graph for this function:

Here is the caller graph for this function:

param_declare_int()

void param_declare_int	(	ParameterSet *	ps,
		const char *	name,
		const enum ParameterFlag	required,
		const int	defvalue,
		const char *	help
	)

Definition at line 267 of file paramset.c.

{
    ParameterSchema * p = param_declare(ps, name, INT, required, help);
    if(required == OPTIONAL) {
        p->defvalue.i = defvalue;
        p->defvalue.nil = 0;
    } else {
        p->defvalue.nil = 1;
    }
}

References ParameterSchema::defvalue, ParameterValue::i, INT, name, ParameterValue::nil, OPTIONAL, and param_declare().

Referenced by create_gadget_parameter_set(), and create_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

param_declare_string()

void param_declare_string	(	ParameterSet *	ps,
		const char *	name,
		const enum ParameterFlag	required,
		const char *	defvalue,
		const char *	help
	)

Definition at line 289 of file paramset.c.

{
    ParameterSchema * p = param_declare(ps, name, STRING, required, help);
    if(required == OPTIONAL) {
        if(defvalue != NULL) {
            p->defvalue.s = fastpm_strdup(defvalue);
            p->defvalue.nil = 0;
        } else {
            /* The handling of nil is not consistent yet! Only string can be non-required and have nil value.
             * blame bad function signature (noway to define nil for int and double. */
            p->defvalue.s = NULL;
            p->defvalue.nil = 1;
        }
    } else {
        p->defvalue.nil = 1;
    }
}

References ParameterSchema::defvalue, fastpm_strdup(), name, ParameterValue::nil, OPTIONAL, param_declare(), ParameterValue::s, and STRING.

Referenced by create_gadget_parameter_set(), and create_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

param_dump()

void param_dump	(	ParameterSet *	ps,
		FILE *	stream
	)

Definition at line 192 of file paramset.c.

{
    int i;
    for(i = 0; i < ps->size; i ++) {
        ParameterSchema * p = &ps->p[i];
        char * v = param_format_value(ps, p->name);
        if(ps->value[i].lineno >= 0) {
            fprintf(stream, "%-31s %-20s # Line %03d # %s \n", p->name, v, ps->value[i].lineno, p->help);
        } else {
            fprintf(stream, "%-31s %-20s # Default  # %s \n", p->name, v, p->help);
        }
        myfree(v);
    }
    fflush(stream);
}

References ParameterSchema::help, ParameterValue::lineno, myfree, ParameterSchema::name, ParameterSet::p, param_format_value(), ParameterSet::size, and ParameterSet::value.

Referenced by read_parameter_file(), and read_parameterfile().

Here is the call graph for this function:

Here is the caller graph for this function:

param_emit()

static int param_emit ( ParameterSet *  ps, char *  start, int  size, int  lineno  )

static

Definition at line 117 of file paramset.c.

{
    /* parse a line */
    if (size == 0) return 0;
    char * buf = ta_malloc2("line", char, size + 1);
    static char blanks[] = " \t\r\n=";
    static char comments[] =  "%#";
    strncpy(buf, start, size);
    buf[size] = 0;
 
    /* blank lines are OK */
    const char * name = NULL;
    char * value = NULL;
    char * ptr = buf;
 
    /* parse name */
    while(*ptr && strchr(blanks, *ptr)) ptr++;
    if (*ptr == 0 || strchr(comments, *ptr)) {
        /* This line is fully comment */
        myfree(buf);
        return 0;
    }
    name = ptr;
    while(*ptr && !strchr(blanks, *ptr)) ptr++;
    *ptr = 0;
    ptr++;
 
    /* parse value */
    while(*ptr && strchr(blanks, *ptr)) ptr++;
 
    if (*ptr == 0 || strchr(comments, *ptr)) {
        /* This line is malformed, must have a value! */
        strncpy(buf, start, size);
        message(0, "Line %d : `%s` is malformed.\n", lineno, buf);
        myfree(buf);
        return 1;
    }
    value = ptr;
    while(*ptr && !strchr(comments, *ptr)) ptr++;
    *ptr = 0;
    ptr++;
 
    /* now this line is important */
    ParameterSchema * p = param_get_schema(ps, name);
    if(!p) {
        message(0, "Line %d: Parameter `%s` is unknown.\n", lineno, name);
        myfree(buf);
        return 1;
    }
    param_set_from_string(ps, name, value, lineno);
    if(p->action) {
        if(0 != p->action(ps, name, p->action_data)) {
            message(0, "Triggering Action on `%s` failed.\n", name);
            myfree(buf);
            return 1;
        }
    }
    myfree(buf);
    return 0;
}

References ParameterSchema::action, ParameterSchema::action_data, message(), myfree, name, param_get_schema(), param_set_from_string(), and ta_malloc2.

Referenced by param_parse().

Here is the call graph for this function:

Here is the caller graph for this function:

param_format_value()

char* param_format_value	(	ParameterSet *	ps,
		const char *	name
	)

Definition at line 388 of file paramset.c.

{
    ParameterSchema * p = param_get_schema(ps, name);
    if(ps->value[p->index].nil) {
        return fastpm_strdup("UNDEFINED");
    }
    switch(p->type) {
        case INT:
        {
            int i = ps->value[p->index].i;
            char buf[128];
            snprintf(buf, 128, "%d", i);
            return fastpm_strdup(buf);
        }
        break;
        case DOUBLE:
        {
            double d = ps->value[p->index].d;
            char buf[128];
            snprintf(buf, 128, "%g", d);
            return fastpm_strdup(buf);
        }
        break;
        case STRING:
        {
            return fastpm_strdup(ps->value[p->index].s);
        }
        break;
        case ENUM:
        {
            return format_enum(p->enumtable, ps->value[p->index].i);
        }
        break;
    }
    return fastpm_strdup("UNDEFINED TYPE");
}

References ParameterValue::d, DOUBLE, ENUM, ParameterSchema::enumtable, fastpm_strdup(), format_enum(), ParameterValue::i, ParameterSchema::index, INT, name, ParameterValue::nil, param_get_schema(), ParameterValue::s, STRING, ParameterSchema::type, and ParameterSet::value.

Referenced by param_dump().

Here is the call graph for this function:

Here is the caller graph for this function:

param_get_double()

double param_get_double	(	ParameterSet *	ps,
		const char *	name
	)

Definition at line 336 of file paramset.c.

{
    ParameterSchema * p = param_get_schema(ps, name);
    if (param_is_nil(ps, name)) {
        message(0, "Accessing an undefined parameter `%s`.\n", p->name);
    }
    return ps->value[p->index].d;
}

References ParameterValue::d, ParameterSchema::index, message(), name, ParameterSchema::name, param_get_schema(), param_is_nil(), and ParameterSet::value.

Referenced by read_parameter_file(), read_parameterfile(), set_all_global_params(), set_blackhole_params(), set_cooling_params(), set_density_params(), set_domain_params(), set_fof_params(), set_gravshort_tree_params(), set_hydro_params(), set_init_params(), set_metal_return_params(), set_qso_lightup_params(), set_sfr_params(), set_timestep_params(), and set_winds_params().

Here is the call graph for this function:

Here is the caller graph for this function:

param_get_enum()

int param_get_enum	(	ParameterSet *	ps,
		const char *	name
	)

Definition at line 378 of file paramset.c.

{
    ParameterSchema * p = param_get_schema(ps, name);
    if (param_is_nil(ps, name)) {
        message(0, "Accessing an undefined parameter `%s`.\n", p->name);
    }
    return ps->value[p->index].i;
}

References ParameterValue::i, ParameterSchema::index, message(), name, ParameterSchema::name, param_get_schema(), param_is_nil(), and ParameterSet::value.

Referenced by BlackHoleFeedbackMethodAction(), set_all_global_params(), set_blackhole_params(), set_cooling_params(), set_density_params(), set_sfr_params(), set_winds_params(), and StarformationCriterionAction().

Here is the call graph for this function:

Here is the caller graph for this function:

param_get_int()

int param_get_int	(	ParameterSet *	ps,
		const char *	name
	)

Definition at line 368 of file paramset.c.

{
    ParameterSchema * p = param_get_schema(ps, name);
    if (param_is_nil(ps, name)) {
        message(0, "Accessing an undefined parameter `%s`.\n", p->name);
    }
    return ps->value[p->index].i;
}

References ParameterValue::i, ParameterSchema::index, message(), name, ParameterSchema::name, param_get_schema(), param_is_nil(), and ParameterSet::value.

Referenced by read_parameter_file(), read_parameterfile(), set_all_global_params(), set_blackhole_params(), set_cooling_params(), set_domain_params(), set_fof_params(), set_gravshort_tree_params(), set_hydro_params(), set_metal_return_params(), set_petaio_params(), set_qso_lightup_params(), set_sfr_params(), set_stats_params(), set_timestep_params(), and set_treewalk_params().

Here is the call graph for this function:

Here is the caller graph for this function:

param_get_schema()

static ParameterSchema* param_get_schema ( ParameterSet *  ps, const char *  name  )

static

Definition at line 102 of file paramset.c.

{
    int i;
    for(i = 0; i < ps->size; i ++) {
        if(!strcasecmp(ps->p[i].name, name)) {
            return &ps->p[i];
        }
    }
    return NULL;
}

References name, ParameterSchema::name, ParameterSet::p, and ParameterSet::size.

Referenced by param_emit(), param_format_value(), param_get_double(), param_get_enum(), param_get_int(), param_get_string(), param_get_string2(), param_is_nil(), param_set_action(), and param_set_from_string().

Here is the caller graph for this function:

param_get_string()

char* param_get_string	(	ParameterSet *	ps,
		const char *	name
	)

Definition at line 346 of file paramset.c.

{
    ParameterSchema * p = param_get_schema(ps, name);
    if (param_is_nil(ps, name)) {
        message(0, "Accessing an undefined parameter `%s`.\n", p->name);
    }
    return ps->value[p->index].s;
}

References ParameterSchema::index, message(), name, ParameterSchema::name, param_get_schema(), param_is_nil(), ParameterValue::s, and ParameterSet::value.

Referenced by OutputListAction(), and read_parameterfile().

Here is the call graph for this function:

Here is the caller graph for this function:

param_get_string2()

void param_get_string2	(	ParameterSet *	ps,
		const char *	name,
		char *	dst,
		size_t	len
	)

Definition at line 355 of file paramset.c.

{
    ParameterSchema * p = param_get_schema(ps, name);
    if (param_is_nil(ps, name)) {
        message(0, "Accessing an undefined parameter `%s`.\n", p->name);
    }
    if(strlen(ps->value[p->index].s) > len)
        endrun(1, "Parameter string %s too long for storage (%d)\n", ps->value[p->index].s, len);
    strncpy(dst, ps->value[p->index].s, len);
    dst[len-1]='\0';
}

References endrun(), ParameterSchema::index, message(), name, ParameterSchema::name, param_get_schema(), param_is_nil(), ParameterValue::s, and ParameterSet::value.

Referenced by read_parameterfile(), set_all_global_params(), set_petaio_params(), set_sfr_params(), and set_stats_params().

Here is the call graph for this function:

Here is the caller graph for this function:

param_is_nil()

int param_is_nil	(	ParameterSet *	ps,
		const char *	name
	)

Definition at line 329 of file paramset.c.

{
    ParameterSchema * p = param_get_schema(ps, name);
    return ps->value[p->index].nil;
}

References ParameterSchema::index, name, ParameterValue::nil, param_get_schema(), and ParameterSet::value.

Referenced by param_get_double(), param_get_enum(), param_get_int(), param_get_string(), and param_get_string2().

Here is the call graph for this function:

Here is the caller graph for this function:

param_parse()

int param_parse	(	ParameterSet *	ps,
		char *	content
	)

Definition at line 208 of file paramset.c.

{
    int i;
    /* copy over the default values, include nil values */
    for(i = 0; i < ps->size; i ++) {
        ps->value[ps->p[i].index] = ps->p[i].defvalue;
    }
    char * p = content;
    char * p1 = content; /* begining of a line */
    int flag = 0;
    int lineno = 0;
    while(1) {
        if(*p == '\n' || *p == 0) {
            int flag1 = param_emit(ps, p1, p - p1, lineno);
            flag |= flag1;
            if(*p == 0) break;
            p++;
            p1 = p;
            lineno ++;
        } else {
            p++;
        }
    }
    return flag;
}

References ParameterSchema::defvalue, ParameterSchema::index, ParameterSet::p, param_emit(), ParameterSet::size, and ParameterSet::value.

Referenced by param_parse_file().

Here is the call graph for this function:

Here is the caller graph for this function:

param_parse_file()

int param_parse_file	(	ParameterSet *	ps,
		const char *	filename
	)

Definition at line 234 of file paramset.c.

{
    char * content = fastpm_file_get_content(filename);
    if(content == NULL) {
        endrun(1, "Could not read file: %s\n", filename);
    }
    int val = param_parse(ps, content);
 
    myfree(content);
    return val;
}

References endrun(), fastpm_file_get_content(), myfree, and param_parse().

Referenced by read_parameter_file(), and read_parameterfile().

Here is the call graph for this function:

Here is the caller graph for this function:

param_set_action()

void param_set_action	(	ParameterSet *	ps,
		const char *	name,
		ParameterAction	action,
		void *	userdata
	)

Definition at line 321 of file paramset.c.

{
    ParameterSchema * p = param_get_schema(ps, name);
    p->action = action;
    p->action_data = userdata;
}

References ParameterSchema::action, ParameterSchema::action_data, name, and param_get_schema().

Referenced by create_gadget_parameter_set().

Here is the call graph for this function:

Here is the caller graph for this function:

param_set_from_string()

void param_set_from_string ( ParameterSet *  ps, const char *  name, char *  value, int  lineno  )

static

Definition at line 426 of file paramset.c.

{
    ParameterSchema * p = param_get_schema(ps, name);
    ps->value[p->index].lineno = lineno;
    switch(p->type) {
        case INT:
        {
            int i;
            sscanf(value, "%d", &i);
            ps->value[p->index].i = i;
            ps->value[p->index].nil = 0;
        }
        break;
        case DOUBLE:
        {
            double d;
            sscanf(value, "%lf", &d);
            ps->value[p->index].d = d;
            ps->value[p->index].nil = 0;
        }
        break;
        case STRING:
        {
            while(*value == ' ') value ++;
            ps->value[p->index].s = fastpm_strdup(value);
            char * a = ps->value[p->index].s;
            a += strlen(a) - 1;
            while(*a == ' ') {
                *a = 0;
                a--;
            }
            ps->value[p->index].nil = 0;
        }
        break;
        case ENUM:
        {
            char * v = fastpm_strdup(value);
            ps->value[p->index].i = parse_enum(p->enumtable, v);
            myfree(v);
            ps->value[p->index].nil = 0;
        }
        break;
    }
}

References ParameterValue::d, DOUBLE, ENUM, ParameterSchema::enumtable, fastpm_strdup(), ParameterValue::i, ParameterSchema::index, INT, ParameterValue::lineno, myfree, name, ParameterValue::nil, param_get_schema(), parse_enum(), ParameterValue::s, STRING, ParameterSchema::type, and ParameterSet::value.

Referenced by param_emit().

Here is the call graph for this function:

Here is the caller graph for this function:

param_validate()

int param_validate

(

ParameterSet *

ps

)

Definition at line 177 of file paramset.c.

{
    int i;
    int flag = 0;
    /* copy over the default values */
    for(i = 0; i < ps->size; i ++) {
        ParameterSchema * p = &ps->p[i];
        if(p->required == REQUIRED && ps->value[p->index].nil) {
            message(0, "Parameter `%s` is required, but not set.\n", p->name);
            flag = 1;
        }
    }
    return flag;
}

References ParameterSchema::index, message(), ParameterSchema::name, ParameterValue::nil, ParameterSet::p, ParameterSchema::required, REQUIRED, ParameterSet::size, and ParameterSet::value.

Referenced by read_parameter_file(), and read_parameterfile().

Here is the call graph for this function:

Here is the caller graph for this function:

parameter_set_free()

void parameter_set_free

(

ParameterSet *

ps

)

Definition at line 480 of file paramset.c.

                                      {
    /* Just reset the temp heap,
     * since that is where the paramset is allocated*/
    ta_reset();
    /*    int i;
     for(i = 0; i < ps->size; i ++) {
        if(ps->p[i].help) {
            myfree(ps->p[i].help);
        }
        if(ps->p[i].type == STRING) {
            if(ps->p[i].defvalue.s) {
                // FIXME: memory corruption
//                free(ps->p[i].defvalue.s);
            }
            if(ps->value[ps->p[i].index].s != ps->p[i].defvalue.s) {
                if(ps->value[ps->p[i].index].s) {
//                    free(ps->value[ps->p[i].index].s);
                }
            }
        }
    }
    myfree(ps);
    */
}

References ta_reset.

Referenced by read_parameter_file().

Here is the caller graph for this function:

parameter_set_new()

ParameterSet* parameter_set_new

(

)

Definition at line 472 of file paramset.c.

{
    ParameterSet * ps = ta_malloc("paramset", ParameterSet, 1);
    ps->size = 0;
    return ps;
}

References ParameterSet::size, and ta_malloc.

Referenced by create_gadget_parameter_set(), and create_parameters().

Here is the caller graph for this function:

parse_enum()

static int parse_enum ( ParameterEnum *  table, const char *  strchoices  )

static

Definition at line 17 of file paramset.c.

                                                                      {
    int value = 0;
    ParameterEnum * p = table;
    const char * delim = "\",;&| \t";
    char * token;
 
    char * strchoices2 = fastpm_strdup(strchoices);
    for(token = strtok(strchoices2, delim); token ; token = strtok(NULL, delim)) {
        for(p = table; p->name; p++) {
            if(strcasecmp(token, p->name) == 0) {
                value |= p->value;
                break;
            }
        }
        if(p->name == NULL) {
            /* error occured !*/
            myfree(strchoices2);
            return 0;
        }
    }
    if(value == 0) {
        /* none is specified, use default (NULL named entry) */
        value = p->value;
    }
    myfree(strchoices2);
    return value;
}

References fastpm_strdup(), myfree, ParameterEnum::name, and ParameterEnum::value.

Referenced by param_declare_enum(), and param_set_from_string().

Here is the call graph for this function:

Here is the caller graph for this function: