Subversion Repositories HelenOS

Rev

Rev 3912 | Rev 4197 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3912 Rev 4192
1
/*
1
/*
2
 * Copyright (c) 2009 Lukas Mejdrech
2
 * Copyright (c) 2009 Lukas Mejdrech
3
 * All rights reserved.
3
 * All rights reserved.
4
 *
4
 *
5
 * Redistribution and use in source and binary forms, with or without
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
6
 * modification, are permitted provided that the following conditions
7
 * are met:
7
 * are met:
8
 *
8
 *
9
 * - Redistributions of source code must retain the above copyright
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
15
 *   derived from this software without specific prior written permission.
16
 *
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
 
28
 
29
/** @addtogroup net
29
/** @addtogroup net
30
 *  @{
30
 *  @{
31
 */
31
 */
32
 
32
 
33
/** @file
33
/** @file
34
 *  Character string to integer map implementation.
34
 *  Character string to integer map implementation.
35
 *  @see char_map.h
35
 *  @see char_map.h
36
 */
36
 */
37
 
37
 
38
#include <errno.h>
38
#include <errno.h>
39
#include <malloc.h>
39
#include <malloc.h>
-
 
40
#include <mem.h>
40
#include <unistd.h>
41
#include <unistd.h>
41
#include <string.h>
-
 
42
 
42
 
43
#include "char_map.h"
43
#include "char_map.h"
44
 
44
 
45
/** Internal magic value for a&nbsp;consistency check.
45
/** Internal magic value for a&nbsp;consistency check.
46
 */
46
 */
47
#define CHAR_MAP_MAGIC_VALUE    0x12345611
47
#define CHAR_MAP_MAGIC_VALUE    0x12345611
48
 
48
 
49
/** Adds the value with the key to the map.
49
/** Adds the value with the key to the map.
50
 *  Creates new nodes to map the key.
50
 *  Creates new nodes to map the key.
51
 *  @param map The character string to integer map. Input/output parameter.
51
 *  @param map The character string to integer map. Input/output parameter.
52
 *  @param identifier The key zero ('\\0') terminated character string. The key character string is processed until the first terminating zero ('\\0') character after the given length is found. Input parameter.
52
 *  @param identifier The key zero ('\\0') terminated character string. The key character string is processed until the first terminating zero ('\\0') character after the given length is found. Input parameter.
53
 *  @param length The key character string length. The parameter may be zero (0) which means that the string is processed until the terminating zero ('\\0') character is found. Input parameter.
53
 *  @param length The key character string length. The parameter may be zero (0) which means that the string is processed until the terminating zero ('\\0') character is found. Input parameter.
54
 *  @param value The integral value to be stored for the key character string. Input parameter.
54
 *  @param value The integral value to be stored for the key character string. Input parameter.
55
 *  @returns EOK on success.
55
 *  @returns EOK on success.
56
 *  @returns ENOMEM if there is not enough memory left.
56
 *  @returns ENOMEM if there is not enough memory left.
57
 *  @returns EEXIST if the key character string is already used.
57
 *  @returns EEXIST if the key character string is already used.
58
 */
58
 */
59
int char_map_add_item( char_map_ref map, const char * identifier, size_t length, const int value );
59
int char_map_add_item( char_map_ref map, const char * identifier, size_t length, const int value );
60
 
60
 
61
/** Returns the node assigned to the key from the map.
61
/** Returns the node assigned to the key from the map.
62
 *  @param map The character string to integer map. Input parameter.
62
 *  @param map The character string to integer map. Input parameter.
63
 *  @param identifier The key zero ('\\0') terminated character string. The key character string is processed until the first terminating zero ('\\0') character after the given length is found. Input parameter.
63
 *  @param identifier The key zero ('\\0') terminated character string. The key character string is processed until the first terminating zero ('\\0') character after the given length is found. Input parameter.
64
 *  @param length The key character string length. The parameter may be zero (0) which means that the string is processed until the terminating zero ('\\0') character is found. Input parameter.
64
 *  @param length The key character string length. The parameter may be zero (0) which means that the string is processed until the terminating zero ('\\0') character is found. Input parameter.
65
 *  @returns The node holding the integral value assigned to the key character string.
65
 *  @returns The node holding the integral value assigned to the key character string.
66
 *  @returns NULL if the key is not assigned a&nbsp;node.
66
 *  @returns NULL if the key is not assigned a&nbsp;node.
67
 */
67
 */
68
char_map_ref    char_map_find_node( const char_map_ref map, const char * identifier, const size_t length );
68
char_map_ref    char_map_find_node( const char_map_ref map, const char * identifier, const size_t length );
69
 
69
 
70
/** Checks if the map is valid.
70
/** Checks if the map is valid.
71
 *  @param map The character string to integer map. Input parameter.
71
 *  @param map The character string to integer map. Input parameter.
72
 *  @returns TRUE if the map is valid.
72
 *  @returns TRUE if the map is valid.
73
 *  @returns FALSE otherwise.
73
 *  @returns FALSE otherwise.
74
 */
74
 */
75
int char_map_is_valid( const char_map_ref map );
75
int char_map_is_valid( const char_map_ref map );
76
 
76
 
77
int char_map_add( char_map_ref map, const char * identifier, size_t length, const int value ){
77
int char_map_add( char_map_ref map, const char * identifier, size_t length, const int value ){
78
    if( char_map_is_valid( map ) && ( identifier ) && (( length ) || ( * identifier ))){
78
    if( char_map_is_valid( map ) && ( identifier ) && (( length ) || ( * identifier ))){
79
        int index;
79
        int index;
80
 
80
 
81
        for( index = 0; index < map->next; ++ index ){
81
        for( index = 0; index < map->next; ++ index ){
82
            if( map->items[ index ]->c == * identifier ){
82
            if( map->items[ index ]->c == * identifier ){
83
                ++ identifier;
83
                ++ identifier;
84
                if( length ) -- length;
84
                if( length ) -- length;
85
                if( length || ( * identifier )){
85
                if( length || ( * identifier )){
86
                    return char_map_add( map->items[ index ], identifier, length, value );
86
                    return char_map_add( map->items[ index ], identifier, length, value );
87
                }else{
87
                }else{
88
                    if( map->items[ index ]->value != CHAR_MAP_NULL ) return EEXISTS;
88
                    if( map->items[ index ]->value != CHAR_MAP_NULL ) return EEXISTS;
89
                    map->items[ index ]->value = value;
89
                    map->items[ index ]->value = value;
90
                    return EOK;
90
                    return EOK;
91
                }
91
                }
92
            }
92
            }
93
        }
93
        }
94
        return char_map_add_item( map, identifier, length, value );
94
        return char_map_add_item( map, identifier, length, value );
95
    }
95
    }
96
    return EINVAL;
96
    return EINVAL;
97
}
97
}
98
 
98
 
99
int char_map_add_item( char_map_ref map, const char * identifier, size_t length, const int value ){
99
int char_map_add_item( char_map_ref map, const char * identifier, size_t length, const int value ){
100
    if( map->next == ( map->size - 1 )){
100
    if( map->next == ( map->size - 1 )){
101
        char_map_ref    * tmp;
101
        char_map_ref    * tmp;
102
 
102
 
103
        tmp = ( char_map_ref * ) malloc( sizeof( char_map_ref ) * 2 * map->size );
103
        tmp = ( char_map_ref * ) malloc( sizeof( char_map_ref ) * 2 * map->size );
104
        if( ! tmp ) return ENOMEM;
104
        if( ! tmp ) return ENOMEM;
105
        map->size *= 2;
105
        map->size *= 2;
106
        memcpy( tmp, map->items, sizeof( char_map_ref ) * map->next );
106
        memcpy( tmp, map->items, sizeof( char_map_ref ) * map->next );
107
        free( map->items );
107
        free( map->items );
108
        map->items = tmp;
108
        map->items = tmp;
109
    }
109
    }
110
    map->items[ map->next ] = ( char_map_ref ) malloc( sizeof( char_map_t ));
110
    map->items[ map->next ] = ( char_map_ref ) malloc( sizeof( char_map_t ));
111
    if( ! map->items[ map->next ] ) return ENOMEM;
111
    if( ! map->items[ map->next ] ) return ENOMEM;
112
    char_map_initialize( map->items[ map->next ] );
112
    char_map_initialize( map->items[ map->next ] );
113
    map->items[ map->next ]->c = * identifier;
113
    map->items[ map->next ]->c = * identifier;
114
    ++ identifier;
114
    ++ identifier;
115
    if( length ) -- length;
115
    if( length ) -- length;
116
    ++ map->next;
116
    ++ map->next;
117
    if( length || ( * identifier )){
117
    if( length || ( * identifier )){
118
        map->items[ map->next - 1 ]->value = CHAR_MAP_NULL;
118
        map->items[ map->next - 1 ]->value = CHAR_MAP_NULL;
119
        return char_map_add_item( map->items[ map->next - 1 ], identifier, length, value );
119
        return char_map_add_item( map->items[ map->next - 1 ], identifier, length, value );
120
    }else{
120
    }else{
121
        map->items[ map->next - 1 ]->value = value;
121
        map->items[ map->next - 1 ]->value = value;
122
    }
122
    }
123
    return EOK;
123
    return EOK;
124
}
124
}
125
 
125
 
126
void char_map_destroy( char_map_ref map ){
126
void char_map_destroy( char_map_ref map ){
127
    if( char_map_is_valid( map )){
127
    if( char_map_is_valid( map )){
128
        int index;
128
        int index;
129
 
129
 
130
        map->magic = 0;
130
        map->magic = 0;
131
        for( index = 0; index < map->next; ++ index ){
131
        for( index = 0; index < map->next; ++ index ){
132
            char_map_destroy( map->items[ index ] );
132
            char_map_destroy( map->items[ index ] );
133
        }
133
        }
134
        free( map->items );
134
        free( map->items );
135
    }
135
    }
136
}
136
}
137
 
137
 
138
int char_map_exclude( char_map_ref map, const char * identifier, size_t length ){
138
int char_map_exclude( char_map_ref map, const char * identifier, size_t length ){
139
    char_map_ref    node;
139
    char_map_ref    node;
140
 
140
 
141
    node = char_map_find_node( map, identifier, length );
141
    node = char_map_find_node( map, identifier, length );
142
    if( node ){
142
    if( node ){
143
        int value;
143
        int value;
144
 
144
 
145
        value = node->value;
145
        value = node->value;
146
        node->value = CHAR_MAP_NULL;
146
        node->value = CHAR_MAP_NULL;
147
        return value;
147
        return value;
148
    }
148
    }
149
    return CHAR_MAP_NULL;
149
    return CHAR_MAP_NULL;
150
}
150
}
151
 
151
 
152
int char_map_find( const char_map_ref map, const char * identifier, size_t length ){
152
int char_map_find( const char_map_ref map, const char * identifier, size_t length ){
153
    char_map_ref    node;
153
    char_map_ref    node;
154
 
154
 
155
    node = char_map_find_node( map, identifier, length );
155
    node = char_map_find_node( map, identifier, length );
156
    return node ? node->value : CHAR_MAP_NULL;
156
    return node ? node->value : CHAR_MAP_NULL;
157
}
157
}
158
 
158
 
159
char_map_ref char_map_find_node( const char_map_ref map, const char * identifier, size_t length ){
159
char_map_ref char_map_find_node( const char_map_ref map, const char * identifier, size_t length ){
160
    if( ! char_map_is_valid( map )) return NULL;
160
    if( ! char_map_is_valid( map )) return NULL;
161
    if( length ) -- length;
161
    if( length ) -- length;
162
    if( length || ( * identifier )){
162
    if( length || ( * identifier )){
163
        int index;
163
        int index;
164
 
164
 
165
        for( index = 0; index < map->next; ++ index ){
165
        for( index = 0; index < map->next; ++ index ){
166
            if( map->items[ index ]->c == * identifier ){
166
            if( map->items[ index ]->c == * identifier ){
167
                ++ identifier;
167
                ++ identifier;
168
                return char_map_find_node( map->items[ index ], identifier, length );
168
                return char_map_find_node( map->items[ index ], identifier, length );
169
            }
169
            }
170
        }
170
        }
171
        return NULL;
171
        return NULL;
172
    }
172
    }
173
    return map;
173
    return map;
174
}
174
}
175
 
175
 
176
int char_map_get_value( const char_map_ref map ){
176
int char_map_get_value( const char_map_ref map ){
177
    return char_map_is_valid( map ) ? map->value : CHAR_MAP_NULL;
177
    return char_map_is_valid( map ) ? map->value : CHAR_MAP_NULL;
178
}
178
}
179
 
179
 
180
int char_map_initialize( char_map_ref map ){
180
int char_map_initialize( char_map_ref map ){
181
    if( ! map ) return EINVAL;
181
    if( ! map ) return EINVAL;
182
    map->c = 0;
182
    map->c = 0;
183
    map->value = CHAR_MAP_NULL;
183
    map->value = CHAR_MAP_NULL;
184
    map->size = 2;
184
    map->size = 2;
185
    map->next = 0;
185
    map->next = 0;
186
    map->items = malloc( sizeof( char_map_ref ) * map->size );
186
    map->items = malloc( sizeof( char_map_ref ) * map->size );
187
    if( ! map->items ) return ENOMEM;
187
    if( ! map->items ) return ENOMEM;
188
    map->items[ map->next ] = NULL;
188
    map->items[ map->next ] = NULL;
189
    map->magic = CHAR_MAP_MAGIC_VALUE;
189
    map->magic = CHAR_MAP_MAGIC_VALUE;
190
    return EOK;
190
    return EOK;
191
}
191
}
192
 
192
 
193
int char_map_is_valid( const char_map_ref map ){
193
int char_map_is_valid( const char_map_ref map ){
194
    return map && ( map->magic == CHAR_MAP_MAGIC_VALUE );
194
    return map && ( map->magic == CHAR_MAP_MAGIC_VALUE );
195
}
195
}
196
 
196
 
197
int char_map_update( char_map_ref map, const char * identifier, const size_t length, const int value ){
197
int char_map_update( char_map_ref map, const char * identifier, const size_t length, const int value ){
198
    char_map_ref    node;
198
    char_map_ref    node;
199
 
199
 
200
//  if( ! char_map_is_valid( map )) return EINVAL;
200
//  if( ! char_map_is_valid( map )) return EINVAL;
201
    node = char_map_find_node( map, identifier, length );
201
    node = char_map_find_node( map, identifier, length );
202
    if( node ){
202
    if( node ){
203
        node->value = value;
203
        node->value = value;
204
        return EOK;
204
        return EOK;
205
    }else{
205
    }else{
206
        return char_map_add( map, identifier, length, value );
206
        return char_map_add( map, identifier, length, value );
207
    }
207
    }
208
}
208
}
209
 
209
 
210
/** @}
210
/** @}
211
 */
211
 */
212
 
212