Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset b5143bd in mainline


Ignore:
Timestamp:
2015-06-06T01:50:56Z (6 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
master
Children:
0453261
Parents:
94e46c9 (diff), 87a2f9b (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:

mainline changes

Files:
45 edited

Legend:

Unmodified
Added
Removed
  • abi/include/abi/proc/uarg.h

    r94e46c9 rb5143bd  
    4242        size_t uspace_stack_size;
    4343       
    44         void (* uspace_thread_function)();
     44        void (* uspace_thread_function)(void *);
    4545        void *uspace_thread_arg;
    4646       
  • boot/arch/arm32/src/mm.c

    r94e46c9 rb5143bd  
    193193}
    194194
    195 static void enable_paging()
    196 {
    197         /* c3   - each two bits controls access to the one of domains (16)
     195static void enable_paging(void)
     196{
     197        /*
     198         * c3   - each two bits controls access to the one of domains (16)
    198199         * 0b01 - behave as a client (user) of a domain
    199200         */
     
    232233
    233234/** Start the MMU - initialize page table and enable paging. */
    234 void mmu_start() {
     235void mmu_start(void)
     236{
    235237        disable_paging();
    236238#ifdef PROCESSOR_ARCH_armv7_a
  • boot/arch/ppc32/include/asm.h

    r94e46c9 rb5143bd  
    3535extern void jump_to_kernel(void *, void *, size_t, void *)
    3636    __attribute__((noreturn));
    37 extern void real_mode();
     37extern void real_mode(void);
    3838
    3939#endif
  • boot/arch/sparc32/src/ambapp.c

    r94e46c9 rb5143bd  
    5858static void ambapp_scan_area(uintptr_t, unsigned int);
    5959
    60 void ambapp_scan()
     60void ambapp_scan(void)
    6161{
    6262        amba_fake = false;
     
    104104}
    105105
    106 void ambapp_qemu_fake_scan()
     106void ambapp_qemu_fake_scan(void)
    107107{
    108108        /* UART */
     
    134134}
    135135
    136 bool ambapp_fake()
     136bool ambapp_fake(void)
    137137{
    138138        return amba_fake;
    139139}
    140140
    141 void ambapp_print_devices()
     141void ambapp_print_devices(void)
    142142{
    143143        printf("ABMA devices:\n");
  • boot/arch/sparc32/src/mm.c

    r94e46c9 rb5143bd  
    7676}
    7777
    78 static void mmu_disable()
     78static void mmu_disable(void)
    7979{
    8080        uint32_t cr = asi_u32_read(ASI_MMUREGS, 0x000);
  • boot/generic/include/memstr.h

    r94e46c9 rb5143bd  
    3636
    3737extern void *memcpy(void *, const void *, size_t)
    38     __attribute__ ((optimize("-fno-tree-loop-distribute-patterns")));
     38    __attribute__((nonnull(1, 2)))
     39    __attribute__((optimize("-fno-tree-loop-distribute-patterns")));
    3940extern void *memset(void *, int, size_t)
    40     __attribute__ ((optimize("-fno-tree-loop-distribute-patterns")));
    41 extern void *memmove(void *, const void *, size_t);
     41    __attribute__((nonnull(1)))
     42    __attribute__((optimize("-fno-tree-loop-distribute-patterns")));
     43extern void *memmove(void *, const void *, size_t)
     44    __attribute__((nonnull(1, 2)));
    4245
    4346#endif
  • contrib/bazaar/bzreml/__init__.py

    r94e46c9 rb5143bd  
    7070       
    7171        sender_user, sender_email = parseaddr(sender)
    72         payload = MIMEText(body.encode("utf-8"), "plain", "utf-8")
     72        payload = MIMEText(body.decode("utf-8", 'ignore').encode("utf-8", 'ignore'), "plain", "utf-8")
    7373       
    7474        msg = MIMEMultipart()
  • contrib/bazaar/mbprotect/__init__.py

    r94e46c9 rb5143bd  
    6060                return
    6161       
    62         # First permitted case is appending changesets to main branch.Look for
     62        # First permitted case is appending changesets to main branch. Look for
    6363        # old tip in new main branch.
    6464        for revision_id in iter_reverse_revision_history(repo, params.new_revid):
    6565                if revision_id == params.old_revid:
    66                         return  # Found old tip
     66                        # Old tip found
     67                        return
    6768       
    6869        # Another permitted case is backing out changesets. Look for new tip
     
    7071        for revision_id in iter_reverse_revision_history(repo, params.old_revid):
    7172                if revision_id == params.new_revid:
    72                         return  # Found new tip
     73                        # New tip found
     74                        return
    7375       
    7476        # Trying to do something else. Reject the change.
  • kernel/arch/abs32le/src/abs32le.c

    r94e46c9 rb5143bd  
    6969}
    7070
    71 void arch_post_cpu_init()
     71void arch_post_cpu_init(void)
    7272{
    7373}
  • kernel/arch/amd64/include/arch/asm.h

    r94e46c9 rb5143bd  
    339339 *
    340340 */
    341 NO_TRACE static inline void enable_l_apic_in_msr()
     341NO_TRACE static inline void enable_l_apic_in_msr(void)
    342342{
    343343        asm volatile (
  • kernel/arch/amd64/src/fpu_context.c

    r94e46c9 rb5143bd  
    5454}
    5555
    56 void fpu_init()
     56void fpu_init(void)
    5757{
    5858        /* TODO: Zero all SSE, MMX etc. registers */
  • kernel/arch/arm32/include/arch/cp15.h

    r94e46c9 rb5143bd  
    4747
    4848#define CONTROL_REG_GEN_READ(name, crn, opc1, crm, opc2) \
    49 static inline uint32_t name##_read() \
     49static inline uint32_t name##_read(void) \
    5050{ \
    5151        uint32_t val; \
  • kernel/arch/arm32/include/arch/security_ext.h

    r94e46c9 rb5143bd  
    4646 * older archs.
    4747 */
    48 static inline bool sec_ext_is_implemented()
     48static inline bool sec_ext_is_implemented(void)
    4949{
    5050#ifdef PROCESSOR_ARCH_armv7_a
     
    6060 * mode.
    6161 */
    62 static inline bool sec_ext_is_monitor_mode()
     62static inline bool sec_ext_is_monitor_mode(void)
    6363{
    6464        return (current_status_reg_read() & MODE_MASK) == MONITOR_MODE;
     
    7575 * Look for 'secureworld_exit' in arch/arm/cpu/armv7/omap3/board.c.
    7676 */
    77 static inline bool sec_ext_is_secure()
     77static inline bool sec_ext_is_secure(void)
    7878{
    7979        return sec_ext_is_implemented()
  • kernel/arch/arm32/src/arm32.c

    r94e46c9 rb5143bd  
    158158
    159159/** Reboot. */
    160 void arch_reboot()
     160void arch_reboot(void)
    161161{
    162162        /* not implemented */
  • kernel/arch/arm32/src/fpu_context.c

    r94e46c9 rb5143bd  
    101101        FPSCR_EN_ALL = FPSCR_DENORMAL_EN_FLAG | FPSCR_INEXACT_EN_FLAG | FPSCR_UNDERFLOW_EN_FLAG | FPSCR_OVERFLOW_EN_FLAG | FPSCR_ZERO_DIV_EN_FLAG | FPSCR_INVALID_OP_EN_FLAG,
    102102};
     103
    103104extern uint32_t fpscr_read(void);
    104105extern void fpscr_write(uint32_t);
     
    114115static void (*restore_context)(fpu_context_t *ctx);
    115116
    116 static int fpu_have_coprocessor_access()
    117 {
    118 /* The register containing the information (CPACR) is not available on armv6-
     117static int fpu_have_coprocessor_access(void)
     118{
     119/*
     120 * The register containing the information (CPACR) is not available on armv6-
    119121 * rely on user decision to use CONFIG_FPU.
    120122 */
     
    143145 * @note do we need to call secure monitor here?
    144146 */
    145 static void fpu_enable_coprocessor_access()
    146 {
    147 /* The register containing the information (CPACR) is not available on armv6-
     147static void fpu_enable_coprocessor_access(void)
     148{
     149/*
     150 * The register containing the information (CPACR) is not available on armv6-
    148151 * rely on user decision to use CONFIG_FPU.
    149152 */
  • kernel/arch/ia32/src/fpu_context.c

    r94e46c9 rb5143bd  
    125125
    126126/** Initialize x87 FPU. Mask all exceptions. */
    127 void fpu_init()
     127void fpu_init(void)
    128128{
    129129        uint32_t help0 = 0;
  • kernel/arch/ia64/src/mm/vhpt.c

    r94e46c9 rb5143bd  
    8282}
    8383
    84 void vhpt_invalidate_all()
     84void vhpt_invalidate_all(void)
    8585{
    8686        memsetb(vhpt_base, VHPT_SIZE, 0);
  • kernel/arch/mips32/src/debugger.c

    r94e46c9 rb5143bd  
    288288 *
    289289 */
    290 void debugger_init()
     290void debugger_init(void)
    291291{
    292292        unsigned int i;
  • kernel/arch/mips32/src/fpu_context.c

    r94e46c9 rb5143bd  
    5353}
    5454
    55 void fpu_init()
     55void fpu_init(void)
    5656{
    5757        /* TODO: Zero all registers */
  • kernel/arch/sparc32/src/sparc32.c

    r94e46c9 rb5143bd  
    9696
    9797
    98 void arch_post_cpu_init()
     98void arch_post_cpu_init(void)
    9999{
    100100}
  • kernel/generic/include/lib/memfnc.h

    r94e46c9 rb5143bd  
    4646
    4747extern void *memset(void *, int, size_t)
     48    __attribute__((nonnull(1)))
    4849    ATTRIBUTE_OPTIMIZE("-fno-tree-loop-distribute-patterns") DO_NOT_DISCARD;
    4950extern void *memcpy(void *, const void *, size_t)
     51    __attribute__((nonnull(1, 2)))
    5052    ATTRIBUTE_OPTIMIZE("-fno-tree-loop-distribute-patterns") DO_NOT_DISCARD;
    5153
  • kernel/generic/include/memstr.h

    r94e46c9 rb5143bd  
    4848#define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
    4949
    50 extern void memsetb(void *, size_t, uint8_t);
    51 extern void memsetw(void *, size_t, uint16_t);
    52 extern void *memmove(void *, const void *, size_t) DO_NOT_DISCARD;
     50extern void memsetb(void *, size_t, uint8_t)
     51    __attribute__((nonnull(1)));
     52extern void memsetw(void *, size_t, uint16_t)
     53    __attribute__((nonnull(1)));
     54extern void *memmove(void *, const void *, size_t)
     55    __attribute__((nonnull(1, 2))) DO_NOT_DISCARD;
    5356
    5457#endif
  • kernel/generic/include/mm/slab.h

    r94e46c9 rb5143bd  
    142142extern void *malloc(size_t, unsigned int)
    143143    __attribute__((malloc));
    144 extern void *realloc(void *, size_t, unsigned int);
     144extern void *realloc(void *, size_t, unsigned int)
     145    __attribute__((warn_unused_result));
    145146extern void free(void *);
    146147
  • kernel/generic/include/typedefs.h

    r94e46c9 rb5143bd  
    5050} atomic_t;
    5151
    52 typedef void (* function)();
     52typedef void (* function)(void);
    5353
    5454typedef uint32_t container_id_t;
  • kernel/generic/src/ipc/ops/conctmeto.c

    r94e46c9 rb5143bd  
    4444        int newphid = phone_alloc(TASK);
    4545
     46        /* Remember the phoneid or the error. */
     47        call->priv = newphid;
    4648        if (newphid < 0)
    4749                return ELIMIT;
     
    4951        /* Set arg5 for server */
    5052        IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]);
    51         call->priv = newphid;
    5253
    5354        return EOK;
     
    7374static int answer_process(call_t *answer)
    7475{
    75         if (IPC_GET_RETVAL(answer->data))
    76                 phone_dealloc(answer->priv);
    77         else
    78                 IPC_SET_ARG5(answer->data, answer->priv);
     76        int newphid = (int) answer->priv;
     77
     78        if (IPC_GET_RETVAL(answer->data)) {
     79                if (newphid >= 0) {
     80                        /*
     81                         * The phone was indeed allocated and now needs
     82                         * to be deallocated.
     83                         */
     84                        phone_dealloc(newphid);
     85                }
     86        } else {
     87                IPC_SET_ARG5(answer->data, newphid);
     88        }
    7989       
    8090        return EOK;
  • kernel/generic/src/ipc/sysipc.c

    r94e46c9 rb5143bd  
    388388{
    389389        call_t *call = get_call(callid);
    390         phone_t *phone;
    391         bool need_old = answer_need_old(call);
    392         bool after_forward = false;
    393         ipc_data_t old;
    394         int rc;
    395 
    396390        if (!call)
    397391                return ENOENT;
    398 
     392       
     393        ipc_data_t old;
     394        bool need_old = answer_need_old(call);
    399395        if (need_old)
    400396                old = call->data;
     397       
     398        bool after_forward = false;
     399        int rc;
     400        phone_t *phone;
    401401       
    402402        if (phone_get(phoneid, &phone) != EOK) {
     
    409409                goto error;
    410410        }
    411 
     411       
    412412        call->flags |= IPC_CALL_FORWARDED;
    413413       
  • kernel/generic/src/lib/func.c

    r94e46c9 rb5143bd  
    5151 *
    5252 */
    53 void halt()
     53void halt(void)
    5454{
    5555#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
  • kernel/generic/src/mm/as.c

    r94e46c9 rb5143bd  
    834834                        if ((cond = (bool) node->keys)) {
    835835                                uintptr_t ptr = node->key[node->keys - 1];
    836                                 size_t size =
     836                                size_t node_size =
    837837                                    (size_t) node->value[node->keys - 1];
    838838                                size_t i = 0;
    839839                               
    840                                 if (overlaps(ptr, P2SZ(size), area->base,
     840                                if (overlaps(ptr, P2SZ(node_size), area->base,
    841841                                    P2SZ(pages))) {
    842842                                       
    843                                         if (ptr + P2SZ(size) <= start_free) {
     843                                        if (ptr + P2SZ(node_size) <= start_free) {
    844844                                                /*
    845845                                                 * The whole interval fits
     
    860860                                        i = (start_free - ptr) >> PAGE_WIDTH;
    861861                                        if (!used_space_remove(area, start_free,
    862                                             size - i))
     862                                            node_size - i))
    863863                                                panic("Cannot remove used space.");
    864864                                } else {
     
    867867                                         * completely removed.
    868868                                         */
    869                                         if (!used_space_remove(area, ptr, size))
     869                                        if (!used_space_remove(area, ptr, node_size))
    870870                                                panic("Cannot remove used space.");
    871871                                }
     
    887887                                    area->pages - pages);
    888888               
    889                                 for (; i < size; i++) {
     889                                for (; i < node_size; i++) {
    890890                                        pte_t *pte = page_mapping_find(as,
    891891                                            ptr + P2SZ(i), false);
  • kernel/generic/src/mm/slab.c

    r94e46c9 rb5143bd  
    610610    unsigned int kmflag), size_t (*destructor)(void *obj), unsigned int flags)
    611611{
     612        ASSERT(size > 0);
     613       
    612614        memsetb(cache, sizeof(*cache), 0);
    613615        cache->name = name;
     
    888890        /* Initialize magazine cache */
    889891        _slab_cache_create(&mag_cache, "slab_magazine_t",
    890             sizeof(slab_magazine_t) + SLAB_MAG_SIZE * sizeof(void*),
     892            sizeof(slab_magazine_t) + SLAB_MAG_SIZE * sizeof(void *),
    891893            sizeof(uintptr_t), NULL, NULL, SLAB_CACHE_NOMAGAZINE |
    892894            SLAB_CACHE_SLINSIDE);
  • kernel/generic/src/udebug/udebug_ops.c

    r94e46c9 rb5143bd  
    375375        if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) {
    376376                mutex_unlock(&TASK->udebug.lock);
     377                free(id_buffer);
    377378                return EINVAL;
    378379        }
     
    456457int udebug_args_read(thread_t *thread, void **buffer)
    457458{
    458         /* Prepare a buffer to hold the arguments. */
    459         sysarg_t *arg_buffer = malloc(6 * sizeof(sysarg_t), 0);
    460        
    461459        /* On success, this will lock t->udebug.lock. */
    462460        int rc = _thread_op_begin(thread, false);
     
    471469        }
    472470       
     471        /* Prepare a buffer to hold the arguments. */
     472        sysarg_t *arg_buffer = malloc(6 * sizeof(sysarg_t), 0);
     473       
    473474        /* Copy to a local buffer before releasing the lock. */
    474475        memcpy(arg_buffer, thread->udebug.syscall_args, 6 * sizeof(sysarg_t));
     
    499500int udebug_regs_read(thread_t *thread, void **buffer)
    500501{
    501         /* Prepare a buffer to hold the data. */
    502         istate_t *state_buf = malloc(sizeof(istate_t), 0);
    503        
    504502        /* On success, this will lock t->udebug.lock */
    505503        int rc = _thread_op_begin(thread, false);
     
    512510                return EBUSY;
    513511        }
     512       
     513        /* Prepare a buffer to hold the data. */
     514        istate_t *state_buf = malloc(sizeof(istate_t), 0);
    514515       
    515516        /* Copy to the allocated buffer */
  • uspace/app/bdsh/cmds/modules/cat/cat.c

    r94e46c9 rb5143bd  
    108108}
    109109
    110 static void waitprompt()
     110static void waitprompt(void)
    111111{
    112112        console_set_pos(console, 0, console_rows-1);
     
    120120}
    121121
    122 static void waitkey()
     122static void waitkey(void)
    123123{
    124124        cons_event_t ev;
     
    149149}
    150150
    151 static void newpage()
     151static void newpage(void)
    152152{
    153153        console_clear(console);
  • uspace/app/bdsh/input.c

    r94e46c9 rb5143bd  
    219219}
    220220
    221 void print_pipe_usage()
     221void print_pipe_usage(void)
    222222{
    223223        printf("Invalid syntax!\n");
  • uspace/app/trace/trace.c

    r94e46c9 rb5143bd  
    730730}
    731731
    732 static void print_syntax()
     732static void print_syntax(void)
    733733{
    734734        printf("Syntax:\n");
  • uspace/drv/bus/usb/vhc/devconn.c

    r94e46c9 rb5143bd  
    3232
    3333
    34 static vhc_virtdev_t *vhc_virtdev_create()
     34static vhc_virtdev_t *vhc_virtdev_create(void)
    3535{
    3636        vhc_virtdev_t *dev = malloc(sizeof(vhc_virtdev_t));
  • uspace/lib/c/generic/getopt.c

    r94e46c9 rb5143bd  
    9595 * Compute the greatest common divisor of a and b.
    9696 */
    97 static int
    98 gcd(a, b)
    99         int a;
    100         int b;
     97static int gcd(int a, int b)
    10198{
    10299        int c;
    103 
     100       
    104101        c = a % b;
    105102        while (c != 0) {
     
    108105                c = a % b;
    109106        }
    110            
     107       
    111108        return b;
    112109}
     
    117114 * in each block).
    118115 */
    119 static void
    120 permute_args(panonopt_start, panonopt_end, opt_end, nargv)
    121         int panonopt_start;
    122         int panonopt_end;
    123         int opt_end;
    124         char **nargv;
     116static void permute_args(int panonopt_start, int panonopt_end, int opt_end,
     117    char **nargv)
    125118{
    126119        int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
     
    157150 *  Returns -2 if -- is found (can be long option or end of options marker).
    158151 */
    159 static int
    160 getopt_internal(nargc, nargv, options)
    161         int nargc;
    162         char **nargv;
    163         const char *options;
     152static int getopt_internal(int nargc, char **nargv, const char *options)
    164153{
    165154        const char *oli;                                /* option letter list index */
     
    299288 *      Parse argc/argv argument vector.
    300289 */
    301 int
    302 getopt(nargc, nargv, options)
    303         int nargc;
    304         char * const *nargv;
    305         const char *options;
     290int getopt(int nargc, char * const *nargv, const char *options)
    306291{
    307292        int retval;
     
    332317 *      Parse argc/argv argument vector.
    333318 */
    334 int
    335 getopt_long(nargc, nargv, options, long_options, idx)
    336         int nargc;
    337         char * const *nargv;
    338         const char *options;
    339         const struct option *long_options;
    340         int *idx;
     319int getopt_long(int nargc, char * const *nargv, const char *options,
     320    const struct option *long_options, int *idx)
    341321{
    342322        int retval;
  • uspace/lib/c/include/malloc.h

    r94e46c9 rb5143bd  
    4444extern void *memalign(const size_t align, const size_t size)
    4545    __attribute__((malloc));
    46 extern void *realloc(const void *addr, const size_t size);
     46extern void *realloc(const void *addr, const size_t size)
     47    __attribute__((warn_unused_result));
    4748extern void free(const void *addr);
    4849extern void *heap_check(void);
  • uspace/lib/c/include/mem.h

    r94e46c9 rb5143bd  
    4040
    4141extern void *memset(void *, int, size_t)
     42    __attribute__((nonnull(1)))
    4243    ATTRIBUTE_OPTIMIZE("-fno-tree-loop-distribute-patterns");
    4344extern void *memcpy(void *, const void *, size_t)
     45    __attribute__((nonnull(1, 2)))
    4446    ATTRIBUTE_OPTIMIZE("-fno-tree-loop-distribute-patterns");
    45 extern void *memmove(void *, const void *, size_t);
    46 extern int memcmp(const void *, const void *, size_t);
     47extern void *memmove(void *, const void *, size_t)
     48    __attribute__((nonnull(1, 2)));
     49extern int memcmp(const void *, const void *, size_t)
     50    __attribute__((nonnull(1, 2)));
    4751
    4852#endif
  • uspace/lib/c/include/task.h

    r94e46c9 rb5143bd  
    6060extern int task_spawn(task_id_t *, task_wait_t *, const char *path, int,
    6161    va_list ap);
    62 extern int task_spawnl(task_id_t *, task_wait_t *, const char *path, ...);
     62extern int task_spawnl(task_id_t *, task_wait_t *, const char *path, ...)
     63    __attribute__((sentinel));
    6364
    6465extern int task_setup_wait(task_id_t, task_wait_t *);
  • uspace/lib/ieee80211/src/ieee80211.c

    r94e46c9 rb5143bd  
    718718 *
    719719 */
    720 ieee80211_dev_t *ieee80211_device_create()
     720ieee80211_dev_t *ieee80211_device_create(void)
    721721{
    722722        return calloc(1, sizeof(ieee80211_dev_t));
  • uspace/lib/pcut/src/run.c

    r94e46c9 rb5143bd  
    7373static int default_suite_initialized = 0;
    7474
    75 static void init_default_suite_when_needed() {
    76         if (default_suite_initialized) {
     75static void init_default_suite_when_needed(void)
     76{
     77        if (default_suite_initialized)
    7778                return;
    78         }
     79       
    7980        default_suite.id = -1;
    8081        default_suite.kind = PCUT_KIND_TESTSUITE;
     
    9192 * @return Always a valid test suite item.
    9293 */
    93 static pcut_item_t *pcut_find_parent_suite(pcut_item_t *it) {
     94static pcut_item_t *pcut_find_parent_suite(pcut_item_t *it)
     95{
    9496        while (it != NULL) {
    95                 if (it->kind == PCUT_KIND_TESTSUITE) {
     97                if (it->kind == PCUT_KIND_TESTSUITE)
    9698                        return it;
    97                 }
     99               
    98100                it = it->previous;
    99101        }
     102       
    100103        init_default_suite_when_needed();
    101104        return &default_suite;
     
    106109 * @param func Function to run (can be NULL).
    107110 */
    108 static void run_setup_teardown(pcut_setup_func_t func) {
    109         if (func != NULL) {
     111static void run_setup_teardown(pcut_setup_func_t func)
     112{
     113        if (func != NULL)
    110114                func();
    111         }
    112115}
    113116
     
    119122 * @param outcome Outcome of the current test.
    120123 */
    121 static void leave_test(int outcome) {
     124static void leave_test(int outcome)
     125{
    122126        PCUT_DEBUG("leave_test(outcome=%d), will_exit=%s", outcome,
    123                 leave_means_exit ? "yes" : "no");
    124         if (leave_means_exit) {
     127            leave_means_exit ? "yes" : "no");
     128        if (leave_means_exit)
    125129                exit(outcome);
    126         }
    127 
     130       
    128131#ifndef PCUT_NO_LONG_JUMP
    129132        longjmp(start_test_jump, 1);
     
    138141 * @param message Message describing the failure.
    139142 */
    140 void pcut_failed_assertion(const char *message) {
     143void pcut_failed_assertion(const char *message)
     144{
    141145        static const char *prev_message = NULL;
     146       
    142147        /*
    143148         * The assertion failed. We need to abort the current test,
     
    145150         * include running the tear-down routine.
    146151         */
    147         if (print_test_error) {
     152        if (print_test_error)
    148153                pcut_print_fail_message(message);
    149         }
    150 
     154       
    151155        if (execute_teardown_on_failure) {
    152156                execute_teardown_on_failure = 0;
    153157                prev_message = message;
    154158                run_setup_teardown(current_suite->teardown_func);
    155 
     159               
    156160                /* Tear-down was okay. */
    157161                if (report_test_result) {
     
    165169                }
    166170        }
    167 
     171       
    168172        prev_message = NULL;
    169 
     173       
    170174        leave_test(TEST_OUTCOME_FAIL); /* No return. */
    171175}
     
    176180 * @return Error status (zero means success).
    177181 */
    178 static int run_test(pcut_item_t *test) {
     182static int run_test(pcut_item_t *test)
     183{
    179184        /*
    180185         * Set here as the returning point in case of test failure.
     
    182187         * test execution.
    183188         */
     189       
    184190#ifndef PCUT_NO_LONG_JUMP
    185191        int test_finished = setjmp(start_test_jump);
    186         if (test_finished) {
     192        if (test_finished)
    187193                return 1;
    188         }
    189194#endif
    190 
    191         if (report_test_result) {
     195       
     196        if (report_test_result)
    192197                pcut_report_test_start(test);
    193         }
    194 
     198       
    195199        current_suite = pcut_find_parent_suite(test);
    196200        current_test = test;
    197 
     201       
    198202        pcut_hook_before_test(test);
    199 
     203       
    200204        /*
    201205         * If anything goes wrong, execute the tear-down function
     
    203207         */
    204208        execute_teardown_on_failure = 1;
    205 
     209       
    206210        /*
    207211         * Run the set-up function.
    208212         */
    209213        run_setup_teardown(current_suite->setup_func);
    210 
     214       
    211215        /*
    212216         * The setup function was performed, it is time to run
     
    214218         */
    215219        test->test_func();
    216 
     220       
    217221        /*
    218222         * Finally, run the tear-down function. We need to clear
     
    221225        execute_teardown_on_failure = 0;
    222226        run_setup_teardown(current_suite->teardown_func);
    223 
     227       
    224228        /*
    225229         * If we got here, it means everything went well with
    226230         * this test.
    227231         */
    228         if (report_test_result) {
     232        if (report_test_result)
    229233                pcut_report_test_done(current_test, TEST_OUTCOME_PASS,
    230                         NULL, NULL, NULL);
    231         }
    232 
     234                    NULL, NULL, NULL);
     235       
    233236        return 0;
    234237}
     
    242245 * @return Error status (zero means success).
    243246 */
    244 int pcut_run_test_forked(pcut_item_t *test) {
    245         int rc;
    246 
     247int pcut_run_test_forked(pcut_item_t *test)
     248{
    247249        report_test_result = 0;
    248250        print_test_error = 1;
    249251        leave_means_exit = 1;
    250 
    251         rc = run_test(test);
    252 
     252       
     253        int rc = run_test(test);
     254       
    253255        current_test = NULL;
    254256        current_suite = NULL;
    255 
     257       
    256258        return rc;
    257259}
     
    265267 * @return Error status (zero means success).
    266268 */
    267 int pcut_run_test_single(pcut_item_t *test) {
    268         int rc;
    269 
     269int pcut_run_test_single(pcut_item_t *test)
     270{
    270271        report_test_result = 1;
    271272        print_test_error = 0;
    272273        leave_means_exit = 0;
    273 
    274         rc = run_test(test);
    275 
     274       
     275        int rc = run_test(test);
     276       
    276277        current_test = NULL;
    277278        current_suite = NULL;
    278 
     279       
    279280        return rc;
    280281}
     
    285286 * @return Timeout in seconds.
    286287 */
    287 int pcut_get_test_timeout(pcut_item_t *test) {
     288int pcut_get_test_timeout(pcut_item_t *test)
     289{
    288290        int timeout = PCUT_DEFAULT_TEST_TIMEOUT;
    289291        pcut_extra_t *extras = test->extras;
    290 
    291 
     292       
    292293        while (extras->type != PCUT_EXTRA_LAST) {
    293                 if (extras->type == PCUT_EXTRA_TIMEOUT) {
     294                if (extras->type == PCUT_EXTRA_TIMEOUT)
    294295                        timeout = extras->timeout;
    295                 }
     296               
    296297                extras++;
    297298        }
    298 
     299       
    299300        return timeout;
    300301}
  • uspace/lib/posix/include/posix/stdlib.h

    r94e46c9 rb5143bd  
    116116
    117117/* Memory Allocation */
    118 extern void *__POSIX_DEF__(malloc)(size_t size);
    119 extern void *__POSIX_DEF__(calloc)(size_t nelem, size_t elsize);
    120 extern void *__POSIX_DEF__(realloc)(void *ptr, size_t size);
     118extern void *__POSIX_DEF__(malloc)(size_t size)
     119    __attribute__((malloc));
     120extern void *__POSIX_DEF__(calloc)(size_t nelem, size_t elsize)
     121    __attribute__((malloc));
     122extern void *__POSIX_DEF__(realloc)(void *ptr, size_t size)
     123    __attribute__((warn_unused_result));
    121124extern void __POSIX_DEF__(free)(void *ptr);
    122125
  • uspace/lib/posix/include/posix/string.h

    r94e46c9 rb5143bd  
    6767/* From mem.h */
    6868// #define bzero(ptr, len)  memset((ptr), 0, (len))
    69 extern void *memset(void *, int, size_t);
    70 extern void *memcpy(void *, const void *, size_t);
    71 extern void *memmove(void *, const void *, size_t);
     69extern void *memset(void *, int, size_t)
     70    __attribute__((nonnull(1)));
     71extern void *memcpy(void *, const void *, size_t)
     72    __attribute__((nonnull(1, 2)));
     73extern void *memmove(void *, const void *, size_t)
     74    __attribute__((nonnull(1, 2)));
    7275
    7376
  • uspace/lib/posix/source/signal.c

    r94e46c9 rb5143bd  
    382382 * Raise all unblocked previously queued signals.
    383383 */
    384 static void _dequeue_unblocked_signals()
     384static void _dequeue_unblocked_signals(void)
    385385{
    386386        link_t *iterator = _signal_queue.head.next;
  • uspace/srv/bd/sata_bd/sata_bd.c

    r94e46c9 rb5143bd  
    147147 *
    148148 */
    149 static int get_sata_disks()
     149static int get_sata_disks(void)
    150150{
    151151        devman_handle_t root_fun;
  • uspace/srv/klog/klog.c

    r94e46c9 rb5143bd  
    5151#include <io/logctl.h>
    5252
    53 #define NAME       "klog"
     53#define NAME  "klog"
    5454
    5555typedef size_t __attribute__ ((aligned(1))) unaligned_size_t;
     
    9898 *
    9999 */
    100 static void producer()
     100static void producer(void)
    101101{
    102102        int read = klog_read(buffer, BUFFER_SIZE);
Note: See TracChangeset for help on using the changeset viewer.