Changeset 33b8d024 in mainline for uspace/lib


Ignore:
Timestamp:
2018-01-16T20:38:46Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2467b41
Parents:
d39c46e0
Message:

Remove const qualifier from the argument of free() and realloc(),
as well as in numerous other variables that hold ownership of memory.

By convention, a pointer that holds ownership is _never_ qualified by const.
This is reflected in the standard type signature of free() and realloc().
Allowing const pointers to hold ownership may seem superficially convenient,
but is actually quite confusing to experienced C programmers.

Location:
uspace/lib
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/malloc.c

    rd39c46e0 r33b8d024  
    874874 *
    875875 */
    876 void *realloc(const void *addr, const size_t size)
     876void *realloc(void * const addr, const size_t size)
    877877{
    878878        if (size == 0) {
    … …  
    988988 *
    989989 */
    990 void free(const void *addr)
     990void free(void * const addr)
    991991{
    992992        if (addr == NULL)

  • uspace/lib/c/include/ipc/devman.h

    rd39c46e0 r33b8d024  
    7474        /** Id of device model.
    7575         */
    76         const char *id;
     76        char *id;
    7777        /** Relevancy of device-to-driver match.
    7878         * The higher is the product of scores specified for the device by the bus driver and by the leaf driver,

  • uspace/lib/c/include/malloc.h

    rd39c46e0 r33b8d024  
    3838#include <stddef.h>
    3939
    40 extern void *malloc(const size_t size)
     40extern void *malloc(size_t size)
    4141    __attribute__((malloc));
    42 extern void *calloc(const size_t nmemb, const size_t size)
     42extern void *calloc(size_t nmemb, size_t size)
    4343    __attribute__((malloc));
    44 extern void *memalign(const size_t align, const size_t size)
     44extern void *memalign(size_t align, size_t size)
    4545    __attribute__((malloc));
    46 extern void *realloc(const void *addr, const size_t size)
     46extern void *realloc(void *addr, size_t size)
    4747    __attribute__((warn_unused_result));
    48 extern void free(const void *addr);
     48extern void free(void *addr);
    4949extern void *heap_check(void);
    5050

  • uspace/lib/drv/generic/private/driver.h

    rd39c46e0 r33b8d024  
    5757       
    5858        /** Device name */
    59         const char *name;
     59        char *name;
    6060       
    6161        /** Driver-specific data associated with this device */
    … …  
    8484       
    8585        /** Function name */
    86         const char *name;
     86        char *name;
    8787       
    8888        /** List of device ids for driver matching */

  • uspace/lib/drv/generic/remote_audio_mixer.c

    rd39c46e0 r33b8d024  
    9494 * @return Error code.
    9595 */
    96 errno_t audio_mixer_get_info(async_exch_t *exch, const char **name, unsigned *items)
     96errno_t audio_mixer_get_info(async_exch_t *exch, char **name, unsigned *items)
    9797{
    9898        if (!exch)
    … …  
    131131 */
    132132errno_t audio_mixer_get_item_info(async_exch_t *exch, unsigned item,
    133     const char **name, unsigned *levels)
     133    char **name, unsigned *levels)
    134134{
    135135        if (!exch)

  • uspace/lib/drv/generic/remote_audio_pcm.c

    rd39c46e0 r33b8d024  
    184184 * @note Caller is responsible for freeing newly allocated memory.
    185185 */
    186 errno_t audio_pcm_get_info_str(audio_pcm_sess_t *sess, const char **name)
     186errno_t audio_pcm_get_info_str(audio_pcm_sess_t *sess, char **name)
    187187{
    188188        if (!name)

  • uspace/lib/drv/include/audio_mixer_iface.h

    rd39c46e0 r33b8d024  
    4343#include "ddf/driver.h"
    4444
    45 errno_t audio_mixer_get_info(async_exch_t *, const char **, unsigned *);
     45errno_t audio_mixer_get_info(async_exch_t *, char **, unsigned *);
    4646errno_t audio_mixer_get_item_info(async_exch_t *, unsigned,
    47     const char **, unsigned *);
     47    char **, unsigned *);
    4848errno_t audio_mixer_get_item_level(async_exch_t *, unsigned, unsigned *);
    4949errno_t audio_mixer_set_item_level(async_exch_t *, unsigned, unsigned);

  • uspace/lib/drv/include/audio_pcm_iface.h

    rd39c46e0 r33b8d024  
    8080void audio_pcm_close(audio_pcm_sess_t *);
    8181
    82 errno_t audio_pcm_get_info_str(audio_pcm_sess_t *, const char **);
     82errno_t audio_pcm_get_info_str(audio_pcm_sess_t *, char **);
    8383errno_t audio_pcm_test_format(audio_pcm_sess_t *, unsigned *, unsigned *,
    8484    pcm_sample_format_t *);

  • uspace/lib/hound/include/hound/client.h

    rd39c46e0 r33b8d024  
    5757
    5858errno_t hound_context_get_available_targets(hound_context_t *hound,
    59     const char ***names, size_t *count);
     59    char ***names, size_t *count);
    6060errno_t hound_context_get_connected_targets(hound_context_t *hound,
    61     const char ***names, size_t *count);
     61    char ***names, size_t *count);
    6262
    6363errno_t hound_context_connect_target(hound_context_t *hound, const char* target);

  • uspace/lib/hound/include/hound/protocol.h

    rd39c46e0 r33b8d024  
    6565errno_t hound_service_unregister_context(hound_sess_t *sess, hound_context_id_t id);
    6666
    67 errno_t hound_service_get_list(hound_sess_t *sess, const char ***ids, size_t *count,
     67errno_t hound_service_get_list(hound_sess_t *sess, char ***ids, size_t *count,
    6868    int flags, const char *connection);
    6969
    … …  
    7777 */
    7878static inline errno_t hound_service_get_list_all(hound_sess_t *sess,
    79     const char ***ids, size_t *count, int flags)
     79    char ***ids, size_t *count, int flags)
    8080{
    8181        return hound_service_get_list(sess, ids, count, flags, NULL);
    … …  
    106106        bool (*is_record_context)(void *, hound_context_id_t);
    107107        /** Get string identifiers of specified objects */
    108         errno_t (*get_list)(void *, const char ***, size_t *, const char *, int);
     108        errno_t (*get_list)(void *, char ***, size_t *, const char *, int);
    109109        /** Create connection between source and sink */
    110110        errno_t (*connect)(void *, const char *, const char *);

  • uspace/lib/hound/src/client.c

    rd39c46e0 r33b8d024  
    7676        hound_sess_t *session;
    7777        /** context name, reported to the daemon */
    78         const char *name;
     78        char *name;
    7979        /** True if the instance is record context */
    8080        bool record;
    … …  
    196196 */
    197197errno_t hound_context_get_available_targets(hound_context_t *hound,
    198     const char ***names, size_t *count)
     198    char ***names, size_t *count)
    199199{
    200200        assert(hound);
    … …  
    213213 */
    214214errno_t hound_context_get_connected_targets(hound_context_t *hound,
    215     const char ***names, size_t *count)
     215    char ***names, size_t *count)
    216216{
    217217        assert(hound);
    … …  
    237237        assert(target);
    238238
    239         const char **tgt = NULL;
     239        char **tgt = NULL;
    240240        size_t count = 1;
    241241        errno_t ret = EOK;

  • uspace/lib/hound/src/protocol.c

    rd39c46e0 r33b8d024  
    173173 * @retval Error code.
    174174 */
    175 errno_t hound_service_get_list(hound_sess_t *sess, const char ***ids, size_t *count,
     175errno_t hound_service_get_list(hound_sess_t *sess, char ***ids, size_t *count,
    176176    int flags, const char *connection)
    177177{
    … …  
    206206
    207207        /* Start receiving names */
    208         const char **names = NULL;
     208        char **names = NULL;
    209209        if (name_count) {
    210210                size_t *sizes = calloc(name_count, sizeof(size_t));
    … …  
    446446                        }
    447447
    448                         const char **list = NULL;
     448                        char **list = NULL;
    449449                        const int flags = IPC_GET_ARG1(call);
    450450                        size_t count = IPC_GET_ARG2(call);

  • uspace/lib/nic/include/nic.h

    rd39c46e0 r33b8d024  
    5757        nic_wv_id_t id;
    5858        nic_wv_type_t type;
    59         const void *data;
     59        void *data;
    6060        size_t length;
    6161        struct nic_wol_virtue *next;

  • uspace/lib/posix/source/stdio/scanf.c

    rd39c46e0 r33b8d024  
    625625
    626626                                const char *cur_borrowed = NULL;
     627                                char *cur_duplicated = NULL;
    627628                                const char *cur_limited = NULL;
    628                                 char *cur_updated = NULL;
     629                                const char *cur_updated = NULL;
    629630
    630631                                /* Borrow the cursor. Until it is returned to the provider
    … …  
    637638                                 * than allowed by width. */
    638639                                if (width != -1) {
    639                                         cur_limited = posix_strndup(cur_borrowed, width);
     640                                        cur_duplicated = posix_strndup(cur_borrowed, width);
     641                                        cur_limited = cur_duplicated;
    640642                                } else {
    641643                                        cur_limited = cur_borrowed;
    642644                                }
    643                                 cur_updated = (char *) cur_limited;
     645                                cur_updated = cur_limited;
    644646
    645647                                long long sres = 0;
    … …  
    648650                                /* Try to convert the integer. */
    649651                                if (int_conv_unsigned) {
    650                                         ures = strtoull(cur_limited, &cur_updated, int_conv_base);
     652                                        ures = strtoull(cur_limited, (char **) &cur_updated, int_conv_base);
    651653                                } else {
    652                                         sres = strtoll(cur_limited, &cur_updated, int_conv_base);
     654                                        sres = strtoll(cur_limited, (char **) &cur_updated, int_conv_base);
    653655                                }
    654656
    655657                                /* Update the cursor so it can be returned to the provider. */
    656658                                cur_borrowed += cur_updated - cur_limited;
    657                                 if (width != -1 && cur_limited != NULL) {
     659                                if (cur_duplicated != NULL) {
    658660                                        /* Deallocate duplicated part of the cursor view. */
    659                                         free(cur_limited);
     661                                        free(cur_duplicated);
    660662                                }
    661663                                cur_limited = NULL;
    662664                                cur_updated = NULL;
     665                                cur_duplicated = NULL;
    663666                                /* Return the cursor to the provider. Input consistency is again
    664667                                 * the job of the provider, so we can report errors from
    … …  
    797800                                const char *cur_borrowed = NULL;
    798801                                const char *cur_limited = NULL;
    799                                 char *cur_updated = NULL;
     802                                char *cur_duplicated = NULL;
     803                                const char *cur_updated = NULL;
    800804
    801805                                /* Borrow the cursor. Until it is returned to the provider
    … …  
    808812                                 * than allowed by width. */
    809813                                if (width != -1) {
    810                                         cur_limited = posix_strndup(cur_borrowed, width);
     814                                        cur_duplicated = posix_strndup(cur_borrowed, width);
     815                                        cur_limited = cur_duplicated;
    811816                                } else {
    812817                                        cur_limited = cur_borrowed;
    813818                                }
    814                                 cur_updated = (char *) cur_limited;
     819                                cur_updated = cur_limited;
    815820
    816821                                float fres = 0.0;
    … …  
    821826                                switch (length_mod) {
    822827                                case LMOD_NONE:
    823                                         fres = posix_strtof(cur_limited, &cur_updated);
     828                                        fres = posix_strtof(cur_limited, (char **) &cur_updated);
    824829                                        break;
    825830                                case LMOD_l:
    826                                         dres = posix_strtod(cur_limited, &cur_updated);
     831                                        dres = posix_strtod(cur_limited, (char **) &cur_updated);
    827832                                        break;
    828833                                case LMOD_L:
    829                                         ldres = posix_strtold(cur_limited, &cur_updated);
     834                                        ldres = posix_strtold(cur_limited, (char **) &cur_updated);
    830835                                        break;
    831836                                default:
    … …  
    835840                                /* Update the cursor so it can be returned to the provider. */
    836841                                cur_borrowed += cur_updated - cur_limited;
    837                                 if (width != -1 && cur_limited != NULL) {
     842                                if (cur_duplicated != NULL) {
    838843                                        /* Deallocate duplicated part of the cursor view. */
    839                                         free(cur_limited);
     844                                        free(cur_duplicated);
    840845                                }
    841846                                cur_limited = NULL;

  • uspace/lib/usbdev/include/usb/dev/alternate_ifaces.h

    rd39c46e0 r33b8d024  
    5959typedef struct {
    6060        /** Array of alternate interfaces descriptions. */
    61         const usb_alternate_interface_descriptors_t *alternatives;
     61        usb_alternate_interface_descriptors_t *alternatives;
    6262        /** Size of @c alternatives array. */
    6363        size_t alternative_count;

  • uspace/lib/usbdev/include/usb/dev/device.h

    rd39c46e0 r33b8d024  
    5151        usb_standard_device_descriptor_t device;
    5252        /** Full configuration descriptor of current configuration. */
    53         const void *full_config;
     53        void *full_config;
    5454        size_t full_config_size;
    5555} usb_device_descriptors_t;

  • uspace/lib/usbdev/include/usb/dev/request.h

    rd39c46e0 r33b8d024  
    7070    void *, size_t, size_t *);
    7171errno_t usb_request_get_full_configuration_descriptor_alloc(usb_pipe_t *,
    72     int, const void **, size_t *);
     72    int, void **, size_t *);
    7373errno_t usb_request_set_descriptor(usb_pipe_t *, usb_request_type_t,
    7474    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, const void *, size_t);

  • uspace/lib/usbdev/src/devpoll.c

    rd39c46e0 r33b8d024  
    8080{
    8181        assert(arg);
    82         const polling_data_t *data = arg;
     82        polling_data_t *data = arg;
    8383        /* Helper to reduce typing. */
    8484        const usb_device_auto_polling_t *params = &data->auto_polling;

  • uspace/lib/usbdev/src/recognise.c

    rd39c46e0 r33b8d024  
    6161 */
    6262static errno_t usb_add_match_id(match_id_list_t *matches, int score,
    63     const char *match_str)
     63    char *match_str)
    6464{
    6565        assert(matches);

  • uspace/lib/usbdev/src/request.c

    rd39c46e0 r33b8d024  
    475475errno_t usb_request_get_full_configuration_descriptor_alloc(
    476476    usb_pipe_t *pipe, int index,
    477     const void **descriptor_ptr, size_t *descriptor_size)
     477    void **descriptor_ptr, size_t *descriptor_size)
    478478{
    479479        errno_t rc;

  • uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h

    rd39c46e0 r33b8d024  
    105105    void *arg
    106106);
    107 void usb_transfer_batch_destroy(const usb_transfer_batch_t *instance);
     107void usb_transfer_batch_destroy(usb_transfer_batch_t *instance);
    108108
    109109void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance,

  • uspace/lib/usbhost/src/usb_transfer_batch.c

    rd39c46e0 r33b8d024  
    9494 * @param[in] instance Batch structure to use.
    9595 */
    96 void usb_transfer_batch_destroy(const usb_transfer_batch_t *instance)
     96void usb_transfer_batch_destroy(usb_transfer_batch_t *instance)
    9797{
    9898        if (!instance)

  • uspace/lib/usbvirt/include/usbvirt/device.h

    rd39c46e0 r33b8d024  
    154154        usb_standard_configuration_descriptor_t *descriptor;
    155155        /** Array of extra data. */
    156         const usbvirt_device_configuration_extras_t *extra;
     156        usbvirt_device_configuration_extras_t *extra;
    157157        /** Length of @c extra array. */
    158158        size_t extra_count;
Note: See TracChangeset for help on using the changeset viewer.