Changes in / [0a0e6e7:f7e69f5] in mainline

Files:

• HelenOS.config (modified) (1 diff)
• boot/Makefile.common (modified) (1 diff)
• tools/checkers/clang.py (modified) (1 diff)
• tools/checkers/stanse.py (modified) (1 diff)
• tools/checkers/vcc.py (modified) (1 diff)
• tools/filldir.py (modified) (1 diff)
• tools/gentestfile.py (modified) (1 diff)
• tools/mkfat.py (modified) (3 diffs)
• tools/mkuimage.py (modified) (3 diffs)
• tools/xstruct.py (modified) (2 diffs)
• uspace/Makefile (modified) (1 diff)
• uspace/app/bdsh/Makefile (modified) (1 diff)
• uspace/app/bdsh/TODO (modified) (1 diff)
• uspace/app/bdsh/cmds/builtins/cd/cd.c (modified) (5 diffs)
• uspace/app/bdsh/cmds/modules/cat/cat.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/cp/cp.c (modified) (12 diffs)
• uspace/app/bdsh/cmds/modules/echo/echo.c (added)
• uspace/app/bdsh/cmds/modules/echo/echo.h (added)
• uspace/app/bdsh/cmds/modules/echo/echo_def.h (added)
• uspace/app/bdsh/cmds/modules/echo/entry.h (added)
• uspace/app/bdsh/cmds/modules/help/help.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/mkdir/mkdir.c (modified) (7 diffs)
• uspace/app/bdsh/cmds/modules/mkdir/mkdir.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/modules.h (modified) (2 diffs)
• uspace/app/bdsh/cmds/modules/printf/TODO (added)
• uspace/app/bdsh/cmds/modules/printf/entry.h (added)
• uspace/app/bdsh/cmds/modules/printf/printf.c (added)
• uspace/app/bdsh/cmds/modules/printf/printf.h (added)
• uspace/app/bdsh/cmds/modules/printf/printf_def.h (added)
• uspace/app/bdsh/cmds/modules/rm/rm.c (modified) (4 diffs)
• uspace/app/bdsh/cmds/modules/rm/rm.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/sleep/sleep.c (modified) (3 diffs)
• uspace/app/edit/edit.c (modified) (10 diffs)
• uspace/app/edit/sheet.c (modified) (1 diff)
• uspace/app/killall/killall.c (modified) (1 diff)
• uspace/app/msim/Makefile (added)
• uspace/app/msim/Makefile.msim.src (added)
• uspace/app/msim/arch_helenos/helenos.h (added)
• uspace/app/msim/arch_helenos/input.c (added)
• uspace/app/msim/arch_helenos/misc.c (added)
• uspace/app/msim/config.h.msim (added)
• uspace/app/nettest1/nettest1.c (modified) (1 diff)
• uspace/app/nettest2/nettest2.c (modified) (1 diff)
• uspace/app/sbi/src/mytypes.h (modified) (1 diff)
• uspace/app/sysinfo/sysinfo.c (modified) (1 diff)
• uspace/app/websrv/websrv.c (modified) (1 diff)
• uspace/drv/bus/usb/ohci/utils/malloc32.h (modified) (1 diff)
• uspace/drv/bus/usb/uhci/utils/malloc32.h (modified) (1 diff)
• uspace/lib/c/generic/stacktrace.c (modified) (1 diff)
• uspace/lib/c/generic/stats.c (modified) (1 diff)
• uspace/lib/c/generic/sysinfo.c (modified) (1 diff)
• uspace/lib/c/generic/time.c (modified) (1 diff)
• uspace/lib/c/include/errno.h (modified) (1 diff)
• uspace/lib/c/include/stdarg.h (modified) (1 diff)
• uspace/lib/c/include/stdio.h (modified) (1 diff)
• uspace/lib/c/include/unistd.h (modified) (2 diffs)
• uspace/lib/clui/tinput.h (modified) (1 diff)
• uspace/lib/drv/generic/logbuf.c (modified) (1 diff)
• uspace/lib/drv/include/ddf/interrupt.h (modified) (1 diff)
• uspace/lib/posix/Makefile (modified) (1 diff)
• uspace/lib/posix/errno.h (modified) (1 diff)
• uspace/lib/posix/getopt.c (added)
• uspace/lib/posix/getopt.h (added)
• uspace/lib/posix/pwd.c (modified) (1 diff)
• uspace/lib/posix/stdbool.h (modified) (1 diff)
• uspace/lib/posix/stdio.h (modified) (1 diff)
• uspace/lib/posix/time.c (modified) (1 diff)
• uspace/lib/posix/unistd.c (modified) (1 diff)
• uspace/lib/posix/unistd.h (modified) (2 diffs)
• uspace/srv/fs/fat/fat_dentry.c (modified) (1 diff)

HelenOS.config

@@ -573 +573 @@
 ! CONFIG_BINUTILS (n/y)
 
+% Build MSIM binary
+! CONFIG_MSIM (n/y)
+
 % Line debugging information
 ! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)

boot/Makefile.common

@@ -202 +202 @@
 endif
 
+ifeq ($(CONFIG_MSIM),y)
+RD_APPS_NON_ESSENTIAL += \
+        $(USPACE_PATH)/app/msim/msim
+endif
+
 COMPONENTS = \
         $(KERNEL_PATH)/kernel.bin \

tools/checkers/clang.py

@@ -114 +114 @@
         for job in jobs:
                 if (not clang(rootdir, job)):
-                        print
+                        print()
                         print("Failed job: %s" % job)
                         return

tools/checkers/stanse.py

@@ -127 +127 @@
         for job in jobs:
                 if (not stanse(rootdir, job)):
-                        print
+                        print()
                         print("Failed job: %s" % job)
                         return

tools/checkers/vcc.py

@@ -204 +204 @@
         for job in jobs:
                 if (not vcc(vcc_path, rootdir, job)):
-                        print
+                        print()
                         print("Failed job: %s" % job)
                         return
         
-        print
+        print()
         print("All jobs passed")
 

tools/filldir.py

@@ -37 +37 @@
 
 if len(sys.argv) < 3:
-        print 'Usage: filldir <parent-dir> <count>'
+        print('Usage: filldir <parent-dir> <count>')
         exit(2)
 

tools/gentestfile.py

@@ -36 +36 @@
 
 if len(sys.argv) < 2:
-        print "Usage: gentestfile.py <count of 64-bit numbers to output>"
+        print("Usage: gentestfile.py <count of 64-bit numbers to output>")
         exit()
 
-m = long(sys.argv[1])
+m = int(sys.argv[1])
 i = 0
 pow_2_64 = 2 ** 64

tools/mkfat.py

@@ -189 +189 @@
         "Filter FAT legal characters"
         
-        filtered_name = ''
+        filtered_name = b''
         filtered = False
         
@@ -205 +205 @@
         
         ascii_name, lfn = fat_lchars(name)
-        ascii_parts = ascii_name.split('.')
+        # Splitting works only on strings, not on bytes
+        ascii_parts = ascii_name.decode('utf8').split('.')
         
         short_name = ''
@@ -444 +445 @@
         extra_bytes = int(sys.argv[1])
         
-        path = os.path.abspath(sys.argv[2].decode())
+        path = os.path.abspath(sys.argv[2])
         if (not os.path.isdir(path)):
                 print("<PATH> must be a directory")

tools/mkuimage.py

@@ -124 +124 @@
         header.img_type = 2             # Kernel
         header.compression = 0          # None
-        header.img_name = image_name
+        header.img_name = image_name.encode('ascii')
 
         header_crc = calc_crc32(header.pack())
@@ -140 +140 @@
         signed_crc = zlib.crc32(byteseq, 0)
         if signed_crc < 0:
-                return (long(signed_crc) + (long(2) ** long(32))) # 2^32L
+                return signed_crc + (1 << 32)
         else:
                 return signed_crc
@@ -148 +148 @@
 def print_syntax(cmd):
         print("syntax: " + cmd + " [<options>] <raw_image> <uImage>")
-        print
+        print()
         print("\traw_image\tInput image name (raw binary data)")
         print("\tuImage\t\tOutput uImage name (U-Boot image)")
-        print
+        print()
         print("options:")
         print("\t-name <name>\tImage name (default: 'Noname')")

tools/xstruct.py

@@ -32 +32 @@
 
 import struct
+import sys
 import types
 
+# Handle long integer conversions nicely in both Python 2 and Python 3
+integer_types = (int, long) if sys.version < '3' else (int,)
+
+# Ensure that 's' format for struct receives correct data type depending
+# on Python version (needed due to different way to encode into bytes) 
+ensure_string = \
+        (lambda value: value if type(value) is str else bytes(value)) \
+                if sys.version < '3' else \
+        (lambda value: bytes(value, 'ascii') if type(value) is str else value)
+
 ranges = {
-        'B': ((int, long), 0x00, 0xff),
-        'H': ((int, long), 0x0000, 0xffff),
-        'L': ((int, long), 0x00000000, 0xffffffff),
-        'Q': ((int, long), 0x0000000000000000, 0xffffffffffffffff),
-        'b': ((int, long), -0x80, 0x7f),
-        'h': ((int, long), -0x8000, 0x7fff),
-        'l': ((int, long), -0x80000000, 0x7fffffff) ,
-        'q': ((int, long), -0x8000000000000000, 0x7fffffffffffffff),
+        'B': (integer_types, 0x00, 0xff),
+        'H': (integer_types, 0x0000, 0xffff),
+        'L': (integer_types, 0x00000000, 0xffffffff),
+        'Q': (integer_types, 0x0000000000000000, 0xffffffffffffffff),
+        'b': (integer_types, -0x80, 0x7f),
+        'h': (integer_types, -0x8000, 0x7fff),
+        'l': (integer_types, -0x80000000, 0x7fffffff) ,
+        'q': (integer_types, -0x8000000000000000, 0x7fffffffffffffff),
 }
 
@@ -74 +85 @@
                                         args.append(item)
                         else:
+                                if (fmt == "s"):
+                                        value = ensure_string(value)
                                 check_range(variable, fmt, value)
                                 args.append(value)              

uspace/Makefile

@@ -139 +139 @@
 endif
 
+ifeq ($(CONFIG_MSIM),y)
+DIRS += \
+        app/msim
+endif
+
 ## Platform-specific hardware support
 #

uspace/app/bdsh/Makefile

@@ -48 +48 @@
         cmds/modules/cp/cp.c \
         cmds/modules/mv/mv.c \
+        cmds/modules/printf/printf.c \
+        cmds/modules/echo/echo.c \
         cmds/modules/mount/mount.c \
         cmds/modules/unmount/unmount.c \

uspace/app/bdsh/TODO

@@ -30 +30 @@
 * Add wrappers for signal, sigaction to make ports to modules easier
 
-* Add 'echo' and 'printf' modules.
-
 Regarding POSIX:
 ----------------

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

@@ -41 +41 @@
 static const char *cmdname = "cd";
 
+/* Previous directory variables.
+ *
+ * Declaring them static to avoid many "== NULL" checks.
+ * PATH_MAX is not that big to cause any problems with memory overhead.
+ */
+static char previous_directory[PATH_MAX] = "";
+static char previous_directory_tmp[PATH_MAX];
+static bool previous_directory_valid = true;
+static bool previous_directory_set = false;
+
+static int chdir_and_remember(const char *new_dir) {
+
+        char *ok = getcwd(previous_directory_tmp, PATH_MAX);
+        previous_directory_valid = ok != NULL;
+        previous_directory_set = true;
+
+        int rc = chdir(new_dir);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        str_cpy(previous_directory, PATH_MAX, previous_directory_tmp);
+        return EOK;
+}
+
 void help_cmd_cd(unsigned int level)
 {
@@ -55 +80 @@
 }
 
+
 /* This is a very rudamentary 'cd' command. It is not 'link smart' (yet) */
 
@@ -62 +88 @@
 
         argc = cli_count_args(argv);
+
+        /* Handle cd -- -. Override to switch to a directory named '-' */
+        bool hyphen_override = false;
+        char *target_directory = argv[1];
+        if (argc == 3) {
+                if (!str_cmp(argv[1], "--")) {
+                        hyphen_override = true;
+                        argc--;
+                        target_directory = argv[2];
+                }
+        }
 
         /* We don't yet play nice with whitespace, a getopt implementation should
@@ -79 +116 @@
         }
 
-        /* We have the correct # of arguments
-     * TODO: handle tidle (~) expansion? */
+        /* We have the correct # of arguments */
+        // TODO: handle tidle (~) expansion? */
 
-        rc = chdir(argv[1]);
+        /* Handle 'cd -' first. */
+        if (!str_cmp(target_directory, "-") && !hyphen_override) {
+                if (!previous_directory_valid) {
+                        cli_error(CL_EFAIL, "Cannot switch to previous directory");
+                        return CMD_FAILURE;
+                }
+                if (!previous_directory_set) {
+                        cli_error(CL_EFAIL, "No previous directory to switch to");
+                        return CMD_FAILURE;
+                }
+                char *prev_dup = str_dup(previous_directory);
+                if (prev_dup == NULL) {
+                        cli_error(CL_ENOMEM, "Cannot switch to previous directory");
+                        return CMD_FAILURE;
+                }
+                rc = chdir_and_remember(prev_dup);
+                free(prev_dup);
+        } else {
+                rc = chdir_and_remember(target_directory);
+        }
 
         if (rc == 0) {
@@ -93 +149 @@
                         break;
                 case ENOENT:
-                        cli_error(CL_ENOENT, "Invalid directory `%s'", argv[1]);
+                        cli_error(CL_ENOENT, "Invalid directory `%s'", target_directory);
                         break;
                 default:
-                        cli_error(CL_EFAIL, "Unable to change to `%s'", argv[1]);
+                        cli_error(CL_EFAIL, "Unable to change to `%s'", target_directory);
                         break;
                 }

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

@@ -4 +4 @@
 /* Prototypes for the cat command, excluding entry points */
 
-static unsigned int cat_file(const char *, size_t, bool, off64_t, off64_t, bool);
-
 #endif /* CAT_H */
 

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

@@ -30 +30 @@
 #include <stdlib.h>
 #include <unistd.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <getopt.h>
 #include <str.h>
@@ -46 +48 @@
 
 static const char *cmdname = "cp";
+static console_ctrl_t *con;
 
 static struct option const long_options[] = {
         { "buffer", required_argument, 0, 'b' },
         { "force", no_argument, 0, 'f' },
+        { "interactive", no_argument, 0, 'i'},
         { "recursive", no_argument, 0, 'r' },
         { "help", no_argument, 0, 'h' },
@@ -139 +143 @@
 }
 
+static bool get_user_decision(bool bdefault, const char *message, ...)
+{
+        va_list args;
+
+        va_start(args, message);
+        vprintf(message, args);
+        va_end(args);
+
+        while (true) {
+                kbd_event_t ev;
+                console_flush(con);
+                console_get_kbd_event(con, &ev);
+                if ((ev.type != KEY_PRESS)
+                    || (ev.mods & (KM_CTRL | KM_ALT)) != 0) {
+                        continue;
+                }
+
+                switch(ev.key) {
+                case KC_Y:
+                        printf("y\n");
+                        return true;
+                case KC_N:
+                        printf("n\n");
+                        return false;
+                case KC_ENTER:
+                        printf("%c\n", bdefault ? 'Y' : 'N');
+                        return bdefault;
+                default:
+                        break;
+                }
+        }
+}
+
 static int64_t do_copy(const char *src, const char *dest,
-    size_t blen, int vb, int recursive, int force)
+    size_t blen, int vb, int recursive, int force, int interactive)
 {
         int r = -1;
@@ -192 +229 @@
                         /* e.g. cp file_name existing_file */
 
-                        /* dest already exists, if force is set we will
-                         * try to remove it.
+                        /* dest already exists, 
+                         * if force is set we will try to remove it.
+                         * if interactive is set user input is required.
                          */
-                        if (force) {
+                        if (force && !interactive) {
                                 if (unlink(dest_path)) {
                                         printf("Unable to remove %s\n",
@@ -201 +239 @@
                                         goto exit;
                                 }
+                        } else if (!force && interactive) {
+                                bool overwrite = get_user_decision(false,
+                                    "File already exists: %s. Overwrite? [y/N]: ",
+                                    dest_path);
+                                if (overwrite) {
+                                        printf("Overwriting file: %s\n", dest_path);
+                                        if (unlink(dest_path)) {
+                                                printf("Unable to remove %s\n", dest_path);
+                                                goto exit;
+                                        }
+                                } else {
+                                        printf("Not overwriting file: %s\n", dest_path);
+                                        r = 0;
+                                        goto exit;
+                                }
                         } else {
-                                printf("file already exists: %s\n", dest_path);
+                                printf("File already exists: %s\n", dest_path);
                                 goto exit;
                         }
@@ -302 +355 @@
                         /* Recursively call do_copy() */
                         r = do_copy(src_dent, dest_dent, blen, vb, recursive,
-                            force);
+                            force, interactive);
                         if (r)
                                 goto exit;
@@ -315 +368 @@
         return r;
 }
-
 
 static int64_t copy_file(const char *src, const char *dest,
@@ -380 +432 @@
             "  -v, --version    Print version information and exit\n"
             "  -V, --verbose    Be annoyingly noisy about what's being done\n"
-            "  -f, --force      Do not complain when <dest> exists\n"
+            "  -f, --force      Do not complain when <dest> exists (overrides a previous -i)\n"
+            "  -i, --interactive Ask what to do when <dest> exists (overrides a previous -f)\n"
             "  -r, --recursive  Copy entire directories\n"
             "  -b, --buffer ## Set the read buffer size to ##\n";
@@ -397 +450 @@
         unsigned int argc, verbose = 0;
         int buffer = 0, recursive = 0;
-        int force = 0;
+        int force = 0, interactive = 0;
         int c, opt_ind;
         int64_t ret;
 
+        con = console_init(stdin, stdout);
         argc = cli_count_args(argv);
 
         for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
-                c = getopt_long(argc, argv, "hvVfrb:", long_options, &opt_ind);
+                c = getopt_long(argc, argv, "hvVfirb:", long_options, &opt_ind);
                 switch (c) { 
                 case 'h':
@@ -416 +470 @@
                         break;
                 case 'f':
+                        interactive = 0;
                         force = 1;
+                        break;
+                case 'i':
+                        force = 0;
+                        interactive = 1;
                         break;
                 case 'r':
@@ -426 +485 @@
                                     "(should be a number greater than zero)\n",
                                     cmdname);
+                                console_done(con);
                                 return CMD_FAILURE;
                         }
@@ -442 +502 @@
                 printf("%s: invalid number of arguments. Try %s --help\n",
                     cmdname, cmdname);
+                console_done(con);
                 return CMD_FAILURE;
         }
 
         ret = do_copy(argv[optind], argv[optind + 1], buffer, verbose,
-            recursive, force);
+            recursive, force, interactive);
+
+        console_done(con);
 
         if (ret == 0)

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

@@ -3 +3 @@
 
 /* Prototypes for the help command (excluding entry points) */
-static int is_mod_or_builtin(char *);
 
 #endif

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

@@ -36 +36 @@
 #include <stdarg.h>
 #include <str.h>
+#include <errno.h>
+#include <str_error.h>
+#include <vfs/vfs.h>
 
 #include "config.h"
@@ -83 +86 @@
 /* This is kind of clunky, but effective for now */
 static unsigned int
-create_directory(const char *path, unsigned int p)
+create_directory(const char *user_path, bool create_parents)
 {
-        DIR *dirp;
-        char *tmp = NULL, *buff = NULL, *wdp = NULL;
-        char *dirs[255];
-        unsigned int absolute = 0, i = 0, ret = 0;
-
-        /* Its a good idea to allocate path, plus we (may) need a copy of
-         * path to tokenize if parents are specified */
-        if (NULL == (tmp = str_dup(path))) {
+        /* Ensure we would always work with absolute and canonified path. */
+        char *path = absolutize(user_path, NULL);
+        if (path == NULL) {
                 cli_error(CL_ENOMEM, "%s: path too big?", cmdname);
                 return 1;
         }
 
-        if (NULL == (wdp = (char *) malloc(PATH_MAX))) {
-                cli_error(CL_ENOMEM, "%s: could not alloc cwd", cmdname);
-                free(tmp);
-                return 1;
-        }
-
-        /* The only reason for wdp is to be (optionally) verbose */
-        getcwd(wdp, PATH_MAX);
-
-        /* Typical use without specifying the creation of parents */
-        if (p == 0) {
-                dirp = opendir(tmp);
-                if (dirp) {
-                        cli_error(CL_EEXISTS, "%s: can not create %s, try -p", cmdname, path);
-                        closedir(dirp);
-                        goto finit;
-                }
-                if (-1 == (mkdir(tmp, 0))) {
-                        cli_error(CL_EFAIL, "%s: could not create %s", cmdname, path);
-                        goto finit;
-                }
-        }
-
-        /* Parents need to be created, path has to be broken up */
-
-        /* See if path[0] is a slash, if so we have to remember to append it */
-        if (tmp[0] == '/')
-                absolute = 1;
-
-        /* TODO: Canonify the path prior to tokenizing it, see below */
-        dirs[i] = strtok(tmp, "/");
-        while (dirs[i] && i < 255)
-                dirs[++i] = strtok(NULL, "/");
-
-        if (NULL == dirs[0])
-                return 1;
-
-        if (absolute == 1) {
-                asprintf(&buff, "/%s", dirs[0]);
-                mkdir(buff, 0);
-                chdir(buff);
-                free(buff);
-                getcwd(wdp, PATH_MAX);
-                i = 1;
+        int rc;
+        int ret = 0;
+
+        if (!create_parents) {
+                rc = mkdir(path, 0);
+                if (rc != EOK) {
+                        cli_error(CL_EFAIL, "%s: could not create %s (%s)",
+                            cmdname, path, str_error(rc));
+                        ret = 1;
+                }
         } else {
-                i = 0;
-        }
-
-        while (dirs[i] != NULL) {
-                /* Sometimes make or scripts conjoin odd paths. Account for something
-                 * like this: ../../foo/bar/../foo/foofoo/./bar */
-                if (!str_cmp(dirs[i], "..") || !str_cmp(dirs[i], ".")) {
-                        if (0 != (chdir(dirs[i]))) {
-                                cli_error(CL_EFAIL, "%s: impossible path: %s",
-                                        cmdname, path);
-                                ret ++;
-                                goto finit;
-                        }
-                        getcwd(wdp, PATH_MAX);
-                } else {
-                        if (-1 == (mkdir(dirs[i], 0))) {
-                                cli_error(CL_EFAIL,
-                                        "%s: failed at %s/%s", wdp, dirs[i]);
-                                ret ++;
-                                goto finit;
-                        }
-                        if (0 != (chdir(dirs[i]))) {
-                                cli_error(CL_EFAIL, "%s: failed creating %s\n",
-                                        cmdname, dirs[i]);
-                                ret ++;
+                /* Create the parent directories as well. */
+                size_t off = 0;
+                while (1) {
+                        size_t prev_off = off;
+                        wchar_t cur_char = str_decode(path, &off, STR_NO_LIMIT);
+                        if ((cur_char == 0) || (cur_char == U_SPECIAL)) {
                                 break;
                         }
-                }
-                i++;
-        }
-        goto finit;
-
-finit:
-        free(wdp);
-        free(tmp);
+                        if (cur_char != '/') {
+                                continue;
+                        }
+                        if (prev_off == 0) {
+                                continue;
+                        }
+                        /*
+                         * If we are here, it means that:
+                         * - we found /
+                         * - it is not the first / (no need to create root
+                         *   directory)
+                         *
+                         * We would now overwrite the / with 0 to terminate the
+                         * string (that shall be okay because we are
+                         * overwriting at the beginning of UTF sequence).
+                         * That would allow us to create the directories
+                         * in correct nesting order.
+                         *
+                         * Notice that we ignore EEXIST errors as some of
+                         * the parent directories may already exist.
+                         */
+                        char slash_char = path[prev_off];
+                        path[prev_off] = 0;
+                        rc = mkdir(path, 0);
+                        if (rc == EEXIST) {
+                                rc = EOK;
+                        }
+
+                        if (rc != EOK) {
+                                cli_error(CL_EFAIL, "%s: could not create %s (%s)",
+                                    cmdname, path, str_error(rc));
+                                ret = 1;
+                                goto leave;
+                        }
+
+                        path[prev_off] = slash_char;
+                }
+                /* Create the final directory. */
+                rc = mkdir(path, 0);
+                if (rc != EOK) {
+                        cli_error(CL_EFAIL, "%s: could not create %s (%s)",
+                            cmdname, path, str_error(rc));
+                        ret = 1;
+                }
+        }
+
+leave:
+        free(path);
         return ret;
 }
@@ -182 +167 @@
 int cmd_mkdir(char **argv)
 {
-        unsigned int argc, create_parents = 0, i, ret = 0, follow = 0;
-        unsigned int verbose = 0;
+        unsigned int argc, i, ret = 0;
+        bool create_parents = false, follow = false, verbose = false;
         int c, opt_ind;
-        char *cwd;
 
         argc = cli_count_args(argv);
@@ -193 +177 @@
                 switch (c) {
                 case 'p':
-                        create_parents = 1;
+                        create_parents = true;
                         break;
                 case 'v':
-                        verbose = 1;
+                        verbose = true;
                         break;
                 case 'h':
@@ -205 +189 @@
                         return CMD_SUCCESS;
                 case 'f':
-                        follow = 1;
+                        follow = true;
                         break;
                 case 'm':
@@ -221 +205 @@
         }
 
-        if (NULL == (cwd = (char *) malloc(PATH_MAX))) {
-                cli_error(CL_ENOMEM, "%s: could not allocate cwd", cmdname);
-                return CMD_FAILURE;
-        }
-
-        memset(cwd, 0, sizeof(cwd));
-        getcwd(cwd, PATH_MAX);
-
         for (i = optind; argv[i] != NULL; i++) {
-                if (verbose == 1)
+                if (verbose)
                         printf("%s: creating %s%s\n",
                                 cmdname, argv[i],
@@ -237 +213 @@
         }
 
-        if (follow == 0)
-                chdir(cwd);
-
-        free(cwd);
+        if (follow && (argv[optind] != NULL)) {
+                chdir(argv[optind]);
+        }
 
         if (ret)

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

@@ -4 +4 @@
 /* Prototypes for the mkdir command, excluding entry points */
 
-static unsigned int create_directory(const char *, unsigned int);
 #endif /* MKDIR_H */
 

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

@@ -61 +61 @@
 #include "unmount/entry.h"
 #include "kcon/entry.h"
+#include "printf/entry.h"
+#include "echo/entry.h"
 
 /* Each .def function fills the module_t struct with the individual name, entry
@@ -82 +84 @@
 #include "unmount/unmount_def.h"
 #include "kcon/kcon_def.h"
+#include "printf/printf_def.h"
+#include "echo/echo_def.h"
 
         {NULL, NULL, NULL, NULL}

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

@@ -46 +46 @@
 #define RM_VERSION "0.0.1"
 
-static rm_job_t rm;
-
 static struct option const long_options[] = {
         { "help", no_argument, 0, 'h' },
@@ -57 +55 @@
 };
 
+/* Return values for rm_scope() */
+#define RM_BOGUS 0
+#define RM_FILE  1
+#define RM_DIR   2
+
+/* Flags for rm_update() */
+#define _RM_ENTRY   0
+#define _RM_ADVANCE 1
+#define _RM_REWIND  2
+#define _RM_EXIT    3
+
+/* A simple job structure */
+typedef struct {
+        /* Options set at run time */
+        unsigned int force;      /* -f option */
+        unsigned int recursive;  /* -r option */
+        unsigned int safe;       /* -s option */
+
+        /* Keeps track of the job in progress */
+        int advance; /* How far deep we've gone since entering */
+        DIR *entry;  /* Entry point to the tree being removed */
+        char *owd;   /* Where we were when we invoked rm */
+        char *cwd;   /* Current directory being transversed */
+        char *nwd;   /* Next directory to be transversed */
+
+        /* Counters */
+        int f_removed; /* Number of files unlinked */
+        int d_removed; /* Number of directories unlinked */
+} rm_job_t;
+
+static rm_job_t rm;
+
+static unsigned int rm_recursive(const char *);
+
 static unsigned int rm_start(rm_job_t *rm)
 {
@@ -95 +127 @@
         if (NULL != rm->cwd)
                 free(rm->cwd);
+}
+
+static unsigned int rm_single(const char *path)
+{
+        if (unlink(path)) {
+                cli_error(CL_EFAIL, "rm: could not remove file %s", path);
+                return 1;
+        }
+        return 0;
+}
+
+static unsigned int rm_scope(const char *path)
+{
+        int fd;
+        DIR *dirp;
+
+        dirp = opendir(path);
+        if (dirp) {
+                closedir(dirp);
+                return RM_DIR;
+        }
+
+        fd = open(path, O_RDONLY);
+        if (fd > 0) {
+                close(fd);
+                return RM_FILE;
+        }
+
+        return RM_BOGUS;
 }
 
@@ -154 +215 @@
 
         return ret + 1;
-}
-
-static unsigned int rm_single(const char *path)
-{
-        if (unlink(path)) {
-                cli_error(CL_EFAIL, "rm: could not remove file %s", path);
-                return 1;
-        }
-        return 0;
-}
-
-static unsigned int rm_scope(const char *path)
-{
-        int fd;
-        DIR *dirp;
-
-        dirp = opendir(path);
-        if (dirp) {
-                closedir(dirp);
-                return RM_DIR;
-        }
-
-        fd = open(path, O_RDONLY);
-        if (fd > 0) {
-                close(fd);
-                return RM_FILE;
-        }
-
-        return RM_BOGUS;
 }
 

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

@@ -2 +2 @@
 #define RM_H
 
-/* Return values for rm_scope() */
-#define RM_BOGUS 0
-#define RM_FILE  1
-#define RM_DIR   2
-
-/* Flags for rm_update() */
-#define _RM_ENTRY   0
-#define _RM_ADVANCE 1
-#define _RM_REWIND  2
-#define _RM_EXIT    3
-
-/* A simple job structure */
-typedef struct {
-        /* Options set at run time */
-        unsigned int force;      /* -f option */
-        unsigned int recursive;  /* -r option */
-        unsigned int safe;       /* -s option */
-
-        /* Keeps track of the job in progress */
-        int advance; /* How far deep we've gone since entering */
-        DIR *entry;  /* Entry point to the tree being removed */
-        char *owd;   /* Where we were when we invoked rm */
-        char *cwd;   /* Current directory being transversed */
-        char *nwd;   /* Next directory to be transversed */
-
-        /* Counters */
-        int f_removed; /* Number of files unlinked */
-        int d_removed; /* Number of directories unlinked */
-} rm_job_t;
-
-
 /* Prototypes for the rm command, excluding entry points */
-static unsigned int rm_start(rm_job_t *);
-static void rm_end(rm_job_t *rm);
-static unsigned int rm_recursive(const char *);
-static unsigned int rm_single(const char *);
-static unsigned int rm_scope(const char *);
 
 #endif /* RM_H */

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

@@ -27 +27 @@
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 #include "config.h"
 #include "util.h"
@@ -41 +43 @@
 void help_cmd_sleep(unsigned int level)
 {
-        printf("This is the %s help for '%s'.\n",
-                level ? EXT_HELP : SHORT_HELP, cmdname);
+        if (level == HELP_SHORT) {
+                printf("`%s' pauses for a given time interval\n", cmdname);
+        } else {
+                help_cmd_sleep(HELP_SHORT);
+                printf(
+                    "Usage:  %s <duration>\n"
+                    "The duration is a decimal number of seconds.\n",
+                    cmdname);
+        }
+
         return;
+}
+
+/** Convert string containing decimal seconds to useconds_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param result Result of the conversion.
+ * @return EOK if conversion was successful.
+ */
+static int decimal_to_useconds(const char *nptr, useconds_t *result)
+{
+        int ret;
+        uint64_t whole_seconds;
+        uint64_t frac_seconds;
+        char *endptr;
+
+        /* Check for whole seconds */
+        if (*nptr == '.') {
+                whole_seconds = 0;
+                endptr = (char *)nptr;
+        } else {
+                ret = str_uint64_t(nptr, &endptr, 10, false, &whole_seconds);
+                if (ret != EOK)
+                        return ret;
+        }
+
+        /* Check for fractional seconds */
+        if (*endptr == '\0') {
+                frac_seconds = 0;
+        } else if (*endptr == '.' && endptr[1] == '\0') {
+                frac_seconds = 0;
+        } else if (*endptr == '.') {
+                nptr = endptr + 1;
+                ret = str_uint64_t(nptr, &endptr, 10, true, &frac_seconds);
+                if (ret != EOK)
+                        return ret;
+
+                int ndigits = endptr - nptr;
+                for (; ndigits < 6; ndigits++) 
+                        frac_seconds *= 10;
+                for (; ndigits > 6; ndigits--)
+                        frac_seconds /= 10;
+        } else {
+                return EINVAL;
+        }
+
+        /* Check for overflow */
+        useconds_t total = whole_seconds * 1000000 + frac_seconds;
+        if (total / 1000000 != whole_seconds)
+                return EOVERFLOW;
+
+        *result = total;
+
+        return EOK;
 }
 
@@ -49 +112 @@
 int cmd_sleep(char **argv)
 {
+        int ret;
         unsigned int argc;
-        unsigned int i;
+        useconds_t duration;
 
         /* Count the arguments */
-        for (argc = 0; argv[argc] != NULL; argc ++);
+        argc = cli_count_args(argv);
 
-        printf("%s %s\n", TEST_ANNOUNCE, cmdname);
-        printf("%d arguments passed to %s", argc - 1, cmdname);
-
-        if (argc < 2) {
-                printf("\n");
-                return CMD_SUCCESS;
+        if (argc != 2) {
+                printf("%s - incorrect number of arguments. Try `help %s'\n",
+                    cmdname, cmdname);
+                return CMD_FAILURE;
         }
 
-        printf(":\n");
-        for (i = 1; i < argc; i++)
-                printf("[%d] -> %s\n", i, argv[i]);
+        ret = decimal_to_useconds(argv[1], &duration);
+        if (ret != EOK) {
+                printf("%s - invalid duration.\n", cmdname);
+                return CMD_FAILURE;
+        }
+
+        (void) usleep(duration);
 
         return CMD_SUCCESS;

uspace/app/edit/edit.c

@@ -118 +118 @@
 static void key_handle_ctrl(kbd_event_t const *ev);
 static void key_handle_shift(kbd_event_t const *ev);
+static void key_handle_shift_ctrl(kbd_event_t const *ev);
 static void key_handle_movement(unsigned int key, bool shift);
 
@@ -139 +140 @@
 static void caret_update(void);
 static void caret_move(int drow, int dcolumn, enum dir_spec align_dir);
+static void caret_move_word_left(void);
+static void caret_move_word_right(void);
 
 static bool selection_active(void);
 static void selection_sel_all(void);
+static void selection_sel_range(spt_t pa, spt_t pb);
+static void selection_sel_prev_word(void);
+static void selection_sel_next_word(void);
 static void selection_get_points(spt_t *pa, spt_t *pb);
 static void selection_delete(void);
@@ -149 +155 @@
 static void pt_get_sof(spt_t *pt);
 static void pt_get_eof(spt_t *pt);
+static void pt_get_sol(spt_t *cpt, spt_t *spt);
+static void pt_get_eol(spt_t *cpt, spt_t *ept);
+static bool pt_is_word_beginning(spt_t *pt);
+static bool pt_is_delimiter(spt_t *pt);
+static bool pt_is_punctuation(spt_t *pt);
 static int tag_cmp(tag_t const *a, tag_t const *b);
 static int spt_cmp(spt_t const *a, spt_t const *b);
@@ -232 +243 @@
                              (ev.mods & KM_SHIFT) != 0) {
                                 key_handle_shift(&ev);
+                        } else if (((ev.mods & KM_ALT) == 0) &&
+                            ((ev.mods & KM_CTRL) != 0) &&
+                             (ev.mods & KM_SHIFT) != 0) {
+                                key_handle_shift_ctrl(&ev);
                         } else if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
                                 key_handle_unmod(&ev);
@@ -376 +391 @@
         case KC_A:
                 selection_sel_all();
+                break;
+        case KC_W:
+                if (selection_active())
+                        break;
+                selection_sel_prev_word();
+                selection_delete();
+                break;
+        case KC_RIGHT:
+                caret_move_word_right();
+                break;
+        case KC_LEFT:
+                caret_move_word_left();
+                break;
+        default:
+                break;
+        }
+}
+
+static void key_handle_shift_ctrl(kbd_event_t const *ev)
+{
+        switch(ev->key) {
+        case KC_LEFT:
+                selection_sel_prev_word();
+                break;
+        case KC_RIGHT:
+                selection_sel_next_word();
                 break;
         default:
@@ -970 +1011 @@
         /* Clamp coordinates. */
         if (drow < 0 && coord.row < 1) coord.row = 1;
-        if (dcolumn < 0 && coord.column < 1) coord.column = 1;
+        if (dcolumn < 0 && coord.column < 1) {
+                if (coord.row < 2)
+                        coord.column = 1;
+                else {
+                        coord.row--;
+                        sheet_get_row_width(&doc.sh, coord.row, &coord.column);
+                }
+        }
         if (drow > 0) {
                 sheet_get_num_rows(&doc.sh, &num_rows);
@@ -998 +1046 @@
 }
 
+static void caret_move_word_left(void) 
+{
+        spt_t pt;
+
+        do {
+                caret_move(0, -1, dir_before);
+
+                tag_get_pt(&pane.caret_pos, &pt);
+
+                sheet_remove_tag(&doc.sh, &pane.sel_start);
+                sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
+        } while (!pt_is_word_beginning(&pt));
+
+        pane.rflags |= REDRAW_TEXT;
+}
+
+static void caret_move_word_right(void) 
+{
+        spt_t pt;
+
+        do {
+                caret_move(0, 0, dir_after);
+
+                tag_get_pt(&pane.caret_pos, &pt);
+
+                sheet_remove_tag(&doc.sh, &pane.sel_start);
+                sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
+        } while (!pt_is_word_beginning(&pt));
+
+        pane.rflags |= REDRAW_TEXT;
+}
+
 /** Check for non-empty selection. */
 static bool selection_active(void)
@@ -1045 +1125 @@
 }
 
+/** Select all text in the editor */
 static void selection_sel_all(void)
 {
@@ -1051 +1132 @@
         pt_get_sof(&spt);
         pt_get_eof(&ept);
+
+        selection_sel_range(spt, ept);
+}
+
+/** Select select all text in a given range with the given direction */
+static void selection_sel_range(spt_t pa, spt_t pb)
+{
         sheet_remove_tag(&doc.sh, &pane.sel_start);
-        sheet_place_tag(&doc.sh, &spt, &pane.sel_start);
+        sheet_place_tag(&doc.sh, &pa, &pane.sel_start);
         sheet_remove_tag(&doc.sh, &pane.caret_pos);
-        sheet_place_tag(&doc.sh, &ept, &pane.caret_pos);
+        sheet_place_tag(&doc.sh, &pb, &pane.caret_pos);
 
         pane.rflags |= REDRAW_TEXT;
         caret_update();
+}
+
+/** Add the previous word to the selection */
+static void selection_sel_prev_word(void)
+{
+        spt_t cpt, wpt, spt, ept;
+
+        selection_get_points(&spt, &ept);
+
+        tag_get_pt(&pane.caret_pos, &cpt);
+        caret_move_word_left();
+        tag_get_pt(&pane.caret_pos, &wpt);
+
+        if (spt_cmp(&spt, &cpt) == 0)
+                selection_sel_range(ept, wpt);
+        else
+                selection_sel_range(spt, wpt);
+}
+
+/** Add the next word to the selection */
+static void selection_sel_next_word(void)
+{
+        spt_t cpt, wpt, spt, ept;
+
+        selection_get_points(&spt, &ept);
+
+        tag_get_pt(&pane.caret_pos, &cpt);
+        caret_move_word_right();
+        tag_get_pt(&pane.caret_pos, &wpt);
+
+        if (spt_cmp(&ept, &cpt) == 0)
+                selection_sel_range(spt, wpt);
+        else
+                selection_sel_range(ept, wpt);
 }
 
@@ -1117 +1239 @@
 
         sheet_get_cell_pt(&doc.sh, &coord, dir_after, pt);
+}
+
+/** Get start-of-line s-point for given s-point cpt */
+static void pt_get_sol(spt_t *cpt, spt_t *spt)
+{
+        coord_t coord;
+
+        spt_get_coord(cpt, &coord);
+        coord.column = 1;
+
+        sheet_get_cell_pt(&doc.sh, &coord, dir_before, spt);
+}
+
+/** Get end-of-line s-point for given s-point cpt */
+static void pt_get_eol(spt_t *cpt, spt_t *ept)
+{
+        coord_t coord;
+        int row_width;
+
+        spt_get_coord(cpt, &coord);
+        sheet_get_row_width(&doc.sh, coord.row, &row_width);
+        coord.column = row_width - 1;
+
+        sheet_get_cell_pt(&doc.sh, &coord, dir_after, ept);
+}
+
+/** Check whether the spt is at a beginning of a word */
+static bool pt_is_word_beginning(spt_t *pt)
+{
+        spt_t lp, sfp, efp, slp, elp;
+        coord_t coord;
+
+        pt_get_sof(&sfp);
+        pt_get_eof(&efp);
+        pt_get_sol(pt, &slp);
+        pt_get_eol(pt, &elp);
+
+        /* the spt is at the beginning or end of the file or line */
+        if ((spt_cmp(&sfp, pt) == 0) || (spt_cmp(&efp, pt) == 0)
+            || (spt_cmp(&slp, pt) == 0) || (spt_cmp(&elp, pt) == 0))
+                return true;
+
+        /* the spt is a delimiter */
+        if (pt_is_delimiter(pt))
+                return false;
+
+        spt_get_coord(pt, &coord);
+
+        coord.column -= 1;
+        sheet_get_cell_pt(&doc.sh, &coord, dir_before, &lp);
+
+        return pt_is_delimiter(&lp)
+            || (pt_is_punctuation(pt) && !pt_is_punctuation(&lp))
+            || (pt_is_punctuation(&lp) && !pt_is_punctuation(pt));
+}
+
+static wchar_t get_first_wchar(const char *str)
+{
+        size_t offset = 0;
+        return str_decode(str, &offset, str_size(str));
+}
+
+static bool pt_is_delimiter(spt_t *pt)
+{
+        spt_t rp;
+        coord_t coord;
+        char *ch = NULL;
+
+        spt_get_coord(pt, &coord);
+
+        coord.column += 1;
+        sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
+
+        ch = range_get_str(pt, &rp);
+        if (ch == NULL)
+                return false;
+
+        wchar_t first_char = get_first_wchar(ch);
+        switch(first_char) {
+        case ' ':
+        case '\t':
+        case '\n':
+                return true;
+        default:
+                return false;
+        }
+}
+
+static bool pt_is_punctuation(spt_t *pt)
+{
+        spt_t rp;
+        coord_t coord;
+        char *ch = NULL;
+
+        spt_get_coord(pt, &coord);
+
+        coord.column += 1;
+        sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
+
+        ch = range_get_str(pt, &rp);
+        if (ch == NULL)
+                return false;
+
+        wchar_t first_char = get_first_wchar(ch);
+        switch(first_char) {
+        case ',':
+        case '.':
+        case ';':
+        case ':':
+        case '/':
+        case '?':
+        case '\\':
+        case '|':
+        case '_':
+        case '+':
+        case '-':
+        case '*':
+        case '=':
+        case '<':
+        case '>':
+                return true;
+        default:
+                return false;
+        }
 }
 

uspace/app/edit/sheet.c

@@ -264 +264 @@
         sheet_get_cell_pt(sh, &coord, dir_before, &pt);
         spt_get_coord(&pt, &coord);
-        *length = coord.column - 1;
+        *length = coord.column;
 }
 

uspace/app/killall/killall.c

@@ -36 +36 @@
 #include <errno.h>
 #include <stdio.h>
+#include <unistd.h>
 #include <task.h>
 #include <stats.h>

uspace/app/nettest1/nettest1.c

@@ -40 +40 @@
 #include <malloc.h>
 #include <stdio.h>
+#include <unistd.h>
 #include <str.h>
 #include <task.h>

uspace/app/nettest2/nettest2.c

@@ -40 +40 @@
 #include <malloc.h>
 #include <stdio.h>
+#include <unistd.h>
 #include <str.h>
 #include <task.h>

uspace/app/sbi/src/mytypes.h

@@ -51 +51 @@
 /** Error return codes. */
 #include <errno.h>
+/** We need NULL defined. */
+#include <unistd.h>
 #define EOK 0
 

uspace/app/sysinfo/sysinfo.c

@@ -36 +36 @@
 #include <errno.h>
 #include <stdio.h>
+#include <unistd.h>
 #include <sysinfo.h>
 #include <malloc.h>

uspace/app/websrv/websrv.c

@@ -36 +36 @@
 #include <bool.h>
 #include <errno.h>
+#include <assert.h>
 #include <stdio.h>
 #include <sys/types.h>

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

@@ -37 +37 @@
 #include <assert.h>
 #include <malloc.h>
+#include <unistd.h>
 #include <errno.h>
 #include <mem.h>

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

@@ -36 +36 @@
 
 #include <assert.h>
+#include <unistd.h>
 #include <errno.h>
 #include <malloc.h>

uspace/lib/c/generic/stacktrace.c

@@ -38 +38 @@
 #include <sys/types.h>
 #include <errno.h>
+#include <unistd.h>
 
 static int stacktrace_read_uintptr(void *arg, uintptr_t addr, uintptr_t *data);

uspace/lib/c/generic/stats.c

@@ -40 +40 @@
 #include <inttypes.h>
 #include <malloc.h>
+#include <unistd.h>
 
 #define SYSINFO_STATS_MAX_PATH  64

uspace/lib/c/generic/sysinfo.c

@@ -39 +39 @@
 #include <malloc.h>
 #include <bool.h>
+#include <unistd.h>
 
 /** Get sysinfo keys size

uspace/lib/c/generic/time.c

@@ -48 +48 @@
 #include <stdio.h>
 #include <ctype.h>
+#include <assert.h>
+#include <unistd.h>
 
 #define ASCTIME_BUF_LEN 26

uspace/lib/c/include/errno.h

@@ -37 +37 @@
 
 #include <abi/errno.h>
-#include <fibril.h>
 
 #define errno  (*(__errno()))

uspace/lib/c/include/stdarg.h

@@ -43 +43 @@
 #define va_arg(ap, type)    __builtin_va_arg(ap, type)
 #define va_end(ap)          __builtin_va_end(ap)
+#define va_copy(dst, src)   __builtin_va_copy(dst, src)
 
 #endif

uspace/lib/c/include/stdio.h

@@ -39 +39 @@
 #include <stdarg.h>
 #include <str.h>
-#include <adt/list.h>
 
 #ifndef NVERIFY_PRINTF

uspace/lib/c/include/unistd.h

@@ -58 +58 @@
 #define getpagesize()  (PAGE_SIZE)
 
-extern int dup2(int oldfd, int newfd);
+extern int dup2(int, int);
 
 extern ssize_t write(int, const void *, size_t);
@@ -73 +73 @@
 extern int unlink(const char *);
 
-extern char *getcwd(char *buf, size_t);
+extern char *getcwd(char *, size_t);
 extern int rmdir(const char *);
 extern int chdir(const char *);

uspace/lib/clui/tinput.h

@@ -37 +37 @@
 #define LIBCLUI_TINPUT_H_
 
-#include <adt/list.h>
-#include <async.h>
 #include <inttypes.h>
 #include <io/console.h>

uspace/lib/drv/generic/logbuf.c

@@ -35 +35 @@
 #include <ddf/log.h>
 #include <assert.h>
+#include <unistd.h>
 
 /** Formatting string for printing number of not-printed items. */

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

@@ -36 +36 @@
 #define DDF_INTERRUPT_H_
 
+#include <libarch/common.h>
+#include <libarch/types.h>
 #include <abi/ddi/irq.h>
 #include <adt/list.h>

uspace/lib/posix/Makefile

@@ -43 +43 @@
         fcntl.c \
         fnmatch.c \
+        getopt.c \
         locale.c \
         math.c \

uspace/lib/posix/errno.h

@@ -66 +66 @@
 #undef errno
 #define errno (*__posix_errno())
+
+#include "unistd.h"
 
 extern int *__posix_errno(void);

uspace/lib/posix/pwd.c

@@ -38 +38 @@
 #include "string.h"
 #include "errno.h"
+#include "assert.h"
 
 static bool entry_read = false;

uspace/lib/posix/stdbool.h

@@ -37 +37 @@
 
 #ifdef LIBC_BOOL_H_
-        #error "You can't include bool.h and stdbool.h at the same time."
+#if (!defined(POSIX_STDIO_H_)) \
+                && (!defined(POSIX_STDLIB_H_)) \
+                && (!defined(POSIX_STRING_H_))
+#error "You can't include bool.h and stdbool.h at the same time."
 #endif
+#endif
+
 #define LIBC_BOOL_H_
 

uspace/lib/posix/stdio.h

@@ -37 +37 @@
 #define POSIX_STDIO_H_
 
+#include "stddef.h"
+#include "unistd.h"
 #include "libc/stdio.h"
 #include "sys/types.h"

uspace/lib/posix/time.c

@@ -45 +45 @@
 #include "errno.h"
 #include "signal.h"
+#include "assert.h"
 
 #include "libc/malloc.h"

uspace/lib/posix/unistd.c

@@ -49 +49 @@
 /* Array of environment variable strings (NAME=VALUE). */
 char **posix_environ = NULL;
+char *posix_optarg;
 
 /**

uspace/lib/posix/unistd.h

@@ -43 +43 @@
 #define _exit exit
 
-/* Option Arguments */
-extern char *optarg;
+extern char *posix_optarg;
 extern int optind, opterr, optopt;
-extern int getopt(int, char * const [], const char *);
+extern int posix_getopt(int, char * const [], const char *);
 
 /* Environment */
@@ -144 +143 @@
 
 #ifndef LIBPOSIX_INTERNAL
+        #define getopt posix_getopt
+        #define optarg posix_optarg
+
         #define environ posix_environ
 

uspace/srv/fs/fat/fat_dentry.c

@@ -43 +43 @@
 #include <byteorder.h>
 #include <assert.h>
+#include <unistd.h>
 
 /** Compare path component with the name read from the dentry.