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

Changeset 81f70b4 in mainline


Ignore:
Timestamp:
2012-03-31T18:14:08Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master
Children:
d5f99e6
Parents:
95c9158 (diff), 2f4fa79 (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 and some usb fixes.

Files:
1 added
25 edited

Legend:

Unmodified
Added
Removed
  • boot/Makefile.build

    r95c9158 r81f70b4  
    3434OPTIMIZATION = 3
    3535
    36 DEFS = -DRELEASE=$(RELEASE) "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
     36DEFS = -DRELEASE=$(RELEASE) "-DCOPYRIGHT=$(COPYRIGHT)" "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
    3737
    3838GCC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
  • boot/arch/ia64/src/main.c

    r95c9158 r81f70b4  
    189189        printf("\nInflating components ... ");
    190190       
     191        /*
     192         * We will use the next available address for a copy of each component to
     193         * make sure that inflate() works with disjunctive memory regions.
     194         */
     195        top = ALIGN_UP(top, PAGE_SIZE);
     196
    191197        for (i = cnt; i > 0; i--) {
    192198                printf("%s ", components[i - 1].name);
    193199               
    194                 int err = inflate(components[i - 1].start, components[i - 1].size,
     200                /*
     201                 * Copy the component to a location which is guaranteed not to
     202                 * overlap with the destination for inflate().
     203                 */
     204                memmove((void *) top, components[i - 1].start, components[i - 1].size);
     205               
     206                int err = inflate((void *) top, components[i - 1].size,
    195207                    dest[i - 1], components[i - 1].inflated);
    196208               
  • boot/generic/include/memstr.h

    r95c9158 r81f70b4  
    3636
    3737extern void *memcpy(void *, const void *, size_t);
     38extern void *memmove(void *, const void *, size_t);
    3839
    3940#endif
  • boot/generic/src/memstr.c

    r95c9158 r81f70b4  
    5151}
    5252
     53/** Move memory block with possible overlapping.
     54 *
     55 * Copy cnt bytes from src address to dst address. The source
     56 * and destination memory areas may overlap.
     57 *
     58 * @param dst Destination address to copy to.
     59 * @param src Source address to copy from.
     60 * @param cnt Number of bytes to copy.
     61 *
     62 * @return Destination address.
     63 *
     64 */
     65void *memmove(void *dst, const void *src, size_t cnt)
     66{
     67        /* Nothing to do? */
     68        if (src == dst)
     69                return dst;
     70       
     71        /* Non-overlapping? */
     72        if ((dst >= src + cnt) || (src >= dst + cnt))
     73                return memcpy(dst, src, cnt);
     74       
     75        uint8_t *dp;
     76        const uint8_t *sp;
     77       
     78        /* Which direction? */
     79        if (src > dst) {
     80                /* Forwards. */
     81                dp = dst;
     82                sp = src;
     83               
     84                while (cnt-- != 0)
     85                        *dp++ = *sp++;
     86        } else {
     87                /* Backwards. */
     88                dp = dst + (cnt - 1);
     89                sp = src + (cnt - 1);
     90               
     91                while (cnt-- != 0)
     92                        *dp-- = *sp--;
     93        }
     94       
     95        return dst;
     96}
     97
    5398/** @}
    5499 */
  • boot/generic/src/version.c

    r95c9158 r81f70b4  
    3232
    3333static const char *project = "HelenOS bootloader";
    34 static const char *copyright = "Copyright (c) 2001-2011 HelenOS project";
     34static const char *copyright = STRING(COPYRIGHT);
    3535static const char *release = STRING(RELEASE);
    3636static const char *name = STRING(NAME);
  • contrib/conf/mips32-gx.sh

    r95c9158 r81f70b4  
    88fi
    99
    10 gxemul $@ -E testmips -C R4000 -X image.boot -d d0:"$DISK_IMG"
     10gxemul $@ -E oldtestmips -C R4000 -X image.boot -d d0:"$DISK_IMG"
  • kernel/Makefile

    r95c9158 r81f70b4  
    9090endif
    9191
    92 DEFS = -DKERNEL -DRELEASE=$(RELEASE) "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
     92DEFS = -DKERNEL -DRELEASE=$(RELEASE) "-DCOPYRIGHT=$(COPYRIGHT)" "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
    9393
    9494GCC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
  • kernel/arch/ppc32/src/ppc32.c

    r95c9158 r81f70b4  
    130130                        visual = VISUAL_INDIRECT_8;
    131131                        break;
     132                case 15:
     133                        visual = VISUAL_RGB_5_5_5_BE;
     134                        break;
    132135                case 16:
    133                         visual = VISUAL_RGB_5_5_5_BE;
     136                        visual = VISUAL_RGB_5_6_5_BE;
    134137                        break;
    135138                case 24:
  • kernel/generic/include/str.h

    r95c9158 r81f70b4  
    9797extern bool wstr_remove(wchar_t *str, size_t pos);
    9898
    99 extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
     99extern int str_uint64_t(const char *, char **, unsigned int, bool, uint64_t *);
    100100
    101101extern void order_suffix(const uint64_t, uint64_t *, char *);
  • kernel/generic/src/console/cmd.c

    r95c9158 r81f70b4  
    906906                   ((char *) argv->buffer)[0] <= '9') {
    907907                uint64_t value;
    908                 rc = str_uint64((char *) argv->buffer, NULL, 0, true, &value);
     908                rc = str_uint64_t((char *) argv->buffer, NULL, 0, true, &value);
    909909                if (rc == EOK)
    910910                        addr = (uintptr_t) value;
  • kernel/generic/src/console/kconsole.c

    r95c9158 r81f70b4  
    472472                /* It's a number - convert it */
    473473                uint64_t value;
    474                 int rc = str_uint64(text, NULL, 0, true, &value);
     474                int rc = str_uint64_t(text, NULL, 0, true, &value);
    475475                switch (rc) {
    476476                case EINVAL:
  • kernel/generic/src/lib/str.c

    r95c9158 r81f70b4  
    893893 *
    894894 */
    895 int str_uint64(const char *nptr, char **endptr, unsigned int base,
     895int str_uint64_t(const char *nptr, char **endptr, unsigned int base,
    896896    bool strict, uint64_t *result)
    897897{
  • kernel/generic/src/main/version.c

    r95c9158 r81f70b4  
    3838
    3939static const char *project = "SPARTAN kernel";
    40 static const char *copyright = "Copyright (c) 2001-2011 HelenOS project";
     40static const char *copyright = STRING(COPYRIGHT);
    4141static const char *release = STRING(RELEASE);
    4242static const char *name = STRING(NAME);
  • kernel/generic/src/sysinfo/stats.c

    r95c9158 r81f70b4  
    474474        /* Parse the task ID */
    475475        task_id_t task_id;
    476         if (str_uint64(name, NULL, 0, true, &task_id) != EOK)
     476        if (str_uint64_t(name, NULL, 0, true, &task_id) != EOK)
    477477                return ret;
    478478       
     
    545545        /* Parse the thread ID */
    546546        thread_id_t thread_id;
    547         if (str_uint64(name, NULL, 0, true, &thread_id) != EOK)
     547        if (str_uint64_t(name, NULL, 0, true, &thread_id) != EOK)
    548548                return ret;
    549549       
     
    662662        /* Parse the exception number */
    663663        uint64_t excn;
    664         if (str_uint64(name, NULL, 0, true, &excn) != EOK)
     664        if (str_uint64_t(name, NULL, 0, true, &excn) != EOK)
    665665                return ret;
    666666       
  • uspace/app/bdsh/cmds/modules/ls/ls.c

    r95c9158 r81f70b4  
    4242#include <sort.h>
    4343
     44#include "ls.h"
    4445#include "errors.h"
    4546#include "config.h"
     
    4849#include "cmds.h"
    4950
    50 /* Various values that can be returned by ls_scope() */
    51 #define LS_BOGUS 0
    52 #define LS_FILE  1
    53 #define LS_DIR   2
    54 
    55 /** Structure to represent a directory entry.
    56  *
    57  * Useful to keep together important information
    58  * for sorting directory entries.
    59  */
    60 struct dir_elem_t {
    61         char *name;
    62         struct stat s;
    63 };
    64 
    6551static const char *cmdname = "ls";
     52
     53static ls_job_t ls;
    6654
    6755static struct option const long_options[] = {
    6856        { "help", no_argument, 0, 'h' },
    6957        { "unsort", no_argument, 0, 'u' },
     58        { "recursive", no_argument, 0, 'r' },
    7059        { 0, 0, 0, 0 }
    7160};
     61
     62/* Prototypes for the ls command, excluding entry points. */
     63static unsigned int ls_start(ls_job_t *);
     64static void ls_print(struct dir_elem_t *);
     65static int ls_cmp(void *, void *, void *);
     66static signed int ls_scan_dir(const char *, DIR *, struct dir_elem_t **);
     67static unsigned int ls_recursive(const char *, DIR *);
     68static unsigned int ls_scope(const char *, struct dir_elem_t *);
     69
     70static unsigned int ls_start(ls_job_t *ls)
     71{
     72        ls->recursive = 0;
     73        ls->sort = 1;
     74
     75        return 1;
     76}
    7277
    7378/** Print an entry.
     
    9297}
    9398
    94 
    9599/** Compare 2 directory elements.
    96100 *
     
    127131 *                              0 otherwise.
    128132 */
    129 static void ls_scan_dir(const char *d, DIR *dirp, int sort)
     133static signed int ls_scan_dir(const char *d, DIR *dirp,
     134    struct dir_elem_t **dir_list_ptr)
    130135{
    131136        int alloc_blocks = 20;
     
    140145       
    141146        if (!dirp)
    142                 return;
     147                return -1;
    143148
    144149        buff = (char *) malloc(PATH_MAX);
    145150        if (!buff) {
    146151                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
    147                 return;
     152                return -1;
    148153        }
    149154       
     
    152157                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
    153158                free(buff);
    154                 return;
     159                return -1;
    155160        }
    156161       
     
    187192        }
    188193       
    189         if (sort) {
     194        if (ls.sort) {
    190195                if (!qsort(&tosort[0], nbdirs, sizeof(struct dir_elem_t),
    191196                    ls_cmp, NULL)) {
     
    196201        for (i = 0; i < nbdirs; i++)
    197202                ls_print(&tosort[i]);
     203
     204        /* Populate the directory list. */
     205        if (ls.recursive) {
     206                tmp = (struct dir_elem_t *) realloc(*dir_list_ptr,
     207                    nbdirs * sizeof(struct dir_elem_t));
     208                if (!tmp) {
     209                        cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     210                        goto out;
     211                }
     212                *dir_list_ptr = tmp;
     213
     214                for (i = 0; i < nbdirs; i++) {
     215                        (*dir_list_ptr)[i].name = str_dup(tosort[i].name);
     216                        if (!(*dir_list_ptr)[i].name) {
     217                                cli_error(CL_ENOMEM, "ls: failed to scan %s", d);
     218                                goto out;
     219                        }
     220                }
     221        }
    198222       
    199223out:
     
    202226        free(tosort);
    203227        free(buff);
     228
     229        return nbdirs;
     230}
     231
     232/** Visit a directory recursively.
     233 *
     234 * ls_recursive visits all the subdirectories recursively and
     235 * prints the files and directories in them.
     236 *
     237 * @param path  Path the current directory being visited.
     238 * @param dirp  Directory stream.
     239 */
     240static unsigned int ls_recursive(const char *path, DIR *dirp)
     241{
     242        int i, nbdirs, ret;
     243        unsigned int scope;
     244        char *subdir_path;
     245        DIR *subdirp;
     246        struct dir_elem_t *dir_list;
     247       
     248        const char * const trailing_slash = "/";
     249
     250        nbdirs = 0;
     251        dir_list = (struct dir_elem_t *) malloc(sizeof(struct dir_elem_t));
     252
     253        printf("\n%s:\n", path);
     254
     255        subdir_path = (char *) malloc(PATH_MAX);
     256        if (!subdir_path) {
     257                ret = CMD_FAILURE;
     258                goto out;
     259        }
     260
     261        nbdirs = ls_scan_dir(path, dirp, &dir_list);
     262        if (nbdirs == -1) {
     263                ret = CMD_FAILURE;
     264                goto out;
     265        }
     266
     267        for (i = 0; i < nbdirs; ++i) {
     268                memset(subdir_path, 0, PATH_MAX);
     269
     270                if (str_size(subdir_path) + str_size(path) + 1 <= PATH_MAX)
     271                        str_append(subdir_path, PATH_MAX, path);
     272                if (path[str_size(path)-1] != '/' &&
     273                    str_size(subdir_path) + str_size(trailing_slash) + 1 <= PATH_MAX)
     274                        str_append(subdir_path, PATH_MAX, trailing_slash);
     275                if (str_size(subdir_path) +
     276                    str_size(dir_list[i].name) + 1 <= PATH_MAX)
     277                        str_append(subdir_path, PATH_MAX, dir_list[i].name);
     278
     279                scope = ls_scope(subdir_path, &dir_list[i]);
     280                switch (scope) {
     281                case LS_FILE:
     282                        break;
     283                case LS_DIR:
     284                        subdirp = opendir(subdir_path);
     285                        if (!subdirp) {
     286                                /* May have been deleted between scoping it and opening it */
     287                                cli_error(CL_EFAIL, "Could not stat %s", dir_list[i].name);
     288                                ret = CMD_FAILURE;
     289                                goto out;
     290                        }
     291
     292                        ret = ls_recursive(subdir_path, subdirp);
     293                        closedir(subdirp);
     294                        if (ret == CMD_FAILURE)
     295                                goto out;
     296                        break;
     297                case LS_BOGUS:
     298                        ret = CMD_FAILURE;
     299                        goto out;
     300                }       
     301        }
     302   
     303        ret = CMD_SUCCESS;
     304
     305out:
     306        for (i = 0; i < nbdirs; i++)
     307                free(dir_list[i].name);
     308        free(dir_list);
     309        free(subdir_path);
     310
     311        return ret;
     312}
     313
     314static unsigned int ls_scope(const char *path, struct dir_elem_t *de)
     315{
     316        if (stat(path, &de->s)) {
     317                cli_error(CL_ENOENT, path);
     318                return LS_BOGUS;
     319        }
     320
     321        if (de->s.is_file)
     322                return LS_FILE;
     323        else if (de->s.is_directory)
     324                return LS_DIR;
     325
     326        return LS_BOGUS;
    204327}
    205328
     
    215338                "Options:\n"
    216339                "  -h, --help       A short option summary\n"
    217                 "  -u, --unsort     Do not sort directory entries\n",
     340                "  -u, --unsort     Do not sort directory entries\n"
     341                "  -r, --recursive  List subdirectories recursively\n",
    218342                cmdname);
    219343        }
     
    228352        DIR *dirp;
    229353        int c, opt_ind;
    230         int sort = 1;
     354        int ret = 0;
     355        unsigned int scope;
     356
     357        if (!ls_start(&ls)) {
     358                cli_error(CL_EFAIL, "%s: Could not initialize", cmdname);
     359                return CMD_FAILURE;
     360        }
    231361
    232362        argc = cli_count_args(argv);
    233363       
    234364        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    235                 c = getopt_long(argc, argv, "hu", long_options, &opt_ind);
     365                c = getopt_long(argc, argv, "hur", long_options, &opt_ind);
    236366                switch (c) {
    237367                case 'h':
     
    239369                        return CMD_SUCCESS;
    240370                case 'u':
    241                         sort = 0;
     371                        ls.sort = 0;
     372                        break;
     373                case 'r':
     374                        ls.recursive = 1;
    242375                        break;
    243376                }
     
    251384                return CMD_FAILURE;
    252385        }
    253         memset(de.name, 0, sizeof(PATH_MAX));
     386        memset(de.name, 0, PATH_MAX);
    254387       
    255388        if (argc == 0)
     
    257390        else
    258391                str_cpy(de.name, PATH_MAX, argv[optind]);
    259        
    260         if (stat(de.name, &de.s)) {
    261                 cli_error(CL_ENOENT, de.name);
    262                 free(de.name);
    263                 return CMD_FAILURE;
    264         }
    265 
    266         if (de.s.is_file) {
     392
     393        scope = ls_scope(de.name, &de);
     394        switch (scope) {
     395        case LS_FILE:
    267396                ls_print(&de);
    268         } else {
     397                break;
     398        case LS_DIR:
    269399                dirp = opendir(de.name);
    270400                if (!dirp) {
     
    274404                        return CMD_FAILURE;
    275405                }
    276                 ls_scan_dir(de.name, dirp, sort);
     406                if (ls.recursive)
     407                        ret = ls_recursive(de.name, dirp);
     408                else 
     409                        ret = ls_scan_dir(de.name, dirp, NULL);
     410
    277411                closedir(dirp);
     412                break;
     413        case LS_BOGUS:
     414                return CMD_FAILURE;
    278415        }
    279416
    280417        free(de.name);
    281418
    282         return CMD_SUCCESS;
    283 }
    284 
     419        if (ret == -1 || ret == CMD_FAILURE)
     420                return CMD_FAILURE;
     421        else
     422                return CMD_SUCCESS;
     423}
     424
  • uspace/app/bdsh/cmds/modules/touch/entry.h

    r95c9158 r81f70b4  
    77
    88#endif /* TOUCH_ENTRY_H */
    9 
  • uspace/app/bdsh/cmds/modules/touch/touch.c

    r95c9158 r81f70b4  
    2727 */
    2828
    29 /* TODO: Options that people would expect, such as not creating the file if
    30  * it doesn't exist, specifying the access time, etc */
     29/*
     30 * TODO: Options that people would expect, such as specifying the access time,
     31 * etc.
     32 */
    3133
    3234#include <stdio.h>
     
    3739#include <sys/types.h>
    3840#include <str.h>
     41#include <getopt.h>
     42#include <sys/stat.h>
     43#include <errno.h>
    3944
    4045#include "config.h"
     
    4752static const char *cmdname = "touch";
    4853
     54static struct option const long_options[] = {
     55        { "no-create", no_argument, 0, 'c' },
     56        { 0, 0, 0, 0 }
     57};
     58
    4959/* Dispays help for touch in various levels */
    5060void help_cmd_touch(unsigned int level)
    5161{
    5262        if (level == HELP_SHORT) {
    53                 printf("`%s' updates access times for files\n", cmdname);
     63                printf("`%s' updates access times of files\n", cmdname);
    5464        } else {
    5565                help_cmd_touch(HELP_SHORT);
    56                 printf("  `%s' <file>, if the file does not exist it will be "
    57                                 "created\n", cmdname);
     66                printf("Usage: `%s' [-c|--no-create] <file>...\n\n"
     67                    "If the file does not exist it will be created empty,\n"
     68                    "unless -c (--no-create) is supplied.\n\n"
     69                    "Options:\n"
     70                    "   -c, --no-create  Do not create new files\n",
     71                    cmdname);
    5872        }
    59 
     73       
    6074        return;
    6175}
     
    6478int cmd_touch(char **argv)
    6579{
    66         unsigned int argc, i = 0, ret = 0;
    67         int fd;
     80        unsigned int argc = cli_count_args(argv);
     81        unsigned int i = 0;
     82        unsigned int ret = 0;
     83        int c;
     84        int longind;
     85        bool no_create = false;
     86        struct stat file_stat;
     87        int fd = -1;
    6888        char *buff = NULL;
    69 
     89       
    7090        DIR *dirp;
    71 
    72         argc = cli_count_args(argv);
    73 
    74         if (argc == 1) {
    75                 printf("%s - incorrect number of arguments. Try `help %s extended'\n",
    76                         cmdname, cmdname);
     91       
     92        for (c = 0, optind = 0, longind = 0; c != -1; ) {
     93                c = getopt_long(argc, argv, "c", long_options, &longind);
     94                switch (c) {
     95                case 'c':
     96                        no_create = true;
     97                        break;
     98                }
     99        }
     100       
     101        if (argc - optind < 1) {
     102                printf("%s: Incorrect number of arguments. Try `help %s extended'\n",
     103                    cmdname, cmdname);
    77104                return CMD_FAILURE;
    78105        }
    79 
    80         for (i = 1; i < argc; i ++) {
     106       
     107        for (i = optind; argv[i] != NULL; i++) {
    81108                buff = str_dup(argv[i]);
     109                if (buff == NULL) {
     110                        cli_error(CL_ENOMEM, "Out of memory");
     111                        ret++;
     112                        continue;
     113                }
     114               
    82115                dirp = opendir(buff);
    83116                if (dirp) {
    84                         cli_error(CL_ENOTSUP, "%s is a directory", buff);
     117                        cli_error(CL_ENOTSUP, "`%s' is a directory", buff);
    85118                        closedir(dirp);
    86                         ret ++;
     119                        free(buff);
     120                        ret++;
    87121                        continue;
    88122                }
    89 
    90                 fd = open(buff, O_RDWR | O_CREAT);
     123               
     124                /* Check whether file exists if -c (--no-create) option is given */
     125                if ((!no_create) || ((no_create) && (stat(buff, &file_stat) == EOK)))
     126                        fd = open(buff, O_RDWR | O_CREAT);
     127               
    91128                if (fd < 0) {
    92                         cli_error(CL_EFAIL, "Could not update / create %s ", buff);
    93                         ret ++;
     129                        cli_error(CL_EFAIL, "Could not update or create `%s'", buff);
     130                        free(buff);
     131                        ret++;
    94132                        continue;
    95                 } else
     133                } else {
    96134                        close(fd);
    97 
     135                        fd = -1;
     136                }
     137               
    98138                free(buff);
    99139        }
    100 
     140       
    101141        if (ret)
    102142                return CMD_FAILURE;
     
    104144                return CMD_SUCCESS;
    105145}
    106 
  • uspace/app/bdsh/cmds/modules/touch/touch.h

    r95c9158 r81f70b4  
    44/* Prototypes for the touch command, excluding entry points */
    55
    6 
    76#endif /* TOUCH_H */
    8 
  • uspace/app/bdsh/cmds/modules/touch/touch_def.h

    r95c9158 r81f70b4  
    55        &help_cmd_touch,
    66},
    7 
  • uspace/app/getterm/Makefile

    r95c9158 r81f70b4  
    2929
    3030USPACE_PREFIX = ../..
    31 DEFS = -DRELEASE=$(RELEASE) "-DNAME=$(NAME)"
     31DEFS = -DRELEASE=$(RELEASE) "-DCOPYRIGHT=$(COPYRIGHT)" "-DNAME=$(NAME)"
    3232BINARY = getterm
    3333
  • uspace/app/getterm/version.c

    r95c9158 r81f70b4  
    4040#include "version.h"
    4141
     42static const char *copyright = STRING(COPYRIGHT);
    4243static const char *release = STRING(RELEASE);
    4344static const char *name = STRING(NAME);
     
    6162        printf("HelenOS release %s (%s)%s%s\n", release, name, revision, timestamp);
    6263        printf("Running on %s (%s)\n", arch, term);
    63         printf("Copyright (c) 2001-2011 HelenOS project\n\n");
     64        printf("%s\n\n", copyright);
    6465}
    6566
  • uspace/lib/c/generic/str.c

    r95c9158 r81f70b4  
    15351535 *
    15361536 */
    1537 int str_uint64(const char *nptr, char **endptr, unsigned int base,
     1537int str_uint64_t(const char *nptr, char **endptr, unsigned int base,
    15381538    bool strict, uint64_t *result)
    15391539{
  • uspace/lib/c/include/str.h

    r95c9158 r81f70b4  
    106106extern int str_uint16_t(const char *, char **, unsigned int, bool, uint16_t *);
    107107extern int str_uint32_t(const char *, char **, unsigned int, bool, uint32_t *);
    108 extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
     108extern int str_uint64_t(const char *, char **, unsigned int, bool, uint64_t *);
    109109extern int str_size_t(const char *, char **, unsigned int, bool, size_t *);
    110110
  • uspace/lib/usb/src/dev.c

    r95c9158 r81f70b4  
    122122        char *ptr;
    123123
    124         rc = str_uint64(path, &ptr, 10, false, &sid);
     124        rc = str_uint64_t(path, &ptr, 10, false, &sid);
    125125        if (rc != EOK) {
    126126                return false;
  • version

    r95c9158 r81f70b4  
    4646
    4747NAME = Sashimi
     48COPYRIGHT = Copyright (c) 2001-2012 HelenOS project
Note: See TracChangeset for help on using the changeset viewer.