Changes in / [f7e69f5:0a0e6e7] in mainline


Ignore:
Files:
17 deleted
53 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    rf7e69f5 r0a0e6e7  
    573573! CONFIG_BINUTILS (n/y)
    574574
    575 % Build MSIM binary
    576 ! CONFIG_MSIM (n/y)
    577 
    578575% Line debugging information
    579576! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)

  • boot/Makefile.common

    rf7e69f5 r0a0e6e7  
    202202endif
    203203
    204 ifeq ($(CONFIG_MSIM),y)
    205 RD_APPS_NON_ESSENTIAL += \
    206         $(USPACE_PATH)/app/msim/msim
    207 endif
    208 
    209204COMPONENTS = \
    210205        $(KERNEL_PATH)/kernel.bin \

  • tools/checkers/clang.py

    rf7e69f5 r0a0e6e7  
    114114        for job in jobs:
    115115                if (not clang(rootdir, job)):
    116                         print()
     116                        print
    117117                        print("Failed job: %s" % job)
    118118                        return

  • tools/checkers/stanse.py

    rf7e69f5 r0a0e6e7  
    127127        for job in jobs:
    128128                if (not stanse(rootdir, job)):
    129                         print()
     129                        print
    130130                        print("Failed job: %s" % job)
    131131                        return

  • tools/checkers/vcc.py

    rf7e69f5 r0a0e6e7  
    204204        for job in jobs:
    205205                if (not vcc(vcc_path, rootdir, job)):
    206                         print()
     206                        print
    207207                        print("Failed job: %s" % job)
    208208                        return
    209209       
    210         print()
     210        print
    211211        print("All jobs passed")
    212212

  • tools/filldir.py

    rf7e69f5 r0a0e6e7  
    3737
    3838if len(sys.argv) < 3:
    39         print('Usage: filldir <parent-dir> <count>')
     39        print 'Usage: filldir <parent-dir> <count>'
    4040        exit(2)
    4141

  • tools/gentestfile.py

    rf7e69f5 r0a0e6e7  
    3636
    3737if len(sys.argv) < 2:
    38         print("Usage: gentestfile.py <count of 64-bit numbers to output>")
     38        print "Usage: gentestfile.py <count of 64-bit numbers to output>"
    3939        exit()
    4040
    41 m = int(sys.argv[1])
     41m = long(sys.argv[1])
    4242i = 0
    4343pow_2_64 = 2 ** 64

  • tools/mkfat.py

    rf7e69f5 r0a0e6e7  
    189189        "Filter FAT legal characters"
    190190       
    191         filtered_name = b''
     191        filtered_name = ''
    192192        filtered = False
    193193       
    … …  
    205205       
    206206        ascii_name, lfn = fat_lchars(name)
    207         # Splitting works only on strings, not on bytes
    208         ascii_parts = ascii_name.decode('utf8').split('.')
     207        ascii_parts = ascii_name.split('.')
    209208       
    210209        short_name = ''
    … …  
    445444        extra_bytes = int(sys.argv[1])
    446445       
    447         path = os.path.abspath(sys.argv[2])
     446        path = os.path.abspath(sys.argv[2].decode())
    448447        if (not os.path.isdir(path)):
    449448                print("<PATH> must be a directory")

  • tools/mkuimage.py

    rf7e69f5 r0a0e6e7  
    124124        header.img_type = 2             # Kernel
    125125        header.compression = 0          # None
    126         header.img_name = image_name.encode('ascii')
     126        header.img_name = image_name
    127127
    128128        header_crc = calc_crc32(header.pack())
    … …  
    140140        signed_crc = zlib.crc32(byteseq, 0)
    141141        if signed_crc < 0:
    142                 return signed_crc + (1 << 32)
     142                return (long(signed_crc) + (long(2) ** long(32))) # 2^32L
    143143        else:
    144144                return signed_crc
    … …  
    148148def print_syntax(cmd):
    149149        print("syntax: " + cmd + " [<options>] <raw_image> <uImage>")
    150         print()
     150        print
    151151        print("\traw_image\tInput image name (raw binary data)")
    152152        print("\tuImage\t\tOutput uImage name (U-Boot image)")
    153         print()
     153        print
    154154        print("options:")
    155155        print("\t-name <name>\tImage name (default: 'Noname')")

  • tools/xstruct.py

    rf7e69f5 r0a0e6e7  
    3232
    3333import struct
    34 import sys
    3534import types
    3635
    37 # Handle long integer conversions nicely in both Python 2 and Python 3
    38 integer_types = (int, long) if sys.version < '3' else (int,)
    39 
    40 # Ensure that 's' format for struct receives correct data type depending
    41 # on Python version (needed due to different way to encode into bytes)
    42 ensure_string = \
    43         (lambda value: value if type(value) is str else bytes(value)) \
    44                 if sys.version < '3' else \
    45         (lambda value: bytes(value, 'ascii') if type(value) is str else value)
    46 
    4736ranges = {
    48         'B': (integer_types, 0x00, 0xff),
    49         'H': (integer_types, 0x0000, 0xffff),
    50         'L': (integer_types, 0x00000000, 0xffffffff),
    51         'Q': (integer_types, 0x0000000000000000, 0xffffffffffffffff),
    52         'b': (integer_types, -0x80, 0x7f),
    53         'h': (integer_types, -0x8000, 0x7fff),
    54         'l': (integer_types, -0x80000000, 0x7fffffff) ,
    55         'q': (integer_types, -0x8000000000000000, 0x7fffffffffffffff),
     37        'B': ((int, long), 0x00, 0xff),
     38        'H': ((int, long), 0x0000, 0xffff),
     39        'L': ((int, long), 0x00000000, 0xffffffff),
     40        'Q': ((int, long), 0x0000000000000000, 0xffffffffffffffff),
     41        'b': ((int, long), -0x80, 0x7f),
     42        'h': ((int, long), -0x8000, 0x7fff),
     43        'l': ((int, long), -0x80000000, 0x7fffffff) ,
     44        'q': ((int, long), -0x8000000000000000, 0x7fffffffffffffff),
    5645}
    5746
    … …  
    8574                                        args.append(item)
    8675                        else:
    87                                 if (fmt == "s"):
    88                                         value = ensure_string(value)
    8976                                check_range(variable, fmt, value)
    9077                                args.append(value)             

  • uspace/Makefile

    rf7e69f5 r0a0e6e7  
    139139endif
    140140
    141 ifeq ($(CONFIG_MSIM),y)
    142 DIRS += \
    143         app/msim
    144 endif
    145 
    146141## Platform-specific hardware support
    147142#

  • uspace/app/bdsh/Makefile

    rf7e69f5 r0a0e6e7  
    4848        cmds/modules/cp/cp.c \
    4949        cmds/modules/mv/mv.c \
    50         cmds/modules/printf/printf.c \
    51         cmds/modules/echo/echo.c \
    5250        cmds/modules/mount/mount.c \
    5351        cmds/modules/unmount/unmount.c \

  • uspace/app/bdsh/TODO

    rf7e69f5 r0a0e6e7  
    3030* Add wrappers for signal, sigaction to make ports to modules easier
    3131
     32* Add 'echo' and 'printf' modules.
     33
    3234Regarding POSIX:
    3335----------------

  • uspace/app/bdsh/cmds/builtins/cd/cd.c

    rf7e69f5 r0a0e6e7  
    4141static const char *cmdname = "cd";
    4242
    43 /* Previous directory variables.
    44  *
    45  * Declaring them static to avoid many "== NULL" checks.
    46  * PATH_MAX is not that big to cause any problems with memory overhead.
    47  */
    48 static char previous_directory[PATH_MAX] = "";
    49 static char previous_directory_tmp[PATH_MAX];
    50 static bool previous_directory_valid = true;
    51 static bool previous_directory_set = false;
    52 
    53 static int chdir_and_remember(const char *new_dir) {
    54 
    55         char *ok = getcwd(previous_directory_tmp, PATH_MAX);
    56         previous_directory_valid = ok != NULL;
    57         previous_directory_set = true;
    58 
    59         int rc = chdir(new_dir);
    60         if (rc != EOK) {
    61                 return rc;
    62         }
    63 
    64         str_cpy(previous_directory, PATH_MAX, previous_directory_tmp);
    65         return EOK;
    66 }
    67 
    6843void help_cmd_cd(unsigned int level)
    6944{
    … …  
    8055}
    8156
    82 
    8357/* This is a very rudamentary 'cd' command. It is not 'link smart' (yet) */
    8458
    … …  
    8862
    8963        argc = cli_count_args(argv);
    90 
    91         /* Handle cd -- -. Override to switch to a directory named '-' */
    92         bool hyphen_override = false;
    93         char *target_directory = argv[1];
    94         if (argc == 3) {
    95                 if (!str_cmp(argv[1], "--")) {
    96                         hyphen_override = true;
    97                         argc--;
    98                         target_directory = argv[2];
    99                 }
    100         }
    10164
    10265        /* We don't yet play nice with whitespace, a getopt implementation should
    … …  
    11679        }
    11780
    118         /* We have the correct # of arguments */
    119         // TODO: handle tidle (~) expansion? */
     81        /* We have the correct # of arguments
     82     * TODO: handle tidle (~) expansion? */
    12083
    121         /* Handle 'cd -' first. */
    122         if (!str_cmp(target_directory, "-") && !hyphen_override) {
    123                 if (!previous_directory_valid) {
    124                         cli_error(CL_EFAIL, "Cannot switch to previous directory");
    125                         return CMD_FAILURE;
    126                 }
    127                 if (!previous_directory_set) {
    128                         cli_error(CL_EFAIL, "No previous directory to switch to");
    129                         return CMD_FAILURE;
    130                 }
    131                 char *prev_dup = str_dup(previous_directory);
    132                 if (prev_dup == NULL) {
    133                         cli_error(CL_ENOMEM, "Cannot switch to previous directory");
    134                         return CMD_FAILURE;
    135                 }
    136                 rc = chdir_and_remember(prev_dup);
    137                 free(prev_dup);
    138         } else {
    139                 rc = chdir_and_remember(target_directory);
    140         }
     84        rc = chdir(argv[1]);
    14185
    14286        if (rc == 0) {
    … …  
    14993                        break;
    15094                case ENOENT:
    151                         cli_error(CL_ENOENT, "Invalid directory `%s'", target_directory);
     95                        cli_error(CL_ENOENT, "Invalid directory `%s'", argv[1]);
    15296                        break;
    15397                default:
    154                         cli_error(CL_EFAIL, "Unable to change to `%s'", target_directory);
     98                        cli_error(CL_EFAIL, "Unable to change to `%s'", argv[1]);
    15599                        break;
    156100                }

  • uspace/app/bdsh/cmds/modules/cat/cat.h

    rf7e69f5 r0a0e6e7  
    44/* Prototypes for the cat command, excluding entry points */
    55
     6static unsigned int cat_file(const char *, size_t, bool, off64_t, off64_t, bool);
     7
    68#endif /* CAT_H */
    79

  • uspace/app/bdsh/cmds/modules/cp/cp.c

    rf7e69f5 r0a0e6e7  
    3030#include <stdlib.h>
    3131#include <unistd.h>
    32 #include <io/console.h>
    33 #include <io/keycode.h>
    3432#include <getopt.h>
    3533#include <str.h>
    … …  
    4846
    4947static const char *cmdname = "cp";
    50 static console_ctrl_t *con;
    5148
    5249static struct option const long_options[] = {
    5350        { "buffer", required_argument, 0, 'b' },
    5451        { "force", no_argument, 0, 'f' },
    55         { "interactive", no_argument, 0, 'i'},
    5652        { "recursive", no_argument, 0, 'r' },
    5753        { "help", no_argument, 0, 'h' },
    … …  
    143139}
    144140
    145 static bool get_user_decision(bool bdefault, const char *message, ...)
    146 {
    147         va_list args;
    148 
    149         va_start(args, message);
    150         vprintf(message, args);
    151         va_end(args);
    152 
    153         while (true) {
    154                 kbd_event_t ev;
    155                 console_flush(con);
    156                 console_get_kbd_event(con, &ev);
    157                 if ((ev.type != KEY_PRESS)
    158                     || (ev.mods & (KM_CTRL | KM_ALT)) != 0) {
    159                         continue;
    160                 }
    161 
    162                 switch(ev.key) {
    163                 case KC_Y:
    164                         printf("y\n");
    165                         return true;
    166                 case KC_N:
    167                         printf("n\n");
    168                         return false;
    169                 case KC_ENTER:
    170                         printf("%c\n", bdefault ? 'Y' : 'N');
    171                         return bdefault;
    172                 default:
    173                         break;
    174                 }
    175         }
    176 }
    177 
    178141static int64_t do_copy(const char *src, const char *dest,
    179     size_t blen, int vb, int recursive, int force, int interactive)
     142    size_t blen, int vb, int recursive, int force)
    180143{
    181144        int r = -1;
    … …  
    229192                        /* e.g. cp file_name existing_file */
    230193
    231                         /* dest already exists,
    232                          * if force is set we will try to remove it.
    233                          * if interactive is set user input is required.
     194                        /* dest already exists, if force is set we will
     195                         * try to remove it.
    234196                         */
    235                         if (force && !interactive) {
     197                        if (force) {
    236198                                if (unlink(dest_path)) {
    237199                                        printf("Unable to remove %s\n",
    … …  
    239201                                        goto exit;
    240202                                }
    241                         } else if (!force && interactive) {
    242                                 bool overwrite = get_user_decision(false,
    243                                     "File already exists: %s. Overwrite? [y/N]: ",
    244                                     dest_path);
    245                                 if (overwrite) {
    246                                         printf("Overwriting file: %s\n", dest_path);
    247                                         if (unlink(dest_path)) {
    248                                                 printf("Unable to remove %s\n", dest_path);
    249                                                 goto exit;
    250                                         }
    251                                 } else {
    252                                         printf("Not overwriting file: %s\n", dest_path);
    253                                         r = 0;
    254                                         goto exit;
    255                                 }
    256203                        } else {
    257                                 printf("File already exists: %s\n", dest_path);
     204                                printf("file already exists: %s\n", dest_path);
    258205                                goto exit;
    259206                        }
    … …  
    355302                        /* Recursively call do_copy() */
    356303                        r = do_copy(src_dent, dest_dent, blen, vb, recursive,
    357                             force, interactive);
     304                            force);
    358305                        if (r)
    359306                                goto exit;
    … …  
    368315        return r;
    369316}
     317
    370318
    371319static int64_t copy_file(const char *src, const char *dest,
    … …  
    432380            "  -v, --version    Print version information and exit\n"
    433381            "  -V, --verbose    Be annoyingly noisy about what's being done\n"
    434             "  -f, --force      Do not complain when <dest> exists (overrides a previous -i)\n"
    435             "  -i, --interactive Ask what to do when <dest> exists (overrides a previous -f)\n"
     382            "  -f, --force      Do not complain when <dest> exists\n"
    436383            "  -r, --recursive  Copy entire directories\n"
    437384            "  -b, --buffer ## Set the read buffer size to ##\n";
    … …  
    450397        unsigned int argc, verbose = 0;
    451398        int buffer = 0, recursive = 0;
    452         int force = 0, interactive = 0;
     399        int force = 0;
    453400        int c, opt_ind;
    454401        int64_t ret;
    455402
    456         con = console_init(stdin, stdout);
    457403        argc = cli_count_args(argv);
    458404
    459405        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    460                 c = getopt_long(argc, argv, "hvVfirb:", long_options, &opt_ind);
     406                c = getopt_long(argc, argv, "hvVfrb:", long_options, &opt_ind);
    461407                switch (c) {
    462408                case 'h':
    … …  
    470416                        break;
    471417                case 'f':
    472                         interactive = 0;
    473418                        force = 1;
    474                         break;
    475                 case 'i':
    476                         force = 0;
    477                         interactive = 1;
    478419                        break;
    479420                case 'r':
    … …  
    485426                                    "(should be a number greater than zero)\n",
    486427                                    cmdname);
    487                                 console_done(con);
    488428                                return CMD_FAILURE;
    489429                        }
    … …  
    502442                printf("%s: invalid number of arguments. Try %s --help\n",
    503443                    cmdname, cmdname);
    504                 console_done(con);
    505444                return CMD_FAILURE;
    506445        }
    507446
    508447        ret = do_copy(argv[optind], argv[optind + 1], buffer, verbose,
    509             recursive, force, interactive);
    510 
    511         console_done(con);
     448            recursive, force);
    512449
    513450        if (ret == 0)

  • uspace/app/bdsh/cmds/modules/help/help.h

    rf7e69f5 r0a0e6e7  
    33
    44/* Prototypes for the help command (excluding entry points) */
     5static int is_mod_or_builtin(char *);
    56
    67#endif

  • uspace/app/bdsh/cmds/modules/mkdir/mkdir.c

    rf7e69f5 r0a0e6e7  
    3636#include <stdarg.h>
    3737#include <str.h>
    38 #include <errno.h>
    39 #include <str_error.h>
    40 #include <vfs/vfs.h>
    4138
    4239#include "config.h"
    … …  
    8683/* This is kind of clunky, but effective for now */
    8784static unsigned int
    88 create_directory(const char *user_path, bool create_parents)
     85create_directory(const char *path, unsigned int p)
    8986{
    90         /* Ensure we would always work with absolute and canonified path. */
    91         char *path = absolutize(user_path, NULL);
    92         if (path == NULL) {
     87        DIR *dirp;
     88        char *tmp = NULL, *buff = NULL, *wdp = NULL;
     89        char *dirs[255];
     90        unsigned int absolute = 0, i = 0, ret = 0;
     91
     92        /* Its a good idea to allocate path, plus we (may) need a copy of
     93         * path to tokenize if parents are specified */
     94        if (NULL == (tmp = str_dup(path))) {
    9395                cli_error(CL_ENOMEM, "%s: path too big?", cmdname);
    9496                return 1;
    9597        }
    9698
    97         int rc;
    98         int ret = 0;
    99 
    100         if (!create_parents) {
    101                 rc = mkdir(path, 0);
    102                 if (rc != EOK) {
    103                         cli_error(CL_EFAIL, "%s: could not create %s (%s)",
    104                             cmdname, path, str_error(rc));
    105                         ret = 1;
    106                 }
     99        if (NULL == (wdp = (char *) malloc(PATH_MAX))) {
     100                cli_error(CL_ENOMEM, "%s: could not alloc cwd", cmdname);
     101                free(tmp);
     102                return 1;
     103        }
     104
     105        /* The only reason for wdp is to be (optionally) verbose */
     106        getcwd(wdp, PATH_MAX);
     107
     108        /* Typical use without specifying the creation of parents */
     109        if (p == 0) {
     110                dirp = opendir(tmp);
     111                if (dirp) {
     112                        cli_error(CL_EEXISTS, "%s: can not create %s, try -p", cmdname, path);
     113                        closedir(dirp);
     114                        goto finit;
     115                }
     116                if (-1 == (mkdir(tmp, 0))) {
     117                        cli_error(CL_EFAIL, "%s: could not create %s", cmdname, path);
     118                        goto finit;
     119                }
     120        }
     121
     122        /* Parents need to be created, path has to be broken up */
     123
     124        /* See if path[0] is a slash, if so we have to remember to append it */
     125        if (tmp[0] == '/')
     126                absolute = 1;
     127
     128        /* TODO: Canonify the path prior to tokenizing it, see below */
     129        dirs[i] = strtok(tmp, "/");
     130        while (dirs[i] && i < 255)
     131                dirs[++i] = strtok(NULL, "/");
     132
     133        if (NULL == dirs[0])
     134                return 1;
     135
     136        if (absolute == 1) {
     137                asprintf(&buff, "/%s", dirs[0]);
     138                mkdir(buff, 0);
     139                chdir(buff);
     140                free(buff);
     141                getcwd(wdp, PATH_MAX);
     142                i = 1;
    107143        } else {
    108                 /* Create the parent directories as well. */
    109                 size_t off = 0;
    110                 while (1) {
    111                         size_t prev_off = off;
    112                         wchar_t cur_char = str_decode(path, &off, STR_NO_LIMIT);
    113                         if ((cur_char == 0) || (cur_char == U_SPECIAL)) {
     144                i = 0;
     145        }
     146
     147        while (dirs[i] != NULL) {
     148                /* Sometimes make or scripts conjoin odd paths. Account for something
     149                 * like this: ../../foo/bar/../foo/foofoo/./bar */
     150                if (!str_cmp(dirs[i], "..") || !str_cmp(dirs[i], ".")) {
     151                        if (0 != (chdir(dirs[i]))) {
     152                                cli_error(CL_EFAIL, "%s: impossible path: %s",
     153                                        cmdname, path);
     154                                ret ++;
     155                                goto finit;
     156                        }
     157                        getcwd(wdp, PATH_MAX);
     158                } else {
     159                        if (-1 == (mkdir(dirs[i], 0))) {
     160                                cli_error(CL_EFAIL,
     161                                        "%s: failed at %s/%s", wdp, dirs[i]);
     162                                ret ++;
     163                                goto finit;
     164                        }
     165                        if (0 != (chdir(dirs[i]))) {
     166                                cli_error(CL_EFAIL, "%s: failed creating %s\n",
     167                                        cmdname, dirs[i]);
     168                                ret ++;
    114169                                break;
    115170                        }
    116                         if (cur_char != '/') {
    117                                 continue;
    118                         }
    119                         if (prev_off == 0) {
    120                                 continue;
    121                         }
    122                         /*
    123                          * If we are here, it means that:
    124                          * - we found /
    125                          * - it is not the first / (no need to create root
    126                          *   directory)
    127                          *
    128                          * We would now overwrite the / with 0 to terminate the
    129                          * string (that shall be okay because we are
    130                          * overwriting at the beginning of UTF sequence).
    131                          * That would allow us to create the directories
    132                          * in correct nesting order.
    133                          *
    134                          * Notice that we ignore EEXIST errors as some of
    135                          * the parent directories may already exist.
    136                          */
    137                         char slash_char = path[prev_off];
    138                         path[prev_off] = 0;
    139                         rc = mkdir(path, 0);
    140                         if (rc == EEXIST) {
    141                                 rc = EOK;
    142                         }
    143 
    144                         if (rc != EOK) {
    145                                 cli_error(CL_EFAIL, "%s: could not create %s (%s)",
    146                                     cmdname, path, str_error(rc));
    147                                 ret = 1;
    148                                 goto leave;
    149                         }
    150 
    151                         path[prev_off] = slash_char;
    152                 }
    153                 /* Create the final directory. */
    154                 rc = mkdir(path, 0);
    155                 if (rc != EOK) {
    156                         cli_error(CL_EFAIL, "%s: could not create %s (%s)",
    157                             cmdname, path, str_error(rc));
    158                         ret = 1;
    159                 }
    160         }
    161 
    162 leave:
    163         free(path);
     171                }
     172                i++;
     173        }
     174        goto finit;
     175
     176finit:
     177        free(wdp);
     178        free(tmp);
    164179        return ret;
    165180}
    … …  
    167182int cmd_mkdir(char **argv)
    168183{
    169         unsigned int argc, i, ret = 0;
    170         bool create_parents = false, follow = false, verbose = false;
     184        unsigned int argc, create_parents = 0, i, ret = 0, follow = 0;
     185        unsigned int verbose = 0;
    171186        int c, opt_ind;
     187        char *cwd;
    172188
    173189        argc = cli_count_args(argv);
    … …  
    177193                switch (c) {
    178194                case 'p':
    179                         create_parents = true;
     195                        create_parents = 1;
    180196                        break;
    181197                case 'v':
    182                         verbose = true;
     198                        verbose = 1;
    183199                        break;
    184200                case 'h':
    … …  
    189205                        return CMD_SUCCESS;
    190206                case 'f':
    191                         follow = true;
     207                        follow = 1;
    192208                        break;
    193209                case 'm':
    … …  
    205221        }
    206222
     223        if (NULL == (cwd = (char *) malloc(PATH_MAX))) {
     224                cli_error(CL_ENOMEM, "%s: could not allocate cwd", cmdname);
     225                return CMD_FAILURE;
     226        }
     227
     228        memset(cwd, 0, sizeof(cwd));
     229        getcwd(cwd, PATH_MAX);
     230
    207231        for (i = optind; argv[i] != NULL; i++) {
    208                 if (verbose)
     232                if (verbose == 1)
    209233                        printf("%s: creating %s%s\n",
    210234                                cmdname, argv[i],
    … …  
    213237        }
    214238
    215         if (follow && (argv[optind] != NULL)) {
    216                 chdir(argv[optind]);
    217         }
     239        if (follow == 0)
     240                chdir(cwd);
     241
     242        free(cwd);
    218243
    219244        if (ret)

  • uspace/app/bdsh/cmds/modules/mkdir/mkdir.h

    rf7e69f5 r0a0e6e7  
    44/* Prototypes for the mkdir command, excluding entry points */
    55
     6static unsigned int create_directory(const char *, unsigned int);
    67#endif /* MKDIR_H */
    78

  • uspace/app/bdsh/cmds/modules/modules.h

    rf7e69f5 r0a0e6e7  
    6161#include "unmount/entry.h"
    6262#include "kcon/entry.h"
    63 #include "printf/entry.h"
    64 #include "echo/entry.h"
    6563
    6664/* Each .def function fills the module_t struct with the individual name, entry
    … …  
    8482#include "unmount/unmount_def.h"
    8583#include "kcon/kcon_def.h"
    86 #include "printf/printf_def.h"
    87 #include "echo/echo_def.h"
    8884
    8985        {NULL, NULL, NULL, NULL}

  • uspace/app/bdsh/cmds/modules/rm/rm.c

    rf7e69f5 r0a0e6e7  
    4646#define RM_VERSION "0.0.1"
    4747
     48static rm_job_t rm;
     49
    4850static struct option const long_options[] = {
    4951        { "help", no_argument, 0, 'h' },
    … …  
    5557};
    5658
    57 /* Return values for rm_scope() */
    58 #define RM_BOGUS 0
    59 #define RM_FILE  1
    60 #define RM_DIR   2
    61 
    62 /* Flags for rm_update() */
    63 #define _RM_ENTRY   0
    64 #define _RM_ADVANCE 1
    65 #define _RM_REWIND  2
    66 #define _RM_EXIT    3
    67 
    68 /* A simple job structure */
    69 typedef struct {
    70         /* Options set at run time */
    71         unsigned int force;      /* -f option */
    72         unsigned int recursive;  /* -r option */
    73         unsigned int safe;       /* -s option */
    74 
    75         /* Keeps track of the job in progress */
    76         int advance; /* How far deep we've gone since entering */
    77         DIR *entry;  /* Entry point to the tree being removed */
    78         char *owd;   /* Where we were when we invoked rm */
    79         char *cwd;   /* Current directory being transversed */
    80         char *nwd;   /* Next directory to be transversed */
    81 
    82         /* Counters */
    83         int f_removed; /* Number of files unlinked */
    84         int d_removed; /* Number of directories unlinked */
    85 } rm_job_t;
    86 
    87 static rm_job_t rm;
    88 
    89 static unsigned int rm_recursive(const char *);
    90 
    9159static unsigned int rm_start(rm_job_t *rm)
    9260{
    … …  
    12795        if (NULL != rm->cwd)
    12896                free(rm->cwd);
    129 }
    130 
    131 static unsigned int rm_single(const char *path)
    132 {
    133         if (unlink(path)) {
    134                 cli_error(CL_EFAIL, "rm: could not remove file %s", path);
    135                 return 1;
    136         }
    137         return 0;
    138 }
    139 
    140 static unsigned int rm_scope(const char *path)
    141 {
    142         int fd;
    143         DIR *dirp;
    144 
    145         dirp = opendir(path);
    146         if (dirp) {
    147                 closedir(dirp);
    148                 return RM_DIR;
    149         }
    150 
    151         fd = open(path, O_RDONLY);
    152         if (fd > 0) {
    153                 close(fd);
    154                 return RM_FILE;
    155         }
    156 
    157         return RM_BOGUS;
    15897}
    15998
    … …  
    215154
    216155        return ret + 1;
     156}
     157
     158static unsigned int rm_single(const char *path)
     159{
     160        if (unlink(path)) {
     161                cli_error(CL_EFAIL, "rm: could not remove file %s", path);
     162                return 1;
     163        }
     164        return 0;
     165}
     166
     167static unsigned int rm_scope(const char *path)
     168{
     169        int fd;
     170        DIR *dirp;
     171
     172        dirp = opendir(path);
     173        if (dirp) {
     174                closedir(dirp);
     175                return RM_DIR;
     176        }
     177
     178        fd = open(path, O_RDONLY);
     179        if (fd > 0) {
     180                close(fd);
     181                return RM_FILE;
     182        }
     183
     184        return RM_BOGUS;
    217185}
    218186

  • uspace/app/bdsh/cmds/modules/rm/rm.h

    rf7e69f5 r0a0e6e7  
    22#define RM_H
    33
     4/* Return values for rm_scope() */
     5#define RM_BOGUS 0
     6#define RM_FILE  1
     7#define RM_DIR   2
     8
     9/* Flags for rm_update() */
     10#define _RM_ENTRY   0
     11#define _RM_ADVANCE 1
     12#define _RM_REWIND  2
     13#define _RM_EXIT    3
     14
     15/* A simple job structure */
     16typedef struct {
     17        /* Options set at run time */
     18        unsigned int force;      /* -f option */
     19        unsigned int recursive;  /* -r option */
     20        unsigned int safe;       /* -s option */
     21
     22        /* Keeps track of the job in progress */
     23        int advance; /* How far deep we've gone since entering */
     24        DIR *entry;  /* Entry point to the tree being removed */
     25        char *owd;   /* Where we were when we invoked rm */
     26        char *cwd;   /* Current directory being transversed */
     27        char *nwd;   /* Next directory to be transversed */
     28
     29        /* Counters */
     30        int f_removed; /* Number of files unlinked */
     31        int d_removed; /* Number of directories unlinked */
     32} rm_job_t;
     33
     34
    435/* Prototypes for the rm command, excluding entry points */
     36static unsigned int rm_start(rm_job_t *);
     37static void rm_end(rm_job_t *rm);
     38static unsigned int rm_recursive(const char *);
     39static unsigned int rm_single(const char *);
     40static unsigned int rm_scope(const char *);
    541
    642#endif /* RM_H */

  • uspace/app/bdsh/cmds/modules/sleep/sleep.c

    rf7e69f5 r0a0e6e7  
    2727 */
    2828
    29 #include <errno.h>
    3029#include <stdio.h>
    3130#include <stdlib.h>
    32 #include <unistd.h>
    3331#include "config.h"
    3432#include "util.h"
    … …  
    4341void help_cmd_sleep(unsigned int level)
    4442{
    45         if (level == HELP_SHORT) {
    46                 printf("`%s' pauses for a given time interval\n", cmdname);
    47         } else {
    48                 help_cmd_sleep(HELP_SHORT);
    49                 printf(
    50                     "Usage:  %s <duration>\n"
    51                     "The duration is a decimal number of seconds.\n",
    52                     cmdname);
    53         }
    54 
     43        printf("This is the %s help for '%s'.\n",
     44                level ? EXT_HELP : SHORT_HELP, cmdname);
    5545        return;
    56 }
    57 
    58 /** Convert string containing decimal seconds to useconds_t.
    59  *
    60  * @param nptr   Pointer to string.
    61  * @param result Result of the conversion.
    62  * @return EOK if conversion was successful.
    63  */
    64 static int decimal_to_useconds(const char *nptr, useconds_t *result)
    65 {
    66         int ret;
    67         uint64_t whole_seconds;
    68         uint64_t frac_seconds;
    69         char *endptr;
    70 
    71         /* Check for whole seconds */
    72         if (*nptr == '.') {
    73                 whole_seconds = 0;
    74                 endptr = (char *)nptr;
    75         } else {
    76                 ret = str_uint64_t(nptr, &endptr, 10, false, &whole_seconds);
    77                 if (ret != EOK)
    78                         return ret;
    79         }
    80 
    81         /* Check for fractional seconds */
    82         if (*endptr == '\0') {
    83                 frac_seconds = 0;
    84         } else if (*endptr == '.' && endptr[1] == '\0') {
    85                 frac_seconds = 0;
    86         } else if (*endptr == '.') {
    87                 nptr = endptr + 1;
    88                 ret = str_uint64_t(nptr, &endptr, 10, true, &frac_seconds);
    89                 if (ret != EOK)
    90                         return ret;
    91 
    92                 int ndigits = endptr - nptr;
    93                 for (; ndigits < 6; ndigits++)
    94                         frac_seconds *= 10;
    95                 for (; ndigits > 6; ndigits--)
    96                         frac_seconds /= 10;
    97         } else {
    98                 return EINVAL;
    99         }
    100 
    101         /* Check for overflow */
    102         useconds_t total = whole_seconds * 1000000 + frac_seconds;
    103         if (total / 1000000 != whole_seconds)
    104                 return EOVERFLOW;
    105 
    106         *result = total;
    107 
    108         return EOK;
    10946}
    11047
    … …  
    11249int cmd_sleep(char **argv)
    11350{
    114         int ret;
    11551        unsigned int argc;
    116         useconds_t duration;
     52        unsigned int i;
    11753
    11854        /* Count the arguments */
    119         argc = cli_count_args(argv);
     55        for (argc = 0; argv[argc] != NULL; argc ++);
    12056
    121         if (argc != 2) {
    122                 printf("%s - incorrect number of arguments. Try `help %s'\n",
    123                     cmdname, cmdname);
    124                 return CMD_FAILURE;
     57        printf("%s %s\n", TEST_ANNOUNCE, cmdname);
     58        printf("%d arguments passed to %s", argc - 1, cmdname);
     59
     60        if (argc < 2) {
     61                printf("\n");
     62                return CMD_SUCCESS;
    12563        }
    12664
    127         ret = decimal_to_useconds(argv[1], &duration);
    128         if (ret != EOK) {
    129                 printf("%s - invalid duration.\n", cmdname);
    130                 return CMD_FAILURE;
    131         }
    132 
    133         (void) usleep(duration);
     65        printf(":\n");
     66        for (i = 1; i < argc; i++)
     67                printf("[%d] -> %s\n", i, argv[i]);
    13468
    13569        return CMD_SUCCESS;

  • uspace/app/edit/edit.c

    rf7e69f5 r0a0e6e7  
    118118static void key_handle_ctrl(kbd_event_t const *ev);
    119119static void key_handle_shift(kbd_event_t const *ev);
    120 static void key_handle_shift_ctrl(kbd_event_t const *ev);
    121120static void key_handle_movement(unsigned int key, bool shift);
    122121
    … …  
    140139static void caret_update(void);
    141140static void caret_move(int drow, int dcolumn, enum dir_spec align_dir);
    142 static void caret_move_word_left(void);
    143 static void caret_move_word_right(void);
    144141
    145142static bool selection_active(void);
    146143static void selection_sel_all(void);
    147 static void selection_sel_range(spt_t pa, spt_t pb);
    148 static void selection_sel_prev_word(void);
    149 static void selection_sel_next_word(void);
    150144static void selection_get_points(spt_t *pa, spt_t *pb);
    151145static void selection_delete(void);
    … …  
    155149static void pt_get_sof(spt_t *pt);
    156150static void pt_get_eof(spt_t *pt);
    157 static void pt_get_sol(spt_t *cpt, spt_t *spt);
    158 static void pt_get_eol(spt_t *cpt, spt_t *ept);
    159 static bool pt_is_word_beginning(spt_t *pt);
    160 static bool pt_is_delimiter(spt_t *pt);
    161 static bool pt_is_punctuation(spt_t *pt);
    162151static int tag_cmp(tag_t const *a, tag_t const *b);
    163152static int spt_cmp(spt_t const *a, spt_t const *b);
    … …  
    243232                             (ev.mods & KM_SHIFT) != 0) {
    244233                                key_handle_shift(&ev);
    245                         } else if (((ev.mods & KM_ALT) == 0) &&
    246                             ((ev.mods & KM_CTRL) != 0) &&
    247                              (ev.mods & KM_SHIFT) != 0) {
    248                                 key_handle_shift_ctrl(&ev);
    249234                        } else if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
    250235                                key_handle_unmod(&ev);
    … …  
    391376        case KC_A:
    392377                selection_sel_all();
    393                 break;
    394         case KC_W:
    395                 if (selection_active())
    396                         break;
    397                 selection_sel_prev_word();
    398                 selection_delete();
    399                 break;
    400         case KC_RIGHT:
    401                 caret_move_word_right();
    402                 break;
    403         case KC_LEFT:
    404                 caret_move_word_left();
    405                 break;
    406         default:
    407                 break;
    408         }
    409 }
    410 
    411 static void key_handle_shift_ctrl(kbd_event_t const *ev)
    412 {
    413         switch(ev->key) {
    414         case KC_LEFT:
    415                 selection_sel_prev_word();
    416                 break;
    417         case KC_RIGHT:
    418                 selection_sel_next_word();
    419378                break;
    420379        default:
    … …  
    1011970        /* Clamp coordinates. */
    1012971        if (drow < 0 && coord.row < 1) coord.row = 1;
    1013         if (dcolumn < 0 && coord.column < 1) {
    1014                 if (coord.row < 2)
    1015                         coord.column = 1;
    1016                 else {
    1017                         coord.row--;
    1018                         sheet_get_row_width(&doc.sh, coord.row, &coord.column);
    1019                 }
    1020         }
     972        if (dcolumn < 0 && coord.column < 1) coord.column = 1;
    1021973        if (drow > 0) {
    1022974                sheet_get_num_rows(&doc.sh, &num_rows);
    … …  
    1046998}
    1047999
    1048 static void caret_move_word_left(void)
    1049 {
    1050         spt_t pt;
    1051 
    1052         do {
    1053                 caret_move(0, -1, dir_before);
    1054 
    1055                 tag_get_pt(&pane.caret_pos, &pt);
    1056 
    1057                 sheet_remove_tag(&doc.sh, &pane.sel_start);
    1058                 sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
    1059         } while (!pt_is_word_beginning(&pt));
    1060 
    1061         pane.rflags |= REDRAW_TEXT;
    1062 }
    1063 
    1064 static void caret_move_word_right(void)
    1065 {
    1066         spt_t pt;
    1067 
    1068         do {
    1069                 caret_move(0, 0, dir_after);
    1070 
    1071                 tag_get_pt(&pane.caret_pos, &pt);
    1072 
    1073                 sheet_remove_tag(&doc.sh, &pane.sel_start);
    1074                 sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
    1075         } while (!pt_is_word_beginning(&pt));
    1076 
    1077         pane.rflags |= REDRAW_TEXT;
    1078 }
    1079 
    10801000/** Check for non-empty selection. */
    10811001static bool selection_active(void)
    … …  
    11251045}
    11261046
    1127 /** Select all text in the editor */
    11281047static void selection_sel_all(void)
    11291048{
    … …  
    11321051        pt_get_sof(&spt);
    11331052        pt_get_eof(&ept);
    1134 
    1135         selection_sel_range(spt, ept);
    1136 }
    1137 
    1138 /** Select select all text in a given range with the given direction */
    1139 static void selection_sel_range(spt_t pa, spt_t pb)
    1140 {
    11411053        sheet_remove_tag(&doc.sh, &pane.sel_start);
    1142         sheet_place_tag(&doc.sh, &pa, &pane.sel_start);
     1054        sheet_place_tag(&doc.sh, &spt, &pane.sel_start);
    11431055        sheet_remove_tag(&doc.sh, &pane.caret_pos);
    1144         sheet_place_tag(&doc.sh, &pb, &pane.caret_pos);
     1056        sheet_place_tag(&doc.sh, &ept, &pane.caret_pos);
    11451057
    11461058        pane.rflags |= REDRAW_TEXT;
    11471059        caret_update();
    1148 }
    1149 
    1150 /** Add the previous word to the selection */
    1151 static void selection_sel_prev_word(void)
    1152 {
    1153         spt_t cpt, wpt, spt, ept;
    1154 
    1155         selection_get_points(&spt, &ept);
    1156 
    1157         tag_get_pt(&pane.caret_pos, &cpt);
    1158         caret_move_word_left();
    1159         tag_get_pt(&pane.caret_pos, &wpt);
    1160 
    1161         if (spt_cmp(&spt, &cpt) == 0)
    1162                 selection_sel_range(ept, wpt);
    1163         else
    1164                 selection_sel_range(spt, wpt);
    1165 }
    1166 
    1167 /** Add the next word to the selection */
    1168 static void selection_sel_next_word(void)
    1169 {
    1170         spt_t cpt, wpt, spt, ept;
    1171 
    1172         selection_get_points(&spt, &ept);
    1173 
    1174         tag_get_pt(&pane.caret_pos, &cpt);
    1175         caret_move_word_right();
    1176         tag_get_pt(&pane.caret_pos, &wpt);
    1177 
    1178         if (spt_cmp(&ept, &cpt) == 0)
    1179                 selection_sel_range(spt, wpt);
    1180         else
    1181                 selection_sel_range(ept, wpt);
    11821060}
    11831061
    … …  
    12391117
    12401118        sheet_get_cell_pt(&doc.sh, &coord, dir_after, pt);
    1241 }
    1242 
    1243 /** Get start-of-line s-point for given s-point cpt */
    1244 static void pt_get_sol(spt_t *cpt, spt_t *spt)
    1245 {
    1246         coord_t coord;
    1247 
    1248         spt_get_coord(cpt, &coord);
    1249         coord.column = 1;
    1250 
    1251         sheet_get_cell_pt(&doc.sh, &coord, dir_before, spt);
    1252 }
    1253 
    1254 /** Get end-of-line s-point for given s-point cpt */
    1255 static void pt_get_eol(spt_t *cpt, spt_t *ept)
    1256 {
    1257         coord_t coord;
    1258         int row_width;
    1259 
    1260         spt_get_coord(cpt, &coord);
    1261         sheet_get_row_width(&doc.sh, coord.row, &row_width);
    1262         coord.column = row_width - 1;
    1263 
    1264         sheet_get_cell_pt(&doc.sh, &coord, dir_after, ept);
    1265 }
    1266 
    1267 /** Check whether the spt is at a beginning of a word */
    1268 static bool pt_is_word_beginning(spt_t *pt)
    1269 {
    1270         spt_t lp, sfp, efp, slp, elp;
    1271         coord_t coord;
    1272 
    1273         pt_get_sof(&sfp);
    1274         pt_get_eof(&efp);
    1275         pt_get_sol(pt, &slp);
    1276         pt_get_eol(pt, &elp);
    1277 
    1278         /* the spt is at the beginning or end of the file or line */
    1279         if ((spt_cmp(&sfp, pt) == 0) || (spt_cmp(&efp, pt) == 0)
    1280             || (spt_cmp(&slp, pt) == 0) || (spt_cmp(&elp, pt) == 0))
    1281                 return true;
    1282 
    1283         /* the spt is a delimiter */
    1284         if (pt_is_delimiter(pt))
    1285                 return false;
    1286 
    1287         spt_get_coord(pt, &coord);
    1288 
    1289         coord.column -= 1;
    1290         sheet_get_cell_pt(&doc.sh, &coord, dir_before, &lp);
    1291 
    1292         return pt_is_delimiter(&lp)
    1293             || (pt_is_punctuation(pt) && !pt_is_punctuation(&lp))
    1294             || (pt_is_punctuation(&lp) && !pt_is_punctuation(pt));
    1295 }
    1296 
    1297 static wchar_t get_first_wchar(const char *str)
    1298 {
    1299         size_t offset = 0;
    1300         return str_decode(str, &offset, str_size(str));
    1301 }
    1302 
    1303 static bool pt_is_delimiter(spt_t *pt)
    1304 {
    1305         spt_t rp;
    1306         coord_t coord;
    1307         char *ch = NULL;
    1308 
    1309         spt_get_coord(pt, &coord);
    1310 
    1311         coord.column += 1;
    1312         sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
    1313 
    1314         ch = range_get_str(pt, &rp);
    1315         if (ch == NULL)
    1316                 return false;
    1317 
    1318         wchar_t first_char = get_first_wchar(ch);
    1319         switch(first_char) {
    1320         case ' ':
    1321         case '\t':
    1322         case '\n':
    1323                 return true;
    1324         default:
    1325                 return false;
    1326         }
    1327 }
    1328 
    1329 static bool pt_is_punctuation(spt_t *pt)
    1330 {
    1331         spt_t rp;
    1332         coord_t coord;
    1333         char *ch = NULL;
    1334 
    1335         spt_get_coord(pt, &coord);
    1336 
    1337         coord.column += 1;
    1338         sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
    1339 
    1340         ch = range_get_str(pt, &rp);
    1341         if (ch == NULL)
    1342                 return false;
    1343 
    1344         wchar_t first_char = get_first_wchar(ch);
    1345         switch(first_char) {
    1346         case ',':
    1347         case '.':
    1348         case ';':
    1349         case ':':
    1350         case '/':
    1351         case '?':
    1352         case '\\':
    1353         case '|':
    1354         case '_':
    1355         case '+':
    1356         case '-':
    1357         case '*':
    1358         case '=':
    1359         case '<':
    1360         case '>':
    1361                 return true;
    1362         default:
    1363                 return false;
    1364         }
    13651119}
    13661120

  • uspace/app/edit/sheet.c

    rf7e69f5 r0a0e6e7  
    264264        sheet_get_cell_pt(sh, &coord, dir_before, &pt);
    265265        spt_get_coord(&pt, &coord);
    266         *length = coord.column;
     266        *length = coord.column - 1;
    267267}
    268268

  • uspace/app/killall/killall.c

    rf7e69f5 r0a0e6e7  
    3636#include <errno.h>
    3737#include <stdio.h>
    38 #include <unistd.h>
    3938#include <task.h>
    4039#include <stats.h>

  • uspace/app/nettest1/nettest1.c

    rf7e69f5 r0a0e6e7  
    4040#include <malloc.h>
    4141#include <stdio.h>
    42 #include <unistd.h>
    4342#include <str.h>
    4443#include <task.h>

  • uspace/app/nettest2/nettest2.c

    rf7e69f5 r0a0e6e7  
    4040#include <malloc.h>
    4141#include <stdio.h>
    42 #include <unistd.h>
    4342#include <str.h>
    4443#include <task.h>

  • uspace/app/sbi/src/mytypes.h

    rf7e69f5 r0a0e6e7  
    5151/** Error return codes. */
    5252#include <errno.h>
    53 /** We need NULL defined. */
    54 #include <unistd.h>
    5553#define EOK 0
    5654

  • uspace/app/sysinfo/sysinfo.c

    rf7e69f5 r0a0e6e7  
    3636#include <errno.h>
    3737#include <stdio.h>
    38 #include <unistd.h>
    3938#include <sysinfo.h>
    4039#include <malloc.h>

  • uspace/app/websrv/websrv.c

    rf7e69f5 r0a0e6e7  
    3636#include <bool.h>
    3737#include <errno.h>
    38 #include <assert.h>
    3938#include <stdio.h>
    4039#include <sys/types.h>

  • uspace/drv/bus/usb/ohci/utils/malloc32.h

    rf7e69f5 r0a0e6e7  
    3737#include <assert.h>
    3838#include <malloc.h>
    39 #include <unistd.h>
    4039#include <errno.h>
    4140#include <mem.h>

  • uspace/drv/bus/usb/uhci/utils/malloc32.h

    rf7e69f5 r0a0e6e7  
    3636
    3737#include <assert.h>
    38 #include <unistd.h>
    3938#include <errno.h>
    4039#include <malloc.h>

  • uspace/lib/c/generic/stacktrace.c

    rf7e69f5 r0a0e6e7  
    3838#include <sys/types.h>
    3939#include <errno.h>
    40 #include <unistd.h>
    4140
    4241static int stacktrace_read_uintptr(void *arg, uintptr_t addr, uintptr_t *data);

  • uspace/lib/c/generic/stats.c

    rf7e69f5 r0a0e6e7  
    4040#include <inttypes.h>
    4141#include <malloc.h>
    42 #include <unistd.h>
    4342
    4443#define SYSINFO_STATS_MAX_PATH  64

  • uspace/lib/c/generic/sysinfo.c

    rf7e69f5 r0a0e6e7  
    3939#include <malloc.h>
    4040#include <bool.h>
    41 #include <unistd.h>
    4241
    4342/** Get sysinfo keys size

  • uspace/lib/c/generic/time.c

    rf7e69f5 r0a0e6e7  
    4848#include <stdio.h>
    4949#include <ctype.h>
    50 #include <assert.h>
    51 #include <unistd.h>
    5250
    5351#define ASCTIME_BUF_LEN 26

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

    rf7e69f5 r0a0e6e7  
    3737
    3838#include <abi/errno.h>
     39#include <fibril.h>
    3940
    4041#define errno  (*(__errno()))

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

    rf7e69f5 r0a0e6e7  
    4343#define va_arg(ap, type)    __builtin_va_arg(ap, type)
    4444#define va_end(ap)          __builtin_va_end(ap)
    45 #define va_copy(dst, src)   __builtin_va_copy(dst, src)
    4645
    4746#endif

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

    rf7e69f5 r0a0e6e7  
    3939#include <stdarg.h>
    4040#include <str.h>
     41#include <adt/list.h>
    4142
    4243#ifndef NVERIFY_PRINTF

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

    rf7e69f5 r0a0e6e7  
    5858#define getpagesize()  (PAGE_SIZE)
    5959
    60 extern int dup2(int, int);
     60extern int dup2(int oldfd, int newfd);
    6161
    6262extern ssize_t write(int, const void *, size_t);
    … …  
    7373extern int unlink(const char *);
    7474
    75 extern char *getcwd(char *, size_t);
     75extern char *getcwd(char *buf, size_t);
    7676extern int rmdir(const char *);
    7777extern int chdir(const char *);

  • uspace/lib/clui/tinput.h

    rf7e69f5 r0a0e6e7  
    3737#define LIBCLUI_TINPUT_H_
    3838
     39#include <adt/list.h>
     40#include <async.h>
    3941#include <inttypes.h>
    4042#include <io/console.h>

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

    rf7e69f5 r0a0e6e7  
    3535#include <ddf/log.h>
    3636#include <assert.h>
    37 #include <unistd.h>
    3837
    3938/** Formatting string for printing number of not-printed items. */

  • uspace/lib/drv/include/ddf/interrupt.h

    rf7e69f5 r0a0e6e7  
    3636#define DDF_INTERRUPT_H_
    3737
    38 #include <libarch/common.h>
    39 #include <libarch/types.h>
    4038#include <abi/ddi/irq.h>
    4139#include <adt/list.h>

  • uspace/lib/posix/Makefile

    rf7e69f5 r0a0e6e7  
    4343        fcntl.c \
    4444        fnmatch.c \
    45         getopt.c \
    4645        locale.c \
    4746        math.c \

  • uspace/lib/posix/errno.h

    rf7e69f5 r0a0e6e7  
    6666#undef errno
    6767#define errno (*__posix_errno())
    68 
    69 #include "unistd.h"
    7068
    7169extern int *__posix_errno(void);

  • uspace/lib/posix/pwd.c

    rf7e69f5 r0a0e6e7  
    3838#include "string.h"
    3939#include "errno.h"
    40 #include "assert.h"
    4140
    4241static bool entry_read = false;

  • uspace/lib/posix/stdbool.h

    rf7e69f5 r0a0e6e7  
    3737
    3838#ifdef LIBC_BOOL_H_
    39 #if (!defined(POSIX_STDIO_H_)) \
    40                 && (!defined(POSIX_STDLIB_H_)) \
    41                 && (!defined(POSIX_STRING_H_))
    42 #error "You can't include bool.h and stdbool.h at the same time."
     39        #error "You can't include bool.h and stdbool.h at the same time."
    4340#endif
    44 #endif
    45 
    4641#define LIBC_BOOL_H_
    4742

  • uspace/lib/posix/stdio.h

    rf7e69f5 r0a0e6e7  
    3737#define POSIX_STDIO_H_
    3838
    39 #include "stddef.h"
    40 #include "unistd.h"
    4139#include "libc/stdio.h"
    4240#include "sys/types.h"

  • uspace/lib/posix/time.c

    rf7e69f5 r0a0e6e7  
    4545#include "errno.h"
    4646#include "signal.h"
    47 #include "assert.h"
    4847
    4948#include "libc/malloc.h"

  • uspace/lib/posix/unistd.c

    rf7e69f5 r0a0e6e7  
    4949/* Array of environment variable strings (NAME=VALUE). */
    5050char **posix_environ = NULL;
    51 char *posix_optarg;
    5251
    5352/**

  • uspace/lib/posix/unistd.h

    rf7e69f5 r0a0e6e7  
    4343#define _exit exit
    4444
    45 extern char *posix_optarg;
     45/* Option Arguments */
     46extern char *optarg;
    4647extern int optind, opterr, optopt;
    47 extern int posix_getopt(int, char * const [], const char *);
     48extern int getopt(int, char * const [], const char *);
    4849
    4950/* Environment */
    … …  
    143144
    144145#ifndef LIBPOSIX_INTERNAL
    145         #define getopt posix_getopt
    146         #define optarg posix_optarg
    147 
    148146        #define environ posix_environ
    149147

  • uspace/srv/fs/fat/fat_dentry.c

    rf7e69f5 r0a0e6e7  
    4343#include <byteorder.h>
    4444#include <assert.h>
    45 #include <unistd.h>
    4645
    4746/** Compare path component with the name read from the dentry.
Note: See TracChangeset for help on using the changeset viewer.