Changeset fdbc3ff in mainline for uspace/lib/c/generic/adt


Ignore:
Timestamp:
2010-11-19T23:50:06Z (15 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
46d4d9f
Parents:
b4c9c61 (diff), a9c6b966 (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.

Location:
uspace/lib/c/generic/adt
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    rb4c9c61 rfdbc3ff  
    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 char *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;
    … …  
    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 char *identifier, size_t length,
    142142    const int value)
    143143{
    … …  
    172172 * @param[in,out] map   The character string to integer map.
    173173 */
    174 void char_map_destroy(char_map_ref map)
     174void char_map_destroy(char_map_t *map)
    175175{
    176176        if (char_map_is_valid(map)) {
    … …  
    196196 *                      zero (0) which means that the string is processed until
    197197 *                      the terminating zero ('\0') character is found.
    198  * @returns             The node holding the integral value assigned to the key
     198 * @return              The node holding the integral value assigned to the key
    199199 *                      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,
     200 * @return              NULL if the key is not assigned a node.
     201 */
     202static char_map_t *
     203char_map_find_node(const char_map_t *map, const char *identifier,
    204204    size_t length)
    205205{
    … …  
    224224        }
    225225
    226         return map;
     226        return (char_map_t *) map;
    227227}
    228228
    … …  
    239239 *                      zero (0) which means that the string is processed until
    240240 *                      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;
     241 * @return              The integral value assigned to the key character string.
     242 * @return              CHAR_MAP_NULL if the key is not assigned a value.
     243 */
     244int char_map_exclude(char_map_t *map, const char *identifier, size_t length)
     245{
     246        char_map_t *node;
    247247
    248248        node = char_map_find_node(map, identifier, length);
    … …  
    267267 *                      zero (0) which means that the string is processed until
    268268 *                      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;
     269 *  @return             The integral value assigned to the key character string.
     270 *  @return             CHAR_MAP_NULL if the key is not assigned a value.
     271 */
     272int char_map_find(const char_map_t *map, const char *identifier, size_t length)
     273{
     274        char_map_t *node;
    275275
    276276        node = char_map_find_node(map, identifier, length);
    … …  
    281281 *
    282282 *  @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)
     283 *  @return             EOK on success.
     284 *  @return             EINVAL if the map parameter is NULL.
     285 *  @return             ENOMEM if there is not enough memory left.
     286 */
     287int char_map_initialize(char_map_t *map)
    288288{
    289289        if (!map)
    … …  
    295295        map->next = 0;
    296296
    297         map->items = malloc(sizeof(char_map_ref) * map->size);
     297        map->items = malloc(sizeof(char_map_t *) * map->size);
    298298        if (!map->items) {
    299299                map->magic = 0;
    … …  
    319319 *  @param[in] value    The integral value to be stored for the key character
    320320 *                      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
     321 *  @return             EOK on success.
     322 *  @return             EINVAL if the map is not valid.
     323 *  @return             EINVAL if the identifier parameter is NULL.
     324 *  @return             EINVAL if the length parameter zero (0) and the
    325325 *                      identifier parameter is an empty character string (the
    326326 *                      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()
     327 *  @return             EEXIST if the key character string is already used.
     328 *  @return             Other error codes as defined for the char_map_add_item()
    329329 *                      function.
    330330 */
    331331int
    332 char_map_update(char_map_ref map, const char *identifier, const size_t length,
     332char_map_update(char_map_t *map, const char *identifier, const size_t length,
    333333    const int value)
    334334{
    335         char_map_ref node;
     335        char_map_t *node;
    336336
    337337        node = char_map_find_node(map, identifier, length);

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

    rb4c9c61 rfdbc3ff  
    5656 *
    5757 * @param[in] fifo      The dynamic queue.
    58  * @returns             TRUE if the queue is valid.
    59  * @returns             FALSE otherwise.
    60  */
    61 static int dyn_fifo_is_valid(dyn_fifo_ref fifo)
     58 * @return              TRUE if the queue is valid.
     59 * @return              FALSE otherwise.
     60 */
     61static int dyn_fifo_is_valid(dyn_fifo_t *fifo)
    6262{
    6363        return fifo && (fifo->magic_value == DYN_FIFO_MAGIC_VALUE);
    … …  
    6868 * @param[in,out] fifo  The dynamic queue.
    6969 * @param[in] size      The initial queue size.
    70  * @returns             EOK on success.
    71  * @returns             EINVAL if the queue is not valid.
    72  * @returns             EBADMEM if the fifo parameter is NULL.
    73  * @returns             ENOMEM if there is not enough memory left.
    74  */
    75 int dyn_fifo_initialize(dyn_fifo_ref fifo, int size)
     70 * @return              EOK on success.
     71 * @return              EINVAL if the queue is not valid.
     72 * @return              EBADMEM if the fifo parameter is NULL.
     73 * @return              ENOMEM if there is not enough memory left.
     74 */
     75int dyn_fifo_initialize(dyn_fifo_t *fifo, int size)
    7676{
    7777        if (!fifo)
    … …  
    100100 *                      this limit. May be zero or negative to indicate no
    101101 *                      limit.
    102  * @returns             EOK on success.
    103  * @returns             EINVAL if the queue is not valid.
    104  * @returns             ENOMEM if there is not enough memory left.
    105  */
    106 int dyn_fifo_push(dyn_fifo_ref fifo, int value, int max_size)
     102 * @return              EOK on success.
     103 * @return              EINVAL if the queue is not valid.
     104 * @return              ENOMEM if there is not enough memory left.
     105 */
     106int dyn_fifo_push(dyn_fifo_t *fifo, int value, int max_size)
    107107{
    108108        int *new_items;
    … …  
    150150 *
    151151 * @param[in,out] fifo  The dynamic queue.
    152  * @returns             Value of the first item in the queue.
    153  * @returns             EINVAL if the queue is not valid.
    154  * @returns             ENOENT if the queue is empty.
    155  */
    156 int dyn_fifo_pop(dyn_fifo_ref fifo)
     152 * @return              Value of the first item in the queue.
     153 * @return              EINVAL if the queue is not valid.
     154 * @return              ENOENT if the queue is empty.
     155 */
     156int dyn_fifo_pop(dyn_fifo_t *fifo)
    157157{
    158158        int value;
    … …  
    172172 *
    173173 * @param[in,out] fifo  The dynamic queue.
    174  * @returnsi            Value of the first item in the queue.
    175  * @returns             EINVAL if the queue is not valid.
    176  * @returns             ENOENT if the queue is empty.
    177  */
    178 int dyn_fifo_value(dyn_fifo_ref fifo)
     174 * @return              Value of the first item in the queue.
     175 * @return              EINVAL if the queue is not valid.
     176 * @return              ENOENT if the queue is empty.
     177 */
     178int dyn_fifo_value(dyn_fifo_t *fifo)
    179179{
    180180        if (!dyn_fifo_is_valid(fifo))
    … …  
    190190 *
    191191 * @param[in,out] fifo  The dynamic queue.
    192  * @returns             EOK on success.
    193  * @returns             EINVAL if the queue is not valid.
    194  */
    195 int dyn_fifo_destroy(dyn_fifo_ref fifo)
     192 * @return              EOK on success.
     193 * @return              EINVAL if the queue is not valid.
     194 */
     195int dyn_fifo_destroy(dyn_fifo_t *fifo)
    196196{
    197197        if (!dyn_fifo_is_valid(fifo))

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

    rb4c9c61 rfdbc3ff  
    5555 *                      appended with the terminating zero ('\0') character
    5656 *                      otherwise.
    57  * @returns             The new bundled character string with measured length.
    58  * @returns             NULL if there is not enough memory left.
    59  */
    60 measured_string_ref
     57 * @return              The new bundled character string with measured length.
     58 * @return              NULL if there is not enough memory left.
     59 */
     60measured_string_t *
    6161measured_string_create_bulk(const char *string, size_t length)
    6262{
    63         measured_string_ref new;
     63        measured_string_t *new;
    6464
    6565        if (length == 0) {
    … …  
    6767                        length++;
    6868        }
    69         new = (measured_string_ref) malloc(sizeof(measured_string_t) +
     69        new = (measured_string_t *) malloc(sizeof(measured_string_t) +
    7070            (sizeof(char) * (length + 1)));
    7171        if (!new)
    … …  
    8484 *
    8585 * @param[in] source    The source measured string to be copied.
    86  * @returns             The copy of the given measured string.
    87  * @returns             NULL if the source parameter is NULL.
    88  * @returns             NULL if there is not enough memory left.
    89  */
    90 measured_string_ref measured_string_copy(measured_string_ref source)
    91 {
    92         measured_string_ref new;
     86 * @return              The copy of the given measured string.
     87 * @return              NULL if the source parameter is NULL.
     88 * @return              NULL if there is not enough memory left.
     89 */
     90measured_string_t *measured_string_copy(measured_string_t *source)
     91{
     92        measured_string_t *new;
    9393
    9494        if (!source)
    9595                return NULL;
    9696
    97         new = (measured_string_ref) malloc(sizeof(measured_string_t));
     97        new = (measured_string_t *) malloc(sizeof(measured_string_t));
    9898        if (new) {
    9999                new->value = (char *) malloc(source->length + 1);
    … …  
    120120 *                      actual character strings.
    121121 *  @param[in] count    The size of the measured strings array.
    122  *  @returns            EOK on success.
    123  *  @returns            EINVAL if the strings or data parameter is NULL.
    124  *  @returns            EINVAL if the count parameter is zero (0).
    125  *  @returns            EINVAL if the sent array differs in size.
    126  *  @returns            EINVAL if there is inconsistency in sent measured
     122 *  @return             EOK on success.
     123 *  @return             EINVAL if the strings or data parameter is NULL.
     124 *  @return             EINVAL if the count parameter is zero (0).
     125 *  @return             EINVAL if the sent array differs in size.
     126 *  @return             EINVAL if there is inconsistency in sent measured
    127127 *                      strings' lengths (should not occur).
    128  *  @returns            ENOMEM if there is not enough memory left.
    129  *  @returns            Other error codes as defined for the
     128 *  @return             ENOMEM if there is not enough memory left.
     129 *  @return             Other error codes as defined for the
    130130 *                      async_data_write_finalize() function.
    131131 */
    132132int
    133 measured_strings_receive(measured_string_ref *strings, char **data,
     133measured_strings_receive(measured_string_t **strings, char **data,
    134134    size_t count)
    135135{
    … …  
    166166        (*data)[lengths[count] - 1] = '\0';
    167167
    168         *strings = (measured_string_ref) malloc(sizeof(measured_string_t) *
     168        *strings = (measured_string_t *) malloc(sizeof(measured_string_t) *
    169169            count);
    170170        if (!*strings) {
    … …  
    209209 * @param[in] strings   The measured strings array to be processed.
    210210 * @param[in] count     The measured strings array size.
    211  * @returns             The computed sizes array.
    212  * @returns             NULL if there is not enough memory left.
    213  */
    214 static size_t *prepare_lengths(const measured_string_ref strings, size_t count)
     211 * @return              The computed sizes array.
     212 * @return              NULL if there is not enough memory left.
     213 */
     214static size_t *prepare_lengths(const measured_string_t *strings, size_t count)
    215215{
    216216        size_t *lengths;
    … …  
    238238 * @param[in] strings   The measured strings array to be transferred.
    239239 * @param[in] count     The measured strings array size.
    240  * @returns             EOK on success.
    241  * @returns             EINVAL if the strings parameter is NULL.
    242  * @returns             EINVAL if the count parameter is zero (0).
    243  * @returns             EINVAL if the calling module does not accept the given
     240 * @return              EOK on success.
     241 * @return              EINVAL if the strings parameter is NULL.
     242 * @return              EINVAL if the count parameter is zero (0).
     243 * @return              EINVAL if the calling module does not accept the given
    244244 *                      array size.
    245  * @returns             EINVAL if there is inconsistency in sent measured
     245 * @return              EINVAL if there is inconsistency in sent measured
    246246 *                      strings' lengths (should not occur).
    247  * @returns             Other error codes as defined for the
     247 * @return              Other error codes as defined for the
    248248 *                      async_data_read_finalize() function.
    249249 */
    250 int measured_strings_reply(const measured_string_ref strings, size_t count)
     250int measured_strings_reply(const measured_string_t *strings, size_t count)
    251251{
    252252        size_t *lengths;
    … …  
    302302 *                      actual character strings.
    303303 * @param[in] count     The size of the measured strings array.
    304  * @returns             EOK on success.
    305  * @returns             EINVAL if the strings or data parameter is NULL.
    306  * @returns             EINVAL if the phone or count parameter is not positive.
    307  * @returns             EINVAL if the sent array differs in size.
    308  * @returns             ENOMEM if there is not enough memory left.
    309  * @returns             Other error codes as defined for the
     304 * @return              EOK on success.
     305 * @return              EINVAL if the strings or data parameter is NULL.
     306 * @return              EINVAL if the phone or count parameter is not positive.
     307 * @return              EINVAL if the sent array differs in size.
     308 * @return              ENOMEM if there is not enough memory left.
     309 * @return              Other error codes as defined for the
    310310 *                      async_data_read_start() function.
    311311 */
    312312int
    313 measured_strings_return(int phone, measured_string_ref *strings, char **data,
     313measured_strings_return(int phone, measured_string_t **strings, char **data,
    314314    size_t count)
    315315{
    … …  
    339339        }
    340340
    341         *strings = (measured_string_ref) malloc(sizeof(measured_string_t) *
     341        *strings = (measured_string_t *) malloc(sizeof(measured_string_t) *
    342342            count);
    343343        if (!*strings) {
    … …  
    378378 * @param[in] strings   The measured strings array to be transferred.
    379379 * @param[in] count     The measured strings array size.
    380  * @returns             EOK on success.
    381  * @returns             EINVAL if the strings parameter is NULL.
    382  * @returns             EINVAL if the phone or count parameter is not positive.
    383  * @returns             Other error codes as defined for the
     380 * @return              EOK on success.
     381 * @return              EINVAL if the strings parameter is NULL.
     382 * @return              EINVAL if the phone or count parameter is not positive.
     383 * @return              Other error codes as defined for the
    384384 *                      async_data_write_start() function.
    385385 */
    386386int
    387 measured_strings_send(int phone, const measured_string_ref strings,
     387measured_strings_send(int phone, const measured_string_t *strings,
    388388    size_t count)
    389389{
Note: See TracChangeset for help on using the changeset viewer.