Return to enum.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / utils

Annotation of embedaddon/strongswan/src/libstrongswan/utils/enum.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * Copyright (C) 2006 Martin Willi
        !             3:  * HSR Hochschule fuer Technik Rapperswil
        !             4:  *
        !             5:  * This program is free software; you can redistribute it and/or modify it
        !             6:  * under the terms of the GNU General Public License as published by the
        !             7:  * Free Software Foundation; either version 2 of the License, or (at your
        !             8:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
        !             9:  *
        !            10:  * This program is distributed in the hope that it will be useful, but
        !            11:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            12:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
        !            13:  * for more details.
        !            14:  */
        !            15: 
        !            16: #include <stddef.h>
        !            17: #include <stdio.h>
        !            18: 
        !            19: #include <library.h>
        !            20: #include <utils/utils.h>
        !            21: 
        !            22: #include "enum.h"
        !            23: 
        !            24: /**
        !            25:  * See header.
        !            26:  */
        !            27: char *enum_to_name(enum_name_t *e, int val)
        !            28: {
        !            29:        if (!e)
        !            30:        {
        !            31:                return NULL;
        !            32:        }
        !            33:        do
        !            34:        {
        !            35:                if (val >= e->first && val <= e->last)
        !            36:                {
        !            37:                        return e->names[val - e->first];
        !            38:                }
        !            39:        }
        !            40:        while ((e = e->next));
        !            41:        return NULL;
        !            42: }
        !            43: 
        !            44: /**
        !            45:  * See header.
        !            46:  */
        !            47: bool enum_from_name_as_int(enum_name_t *e, const char *name, int *val)
        !            48: {
        !            49:        do
        !            50:        {
        !            51:                int i, count = e->last - e->first + 1;
        !            52: 
        !            53:                for (i = 0; i < count; i++)
        !            54:                {
        !            55:                        if (name && strcaseeq(name, e->names[i]))
        !            56:                        {
        !            57:                                *val = e->first + i;
        !            58:                                return TRUE;
        !            59:                        }
        !            60:                }
        !            61:        }
        !            62:        while ((e = e->next));
        !            63:        return FALSE;
        !            64: }
        !            65: 
        !            66: /**
        !            67:  * Get the position of a flag name using offset calculation
        !            68:  */
        !            69: static int find_flag_pos(u_int val, u_int first)
        !            70: {
        !            71:        int offset = 0;
        !            72: 
        !            73:        while (val != 0x01)
        !            74:        {
        !            75:                val = val >> 1;
        !            76:                offset++;
        !            77:        }
        !            78:        return first - offset;
        !            79: }
        !            80: 
        !            81: /**
        !            82:  * Described in header.
        !            83:  */
        !            84: char *enum_flags_to_string(enum_name_t *e, u_int val, char *buf, size_t len)
        !            85: {
        !            86:        char *pos = buf, *delim = "";
        !            87:        int i, wr;
        !            88: 
        !            89:        if (e->next != ENUM_FLAG_MAGIC)
        !            90:        {
        !            91:                if (snprintf(buf, len, "(%d)", (int)val) >= len)
        !            92:                {
        !            93:                        return NULL;
        !            94:                }
        !            95:                return buf;
        !            96:        }
        !            97: 
        !            98:        if (snprintf(buf, len, "(unset)") >= len)
        !            99:        {
        !           100:                return NULL;
        !           101:        }
        !           102: 
        !           103:        for (i = 0; val; i++)
        !           104:        {
        !           105:                u_int flag = 1 << i;
        !           106: 
        !           107:                if (val & flag)
        !           108:                {
        !           109:                        char *name = NULL, hex[32];
        !           110: 
        !           111:                        if (flag >= (u_int)e->first && flag <= (u_int)e->last)
        !           112:                        {
        !           113:                                name = e->names[find_flag_pos(e->first, i)];
        !           114:                        }
        !           115:                        else
        !           116:                        {
        !           117:                                snprintf(hex, sizeof(hex), "(0x%X)", flag);
        !           118:                                name = hex;
        !           119:                        }
        !           120:                        if (name)
        !           121:                        {
        !           122:                                wr = snprintf(pos, len, "%s%s", delim, name);
        !           123:                                if (wr >= len)
        !           124:                                {
        !           125:                                        return NULL;
        !           126:                                }
        !           127:                                len -= wr;
        !           128:                                pos += wr;
        !           129:                                delim = " | ";
        !           130:                        }
        !           131:                        val &= ~flag;
        !           132:                }
        !           133:        }
        !           134:        return buf;
        !           135: }
        !           136: 
        !           137: /**
        !           138:  * See header.
        !           139:  */
        !           140: int enum_printf_hook(printf_hook_data_t *data, printf_hook_spec_t *spec,
        !           141:                                         const void *const *args)
        !           142: {
        !           143:        enum_name_t *ed = *((enum_name_t**)(args[0]));
        !           144:        int val = *((int*)(args[1]));
        !           145:        char *name, buf[512];
        !           146: 
        !           147:        if (ed && ed->next == ENUM_FLAG_MAGIC)
        !           148:        {
        !           149:                name = enum_flags_to_string(ed, val, buf, sizeof(buf));
        !           150:                if (name == NULL)
        !           151:                {
        !           152:                        snprintf(buf, sizeof(buf), "(0x%X)", val);
        !           153:                        name = buf;
        !           154:                }
        !           155:        }
        !           156:        else
        !           157:        {
        !           158:                name = enum_to_name(ed, val);
        !           159:                if (name == NULL)
        !           160:                {
        !           161:                        snprintf(buf, sizeof(buf), "(%d)", val);
        !           162:                        name = buf;
        !           163:                }
        !           164:        }
        !           165:        if (spec->minus)
        !           166:        {
        !           167:                return print_in_hook(data, "%-*s", spec->width, name);
        !           168:        }
        !           169:        return print_in_hook(data, "%*s", spec->width, name);
        !           170: }