Changeset b5e68c8 in mainline for uspace/lib/c/generic/adt/char_map.c


Ignore:
Timestamp:
2011-05-12T16:49:44Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f36787d7
Parents:
e80329d6 (diff), 750636a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/adt/char_map.c

    re80329d6 rb5e68c8  
    6060 * @param[in] value     The integral value to be stored for the key character
    6161 *                      string.
    62  * @returns             EOK on success.
    63  * @returns             ENOMEM if there is not enough memory left.
    64  * @returns             EEXIST if the key character string is already used.
     62 * @return              EOK on success.
     63 * @return              ENOMEM if there is not enough memory left.
     64 * @return              EEXIST if the key character string is already used.
    6565 */
    6666static int
    67 char_map_add_item(char_map_ref map, const char *identifier, size_t length,
     67char_map_add_item(char_map_t *map, const uint8_t *identifier, size_t length,
    6868    const int value)
    6969{
    7070        if (map->next == (map->size - 1)) {
    71                 char_map_ref *tmp;
    72 
    73                 tmp = (char_map_ref *) realloc(map->items,
    74                     sizeof(char_map_ref) * 2 * map->size);
     71                char_map_t **tmp;
     72
     73                tmp = (char_map_t **) realloc(map->items,
     74                    sizeof(char_map_t *) * 2 * map->size);
    7575                if (!tmp)
    7676                        return ENOMEM;
    … …  
    8080        }
    8181
    82         map->items[map->next] = (char_map_ref) malloc(sizeof(char_map_t));
     82        map->items[map->next] = (char_map_t *) malloc(sizeof(char_map_t));
    8383        if (!map->items[map->next])
    8484                return ENOMEM;
    … …  
    9090        }
    9191
    92         map->items[map->next]->c = * identifier;
    93         ++ identifier;
    94         ++ map->next;
    95         if ((length > 1) || ((length == 0) && (*identifier))) {
     92        map->items[map->next]->c = *identifier;
     93        identifier++;
     94        map->next++;
     95        if ((length > 1) || ((length == 0) && *identifier)) {
    9696                map->items[map->next - 1]->value = CHAR_MAP_NULL;
    9797                return char_map_add_item(map->items[map->next - 1], identifier,
    … …  
    107107 *
    108108 * @param[in] map       The character string to integer map.
    109  * @returns             TRUE if the map is valid.
    110  * @returns             FALSE otherwise.
    111  */
    112 static int char_map_is_valid(const char_map_ref map)
     109 * @return              TRUE if the map is valid.
     110 * @return              FALSE otherwise.
     111 */
     112static int char_map_is_valid(const char_map_t *map)
    113113{
    114114        return map && (map->magic == CHAR_MAP_MAGIC_VALUE);
    … …  
    127127 * @param[in] value     The integral value to be stored for the key character
    128128 *                      string.
    129  * @returns             EOK on success.
    130  * @returns             EINVAL if the map is not valid.
    131  * @returns             EINVAL if the identifier parameter is NULL.
    132  * @returns             EINVAL if the length parameter zero (0) and the
     129 * @return              EOK on success.
     130 * @return              EINVAL if the map is not valid.
     131 * @return              EINVAL if the identifier parameter is NULL.
     132 * @return              EINVAL if the length parameter zero (0) and the
    133133 *                      identifier parameter is an empty character string (the
    134134 *                      first character is the terminating zero ('\0')
    135135 *                      character.
    136  * @returns             EEXIST if the key character string is already used.
    137  * @returns             Other error codes as defined for the
     136 * @return              EEXIST if the key character string is already used.
     137 * @return              Other error codes as defined for the
    138138 *                      char_map_add_item() function.
    139139 */
    140140int
    141 char_map_add(char_map_ref map, const char *identifier, size_t length,
     141char_map_add(char_map_t *map, const uint8_t *identifier, size_t length,
    142142    const int value)
    143143{
    144         if (char_map_is_valid(map) && (identifier) &&
    145             ((length) || (*identifier))) {
     144        if (char_map_is_valid(map) && identifier && (length || *identifier)) {
    146145                int index;
    147146
    148                 for (index = 0; index < map->next; ++ index) {
     147                for (index = 0; index < map->next; index++) {
    149148                        if (map->items[index]->c != *identifier)
    150149                                continue;
    151150                               
    152                         ++ identifier;
    153                         if((length > 1) || ((length == 0) && (*identifier))) {
     151                        identifier++;
     152                        if((length > 1) || ((length == 0) && *identifier)) {
    154153                                return char_map_add(map->items[index],
    155154                                    identifier, length ? length - 1 : 0, value);
    … …  
    172171 * @param[in,out] map   The character string to integer map.
    173172 */
    174 void char_map_destroy(char_map_ref map)
     173void char_map_destroy(char_map_t *map)
    175174{
    176175        if (char_map_is_valid(map)) {
    … …  
    178177
    179178                map->magic = 0;
    180                 for (index = 0; index < map->next; ++index)
     179                for (index = 0; index < map->next; index++)
    181180                        char_map_destroy(map->items[index]);
    182181
    … …  
    196195 *                      zero (0) which means that the string is processed until
    197196 *                      the terminating zero ('\0') character is found.
    198  * @returns             The node holding the integral value assigned to the key
     197 * @return              The node holding the integral value assigned to the key
    199198 *                      character string.
    200  * @returns             NULL if the key is not assigned a node.
    201  */
    202 static char_map_ref
    203 char_map_find_node(const char_map_ref map, const char *identifier,
     199 * @return              NULL if the key is not assigned a node.
     200 */
     201static char_map_t *
     202char_map_find_node(const char_map_t *map, const uint8_t *identifier,
    204203    size_t length)
    205204{
    … …  
    207206                return NULL;
    208207
    209         if (length || (*identifier)) {
     208        if (length || *identifier) {
    210209                int index;
    211210
    212                 for (index = 0; index < map->next; ++index) {
     211                for (index = 0; index < map->next; index++) {
    213212                        if (map->items[index]->c == *identifier) {
    214                                 ++identifier;
     213                                identifier++;
    215214                                if (length == 1)
    216215                                        return map->items[index];
    … …  
    224223        }
    225224
    226         return map;
     225        return (char_map_t *) map;
    227226}
    228227
    … …  
    239238 *                      zero (0) which means that the string is processed until
    240239 *                      the terminating zero ('\0') character is found.
    241  * @returns             The integral value assigned to the key character string.
    242  * @returns             CHAR_MAP_NULL if the key is not assigned a value.
    243  */
    244 int char_map_exclude(char_map_ref map, const char *identifier, size_t length)
    245 {
    246         char_map_ref node;
     240 * @return              The integral value assigned to the key character string.
     241 * @return              CHAR_MAP_NULL if the key is not assigned a value.
     242 */
     243int char_map_exclude(char_map_t *map, const uint8_t *identifier, size_t length)
     244{
     245        char_map_t *node;
    247246
    248247        node = char_map_find_node(map, identifier, length);
    … …  
    267266 *                      zero (0) which means that the string is processed until
    268267 *                      the terminating zero ('\0') character is found.
    269  *  @returns            The integral value assigned to the key character string.
    270  *  @returns            CHAR_MAP_NULL if the key is not assigned a value.
    271  */
    272 int char_map_find(const char_map_ref map, const char *identifier, size_t length)
    273 {
    274         char_map_ref node;
     268 *  @return             The integral value assigned to the key character string.
     269 *  @return             CHAR_MAP_NULL if the key is not assigned a value.
     270 */
     271int char_map_find(const char_map_t *map, const uint8_t *identifier, size_t length)
     272{
     273        char_map_t *node;
    275274
    276275        node = char_map_find_node(map, identifier, length);
    … …  
    281280 *
    282281 *  @param[in,out] map  The character string to integer map.
    283  *  @returns            EOK on success.
    284  *  @returns            EINVAL if the map parameter is NULL.
    285  *  @returns            ENOMEM if there is not enough memory left.
    286  */
    287 int char_map_initialize(char_map_ref map)
     282 *  @return             EOK on success.
     283 *  @return             EINVAL if the map parameter is NULL.
     284 *  @return             ENOMEM if there is not enough memory left.
     285 */
     286int char_map_initialize(char_map_t *map)
    288287{
    289288        if (!map)
    … …  
    295294        map->next = 0;
    296295
    297         map->items = malloc(sizeof(char_map_ref) * map->size);
     296        map->items = malloc(sizeof(char_map_t *) * map->size);
    298297        if (!map->items) {
    299298                map->magic = 0;
    … …  
    319318 *  @param[in] value    The integral value to be stored for the key character
    320319 *                      string.
    321  *  @returns            EOK on success.
    322  *  @returns            EINVAL if the map is not valid.
    323  *  @returns            EINVAL if the identifier parameter is NULL.
    324  *  @returns            EINVAL if the length parameter zero (0) and the
     320 *  @return             EOK on success.
     321 *  @return             EINVAL if the map is not valid.
     322 *  @return             EINVAL if the identifier parameter is NULL.
     323 *  @return             EINVAL if the length parameter zero (0) and the
    325324 *                      identifier parameter is an empty character string (the
    326325 *                      first character is the terminating zero ('\0) character.
    327  *  @returns            EEXIST if the key character string is already used.
    328  *  @returns            Other error codes as defined for the char_map_add_item()
     326 *  @return             EEXIST if the key character string is already used.
     327 *  @return             Other error codes as defined for the char_map_add_item()
    329328 *                      function.
    330329 */
    331330int
    332 char_map_update(char_map_ref map, const char *identifier, const size_t length,
     331char_map_update(char_map_t *map, const uint8_t *identifier, const size_t length,
    333332    const int value)
    334333{
    335         char_map_ref node;
     334        char_map_t *node;
    336335
    337336        node = char_map_find_node(map, identifier, length);
Note: See TracChangeset for help on using the changeset viewer.