Changes in / [ce683ed3:4b16422] in mainline


Ignore:
Files:
9 added
24 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/proc/program.c

    rce683ed3 r4b16422  
    127127       
    128128        unsigned int rc = elf_load((elf_header_t *) image_addr, as, 0);
     129        LOG("elf_load() -> %u\n", rc);
    129130        if (rc != EE_OK) {
    130131                as_destroy(as);

  • tools/checkers/clang.py

    rce683ed3 r4b16422  
    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

    rce683ed3 r4b16422  
    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

    rce683ed3 r4b16422  
    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

    rce683ed3 r4b16422  
    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

    rce683ed3 r4b16422  
    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 = long(sys.argv[1])
     41m = int(sys.argv[1])
    4242i = 0
    4343pow_2_64 = 2 ** 64

  • tools/mkfat.py

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

  • tools/mkuimage.py

    rce683ed3 r4b16422  
    124124        header.img_type = 2             # Kernel
    125125        header.compression = 0          # None
    126         header.img_name = image_name
     126        header.img_name = image_name.encode('ascii')
    127127
    128128        header_crc = calc_crc32(header.pack())
    … …  
    140140        signed_crc = zlib.crc32(byteseq, 0)
    141141        if signed_crc < 0:
    142                 return (long(signed_crc) + (long(2) ** long(32))) # 2^32L
     142                return signed_crc + (1 << 32)
    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

    rce683ed3 r4b16422  
    3232
    3333import struct
     34import sys
    3435import types
    3536
     37# Handle long integer conversions nicely in both Python 2 and Python 3
     38integer_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)
     42ensure_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
    3647ranges = {
    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),
     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),
    4556}
    4657
    … …  
    7485                                        args.append(item)
    7586                        else:
     87                                if (fmt == "s"):
     88                                        value = ensure_string(value)
    7689                                check_range(variable, fmt, value)
    7790                                args.append(value)             

  • uspace/app/bdsh/Makefile

    rce683ed3 r4b16422  
    4848        cmds/modules/cp/cp.c \
    4949        cmds/modules/mv/mv.c \
     50        cmds/modules/printf/printf.c \
     51        cmds/modules/echo/echo.c \
    5052        cmds/modules/mount/mount.c \
    5153        cmds/modules/unmount/unmount.c \

  • uspace/app/bdsh/TODO

    rce683ed3 r4b16422  
    3030* Add wrappers for signal, sigaction to make ports to modules easier
    3131
    32 * Add 'echo' and 'printf' modules.
    33 
    3432Regarding POSIX:
    3533----------------

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

    rce683ed3 r4b16422  
    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 */
     48static char previous_directory[PATH_MAX] = "";
     49static char previous_directory_tmp[PATH_MAX];
     50static bool previous_directory_valid = true;
     51static bool previous_directory_set = false;
     52
     53static 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
    4368void help_cmd_cd(unsigned int level)
    4469{
    … …  
    5580}
    5681
     82
    5783/* This is a very rudamentary 'cd' command. It is not 'link smart' (yet) */
    5884
    … …  
    6288
    6389        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        }
    64101
    65102        /* We don't yet play nice with whitespace, a getopt implementation should
    … …  
    79116        }
    80117
    81         /* We have the correct # of arguments
    82      * TODO: handle tidle (~) expansion? */
     118        /* We have the correct # of arguments */
     119        // TODO: handle tidle (~) expansion? */
    83120
    84         rc = chdir(argv[1]);
     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        }
    85141
    86142        if (rc == 0) {
    … …  
    93149                        break;
    94150                case ENOENT:
    95                         cli_error(CL_ENOENT, "Invalid directory `%s'", argv[1]);
     151                        cli_error(CL_ENOENT, "Invalid directory `%s'", target_directory);
    96152                        break;
    97153                default:
    98                         cli_error(CL_EFAIL, "Unable to change to `%s'", argv[1]);
     154                        cli_error(CL_EFAIL, "Unable to change to `%s'", target_directory);
    99155                        break;
    100156                }

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

    rce683ed3 r4b16422  
    44/* Prototypes for the cat command, excluding entry points */
    55
    6 static unsigned int cat_file(const char *, size_t, bool, off64_t, off64_t, bool);
    7 
    86#endif /* CAT_H */
    97

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

    rce683ed3 r4b16422  
    3030#include <stdlib.h>
    3131#include <unistd.h>
     32#include <io/console.h>
     33#include <io/keycode.h>
    3234#include <getopt.h>
    3335#include <str.h>
    … …  
    4648
    4749static const char *cmdname = "cp";
     50static console_ctrl_t *con;
    4851
    4952static struct option const long_options[] = {
    5053        { "buffer", required_argument, 0, 'b' },
    5154        { "force", no_argument, 0, 'f' },
     55        { "interactive", no_argument, 0, 'i'},
    5256        { "recursive", no_argument, 0, 'r' },
    5357        { "help", no_argument, 0, 'h' },
    … …  
    139143}
    140144
     145static 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
    141178static int64_t do_copy(const char *src, const char *dest,
    142     size_t blen, int vb, int recursive, int force)
     179    size_t blen, int vb, int recursive, int force, int interactive)
    143180{
    144181        int r = -1;
    … …  
    192229                        /* e.g. cp file_name existing_file */
    193230
    194                         /* dest already exists, if force is set we will
    195                          * try to remove it.
     231                        /* dest already exists,
     232                         * if force is set we will try to remove it.
     233                         * if interactive is set user input is required.
    196234                         */
    197                         if (force) {
     235                        if (force && !interactive) {
    198236                                if (unlink(dest_path)) {
    199237                                        printf("Unable to remove %s\n",
    … …  
    201239                                        goto exit;
    202240                                }
     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                                }
    203256                        } else {
    204                                 printf("file already exists: %s\n", dest_path);
     257                                printf("File already exists: %s\n", dest_path);
    205258                                goto exit;
    206259                        }
    … …  
    302355                        /* Recursively call do_copy() */
    303356                        r = do_copy(src_dent, dest_dent, blen, vb, recursive,
    304                             force);
     357                            force, interactive);
    305358                        if (r)
    306359                                goto exit;
    … …  
    315368        return r;
    316369}
    317 
    318370
    319371static int64_t copy_file(const char *src, const char *dest,
    … …  
    380432            "  -v, --version    Print version information and exit\n"
    381433            "  -V, --verbose    Be annoyingly noisy about what's being done\n"
    382             "  -f, --force      Do not complain when <dest> exists\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"
    383436            "  -r, --recursive  Copy entire directories\n"
    384437            "  -b, --buffer ## Set the read buffer size to ##\n";
    … …  
    397450        unsigned int argc, verbose = 0;
    398451        int buffer = 0, recursive = 0;
    399         int force = 0;
     452        int force = 0, interactive = 0;
    400453        int c, opt_ind;
    401454        int64_t ret;
    402455
     456        con = console_init(stdin, stdout);
    403457        argc = cli_count_args(argv);
    404458
    405459        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    406                 c = getopt_long(argc, argv, "hvVfrb:", long_options, &opt_ind);
     460                c = getopt_long(argc, argv, "hvVfirb:", long_options, &opt_ind);
    407461                switch (c) {
    408462                case 'h':
    … …  
    416470                        break;
    417471                case 'f':
     472                        interactive = 0;
    418473                        force = 1;
     474                        break;
     475                case 'i':
     476                        force = 0;
     477                        interactive = 1;
    419478                        break;
    420479                case 'r':
    … …  
    426485                                    "(should be a number greater than zero)\n",
    427486                                    cmdname);
     487                                console_done(con);
    428488                                return CMD_FAILURE;
    429489                        }
    … …  
    442502                printf("%s: invalid number of arguments. Try %s --help\n",
    443503                    cmdname, cmdname);
     504                console_done(con);
    444505                return CMD_FAILURE;
    445506        }
    446507
    447508        ret = do_copy(argv[optind], argv[optind + 1], buffer, verbose,
    448             recursive, force);
     509            recursive, force, interactive);
     510
     511        console_done(con);
    449512
    450513        if (ret == 0)

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

    rce683ed3 r4b16422  
    33
    44/* Prototypes for the help command (excluding entry points) */
    5 static int is_mod_or_builtin(char *);
    65
    76#endif

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

    rce683ed3 r4b16422  
    3636#include <stdarg.h>
    3737#include <str.h>
     38#include <errno.h>
     39#include <str_error.h>
     40#include <vfs/vfs.h>
    3841
    3942#include "config.h"
    … …  
    8386/* This is kind of clunky, but effective for now */
    8487static unsigned int
    85 create_directory(const char *path, unsigned int p)
     88create_directory(const char *user_path, bool create_parents)
    8689{
    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))) {
     90        /* Ensure we would always work with absolute and canonified path. */
     91        char *path = absolutize(user_path, NULL);
     92        if (path == NULL) {
    9593                cli_error(CL_ENOMEM, "%s: path too big?", cmdname);
    9694                return 1;
    9795        }
    9896
    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;
     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                }
    143107        } else {
    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 ++;
     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)) {
    169114                                break;
    170115                        }
    171                 }
    172                 i++;
    173         }
    174         goto finit;
    175 
    176 finit:
    177         free(wdp);
    178         free(tmp);
     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
     162leave:
     163        free(path);
    179164        return ret;
    180165}
    … …  
    182167int cmd_mkdir(char **argv)
    183168{
    184         unsigned int argc, create_parents = 0, i, ret = 0, follow = 0;
    185         unsigned int verbose = 0;
     169        unsigned int argc, i, ret = 0;
     170        bool create_parents = false, follow = false, verbose = false;
    186171        int c, opt_ind;
    187         char *cwd;
    188172
    189173        argc = cli_count_args(argv);
    … …  
    193177                switch (c) {
    194178                case 'p':
    195                         create_parents = 1;
     179                        create_parents = true;
    196180                        break;
    197181                case 'v':
    198                         verbose = 1;
     182                        verbose = true;
    199183                        break;
    200184                case 'h':
    … …  
    205189                        return CMD_SUCCESS;
    206190                case 'f':
    207                         follow = 1;
     191                        follow = true;
    208192                        break;
    209193                case 'm':
    … …  
    221205        }
    222206
    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 
    231207        for (i = optind; argv[i] != NULL; i++) {
    232                 if (verbose == 1)
     208                if (verbose)
    233209                        printf("%s: creating %s%s\n",
    234210                                cmdname, argv[i],
    … …  
    237213        }
    238214
    239         if (follow == 0)
    240                 chdir(cwd);
    241 
    242         free(cwd);
     215        if (follow && (argv[optind] != NULL)) {
     216                chdir(argv[optind]);
     217        }
    243218
    244219        if (ret)

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

    rce683ed3 r4b16422  
    44/* Prototypes for the mkdir command, excluding entry points */
    55
    6 static unsigned int create_directory(const char *, unsigned int);
    76#endif /* MKDIR_H */
    87

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

    rce683ed3 r4b16422  
    6161#include "unmount/entry.h"
    6262#include "kcon/entry.h"
     63#include "printf/entry.h"
     64#include "echo/entry.h"
    6365
    6466/* Each .def function fills the module_t struct with the individual name, entry
    … …  
    8284#include "unmount/unmount_def.h"
    8385#include "kcon/kcon_def.h"
     86#include "printf/printf_def.h"
     87#include "echo/echo_def.h"
    8488
    8589        {NULL, NULL, NULL, NULL}

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

    rce683ed3 r4b16422  
    4646#define RM_VERSION "0.0.1"
    4747
    48 static rm_job_t rm;
    49 
    5048static struct option const long_options[] = {
    5149        { "help", no_argument, 0, 'h' },
    … …  
    5755};
    5856
     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 */
     69typedef 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
     87static rm_job_t rm;
     88
     89static unsigned int rm_recursive(const char *);
     90
    5991static unsigned int rm_start(rm_job_t *rm)
    6092{
    … …  
    95127        if (NULL != rm->cwd)
    96128                free(rm->cwd);
     129}
     130
     131static 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
     140static 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;
    97158}
    98159
    … …  
    154215
    155216        return ret + 1;
    156 }
    157 
    158 static 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 
    167 static 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;
    185217}
    186218

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

    rce683ed3 r4b16422  
    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 */
    16 typedef 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 
    354/* Prototypes for the rm command, excluding entry points */
    36 static unsigned int rm_start(rm_job_t *);
    37 static void rm_end(rm_job_t *rm);
    38 static unsigned int rm_recursive(const char *);
    39 static unsigned int rm_single(const char *);
    40 static unsigned int rm_scope(const char *);
    415
    426#endif /* RM_H */

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

    rce683ed3 r4b16422  
    2727 */
    2828
     29#include <errno.h>
    2930#include <stdio.h>
    3031#include <stdlib.h>
     32#include <unistd.h>
    3133#include "config.h"
    3234#include "util.h"
    … …  
    4143void help_cmd_sleep(unsigned int level)
    4244{
    43         printf("This is the %s help for '%s'.\n",
    44                 level ? EXT_HELP : SHORT_HELP, cmdname);
     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
    4555        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 */
     64static 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;
    46109}
    47110
    … …  
    49112int cmd_sleep(char **argv)
    50113{
     114        int ret;
    51115        unsigned int argc;
    52         unsigned int i;
     116        useconds_t duration;
    53117
    54118        /* Count the arguments */
    55         for (argc = 0; argv[argc] != NULL; argc ++);
     119        argc = cli_count_args(argv);
    56120
    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;
     121        if (argc != 2) {
     122                printf("%s - incorrect number of arguments. Try `help %s'\n",
     123                    cmdname, cmdname);
     124                return CMD_FAILURE;
    63125        }
    64126
    65         printf(":\n");
    66         for (i = 1; i < argc; i++)
    67                 printf("[%d] -> %s\n", i, argv[i]);
     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);
    68134
    69135        return CMD_SUCCESS;

  • uspace/app/edit/edit.c

    rce683ed3 r4b16422  
    118118static void key_handle_ctrl(kbd_event_t const *ev);
    119119static void key_handle_shift(kbd_event_t const *ev);
     120static void key_handle_shift_ctrl(kbd_event_t const *ev);
    120121static void key_handle_movement(unsigned int key, bool shift);
    121122
    … …  
    139140static void caret_update(void);
    140141static void caret_move(int drow, int dcolumn, enum dir_spec align_dir);
     142static void caret_move_word_left(void);
     143static void caret_move_word_right(void);
    141144
    142145static bool selection_active(void);
    143146static void selection_sel_all(void);
     147static void selection_sel_range(spt_t pa, spt_t pb);
     148static void selection_sel_prev_word(void);
     149static void selection_sel_next_word(void);
    144150static void selection_get_points(spt_t *pa, spt_t *pb);
    145151static void selection_delete(void);
    … …  
    149155static void pt_get_sof(spt_t *pt);
    150156static void pt_get_eof(spt_t *pt);
     157static void pt_get_sol(spt_t *cpt, spt_t *spt);
     158static void pt_get_eol(spt_t *cpt, spt_t *ept);
     159static bool pt_is_word_beginning(spt_t *pt);
     160static bool pt_is_delimiter(spt_t *pt);
     161static bool pt_is_punctuation(spt_t *pt);
    151162static int tag_cmp(tag_t const *a, tag_t const *b);
    152163static int spt_cmp(spt_t const *a, spt_t const *b);
    … …  
    232243                             (ev.mods & KM_SHIFT) != 0) {
    233244                                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);
    234249                        } else if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
    235250                                key_handle_unmod(&ev);
    … …  
    376391        case KC_A:
    377392                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
     411static 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();
    378419                break;
    379420        default:
    … …  
    9701011        /* Clamp coordinates. */
    9711012        if (drow < 0 && coord.row < 1) coord.row = 1;
    972         if (dcolumn < 0 && coord.column < 1) coord.column = 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        }
    9731021        if (drow > 0) {
    9741022                sheet_get_num_rows(&doc.sh, &num_rows);
    … …  
    9981046}
    9991047
     1048static 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
     1064static 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
    10001080/** Check for non-empty selection. */
    10011081static bool selection_active(void)
    … …  
    10451125}
    10461126
     1127/** Select all text in the editor */
    10471128static void selection_sel_all(void)
    10481129{
    … …  
    10511132        pt_get_sof(&spt);
    10521133        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 */
     1139static void selection_sel_range(spt_t pa, spt_t pb)
     1140{
    10531141        sheet_remove_tag(&doc.sh, &pane.sel_start);
    1054         sheet_place_tag(&doc.sh, &spt, &pane.sel_start);
     1142        sheet_place_tag(&doc.sh, &pa, &pane.sel_start);
    10551143        sheet_remove_tag(&doc.sh, &pane.caret_pos);
    1056         sheet_place_tag(&doc.sh, &ept, &pane.caret_pos);
     1144        sheet_place_tag(&doc.sh, &pb, &pane.caret_pos);
    10571145
    10581146        pane.rflags |= REDRAW_TEXT;
    10591147        caret_update();
     1148}
     1149
     1150/** Add the previous word to the selection */
     1151static 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 */
     1168static 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);
    10601182}
    10611183
    … …  
    11171239
    11181240        sheet_get_cell_pt(&doc.sh, &coord, dir_after, pt);
     1241}
     1242
     1243/** Get start-of-line s-point for given s-point cpt */
     1244static 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 */
     1255static 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 */
     1268static 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
     1297static 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
     1303static 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
     1329static 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        }
    11191365}
    11201366

  • uspace/app/edit/sheet.c

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

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

    rce683ed3 r4b16422  
    5858#define getpagesize()  (PAGE_SIZE)
    5959
    60 extern int dup2(int oldfd, int newfd);
     60extern int dup2(int, int);
    6161
    6262extern ssize_t write(int, const void *, size_t);
    … …  
    7373extern int unlink(const char *);
    7474
    75 extern char *getcwd(char *buf, size_t);
     75extern char *getcwd(char *, size_t);
    7676extern int rmdir(const char *);
    7777extern int chdir(const char *);
Note: See TracChangeset for help on using the changeset viewer.