Changeset 46c20c8 in mainline for uspace/app/bdsh/cmds


Ignore:
Timestamp:
2010-11-26T20:08:10Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
45df59a
Parents:
fb150d78 (diff), ffdd2b9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
uspace/app/bdsh/cmds
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/cmds/builtin_cmds.c

    rfb150d78 r46c20c8  
    3434#include <stdio.h>
    3535#include <stdlib.h>
    36 #include <string.h>
     36#include <str.h>
    3737#include "errors.h"
    3838#include "cmds.h"

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

    rfb150d78 r46c20c8  
    1010#include "cd/cd_def.h"
    1111#include "exit/exit_def.h"
    12         {NULL, NULL, NULL, NULL}
     12        {NULL, NULL, NULL, NULL, 0}
    1313};
    1414

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

    rfb150d78 r46c20c8  
    3232#include <stdlib.h>
    3333#include <unistd.h>
    34 #include <string.h>
     34#include <str.h>
    3535#include <errno.h>
    3636
    … …  
    4141#include "cd.h"
    4242
    43 static char * cmdname = "cd";
     43static const char *cmdname = "cd";
    4444
    4545void help_cmd_cd(unsigned int level)

  • uspace/app/bdsh/cmds/builtins/cd/cd_def.h

    rfb150d78 r46c20c8  
    44        &cmd_cd,
    55        &help_cmd_cd,
     6        0
    67},

  • uspace/app/bdsh/cmds/builtins/exit/exit_def.h

    rfb150d78 r46c20c8  
    44        &cmd_exit,
    55        &help_cmd_exit,
     6        0
    67},

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

    rfb150d78 r46c20c8  
    3333/* Module structure */
    3434typedef struct {
    35         char *name;         /* Name of the command */
    36         char *desc;         /* Description of the command */
     35        const char *name;   /* Name of the command */
     36        const char *desc;   /* Description of the command */
    3737        mod_entry_t entry;  /* Command (exec) entry function */
    3838        mod_help_t help;    /* Command (help) entry function */
    … …  
    4141/* Builtin structure, same as modules except different types of entry points */
    4242typedef struct {
    43         char *name;
    44         char *desc;
     43        const char *name;
     44        const char *desc;
    4545        builtin_entry_t entry;
    4646        builtin_help_t help;
    … …  
    5757extern int is_module(const char *);
    5858extern int is_module_alias(const char *);
    59 extern char * alias_for_module(const char *);
     59extern char *alias_for_module(const char *);
    6060extern int help_module(int, unsigned int);
    6161extern int run_module(int, char *[]);
    … …  
    6565extern int is_builtin(const char *);
    6666extern int is_builtin_alias(const char *);
    67 extern char * alias_for_builtin(const char *);
     67extern char *alias_for_builtin(const char *);
    6868extern int help_builtin(int, unsigned int);
    6969extern int run_builtin(int, char *[], cliuser_t *);

  • uspace/app/bdsh/cmds/mod_cmds.c

    rfb150d78 r46c20c8  
    4747#include <stdio.h>
    4848#include <stdlib.h>
    49 #include <string.h>
     49#include <str.h>
    5050#include "errors.h"
    5151#include "cmds.h"

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

    rfb150d78 r46c20c8  
    2929#include <stdio.h>
    3030#include <stdlib.h>
    31 #include <string.h>
     31#include <str.h>
     32#include <sys/typefmt.h>
    3233#include "config.h"
    3334#include "util.h"
    … …  
    6869        unsigned int argc;
    6970        unsigned int i, j;
    70         dev_handle_t handle;
     71        devmap_handle_t handle;
    7172        uint8_t *blk;
    7273        size_t size, bytes, rows;
    7374        size_t block_size;
    7475        int rc;
    75         bn_t ba;
     76        aoff64_t ba;
    7677        uint8_t b;
    7778
    … …  
    122123                rc = block_read_direct(handle, ba, 1, blk);
    123124                if (rc != EOK) {
    124                         printf("%s: Error reading block %llu\n", cmdname, ba);
     125                        printf("%s: Error reading block %" PRIuOFF64 "\n", cmdname, ba);
    125126                        free(blk);
    126127                        block_fini(handle);

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

    rfb150d78 r46c20c8  
    3333#include <unistd.h>
    3434#include <getopt.h>
    35 #include <string.h>
     35#include <str.h>
    3636#include <fcntl.h>
    3737
    … …  
    4343#include "cmds.h"
    4444
    45 static char *cmdname = "cat";
     45static const char *cmdname = "cat";
    4646#define CAT_VERSION "0.0.1"
    4747#define CAT_DEFAULT_BUFLEN 1024
    4848
    49 static char *cat_oops = "That option is not yet supported\n";
     49static const char *cat_oops = "That option is not yet supported\n";
    5050
    5151static struct option const long_options[] = {
    … …  
    8585{
    8686        int fd, bytes = 0, count = 0, reads = 0;
    87         off_t total = 0;
     87        off64_t total = 0;
    8888        char *buff = NULL;
    8989

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

    rfb150d78 r46c20c8  
    3333#include <unistd.h>
    3434#include <getopt.h>
    35 #include <string.h>
     35#include <str.h>
    3636#include <fcntl.h>
    3737#include "config.h"
    … …  
    7474{
    7575        int fd1, fd2, bytes = 0;
    76         off_t total = 0;
     76        off64_t total = 0;
    7777        int64_t copied = 0;
    7878        char *buff = NULL;
    … …  
    9595
    9696        if (vb)
    97                 printf("%d bytes to copy\n", total);
     97                printf("%" PRIu64 " bytes to copy\n", total);
    9898
    9999        lseek(fd1, 0, SEEK_SET);
    … …  
    130130                 */
    131131                if (res != 0) {
    132                         printf("\n%d more bytes than actually exist were copied\n", res);
     132                        printf("\n%zd more bytes than actually exist were copied\n", res);
    133133                        goto err;
    134134                }
    … …  
    187187                        return CMD_SUCCESS;
    188188                case 'v':
    189                         printf("%d\n", CP_VERSION);
     189                        printf("%s\n", CP_VERSION);
    190190                        return CMD_SUCCESS;
    191191                case 'V':
    … …  
    223223
    224224        if (verbose)
    225                 printf("%d bytes copied\n", ret);
     225                printf("%" PRId64 " bytes copied\n", ret);
    226226
    227227        if (ret >= 0)

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

    rfb150d78 r46c20c8  
    3131#include <stdio.h>
    3232#include <stdlib.h>
    33 #include <string.h>
     33#include <str.h>
    3434
    3535#include "config.h"
    … …  
    4242#include "util.h"
    4343
    44 static char *cmdname = "help";
     44static const char *cmdname = "help";
    4545extern const char *progname;
    4646
    47 #define HELP_IS_MODULE   1
    48 #define HELP_IS_BUILTIN  0
    49 #define HELP_IS_RUBBISH  -1
     47#define HELP_IS_COMMANDS        2
     48#define HELP_IS_MODULE          1
     49#define HELP_IS_BUILTIN         0
     50#define HELP_IS_RUBBISH         -1
    5051
    5152volatile int mod_switch = -1;
    … …  
    5556{
    5657        int rc = HELP_IS_RUBBISH;
     58
     59        if (str_cmp(cmd, "commands") == 0)
     60                return HELP_IS_COMMANDS;
    5761
    5862        rc = is_builtin(cmd);
    … …  
    9094}
    9195
    92 int cmd_help(char *argv[])
     96static void help_commands(void)
    9397{
     98        builtin_t *cmd;
    9499        module_t *mod;
    95         builtin_t *cmd;
    96         unsigned int i = 0;
    97         int rc = 0;
    98         int argc;
    99         int level = HELP_SHORT;
     100        unsigned int i;
    100101
    101         argc = cli_count_args(argv);
    102 
    103         if (argc > 3) {
    104                 printf("\nToo many arguments to `%s', try:\n", cmdname);
    105                 help_cmd_help(HELP_SHORT);
    106                 return CMD_FAILURE;
    107         }
    108 
    109         if (argc == 3) {
    110                 if (!str_cmp("extended", argv[2]))
    111                         level = HELP_LONG;
    112                 else
    113                         level = HELP_SHORT;
    114         }
    115 
    116         if (argc > 1) {
    117                 rc = is_mod_or_builtin(argv[1]);
    118                 switch (rc) {
    119                 case HELP_IS_RUBBISH:
    120                         printf("Invalid command %s\n", argv[1]);
    121                         return CMD_FAILURE;
    122                 case HELP_IS_MODULE:
    123                         help_module(mod_switch, level);
    124                         return CMD_SUCCESS;
    125                 case HELP_IS_BUILTIN:
    126                         help_builtin(mod_switch, level);
    127                         return CMD_SUCCESS;
    128                 }
    129         }
    130 
    131         printf("\n  Available commands are:\n");
     102        printf("\n  Bdsh built-in commands:\n");
    132103        printf("  ------------------------------------------------------------\n");
    133104
    … …  
    154125        printf("\n  Try %s %s for more information on how `%s' works.\n\n",
    155126                cmdname, cmdname, cmdname);
     127}
     128
     129/** Display survival tips. ('help' without arguments) */
     130static void help_survival(void)
     131{
     132        printf("Don't panic!\n\n");
     133
     134        printf("This is Bdsh, the Brain dead shell, currently "
     135            "the primary user interface to HelenOS. Bdsh allows you to enter "
     136            "commands and supports history (Up, Down arrow keys), "
     137            "line editing (Left Arrow, Right Arrow, Home, End, Backspace), "
     138            "selection (Shift + movement keys), copy and paste (Ctrl-C, "
     139            "Ctrl-V), similar to common desktop environments.\n\n");
     140
     141        printf("The most basic filesystem commands are Bdsh builtins. Type "
     142            "'help commands' [Enter] to see the list of Bdsh builtin commands. "
     143            "Other commands are external executables located in the /app and "
     144            "/srv directories. Type 'ls /app' [Enter] and 'ls /srv' [Enter] "
     145            "to see their list. You can execute an external command simply "
     146            "by entering its name (e.g. type 'tetris' [Enter]).\n\n");
     147
     148        printf("HelenOS has virtual consoles (VCs). You can switch between "
     149            "these using the F1-F11 keys.\n\n");
     150
     151        printf("This is but a small glimpse of what you can do with HelenOS. "
     152            "To learn more please point your browser to the HelenOS User's "
     153            "Guide: http://trac.helenos.org/trac.fcgi/wiki/UsersGuide\n\n");
     154}
     155
     156int cmd_help(char *argv[])
     157{
     158        int rc = 0;
     159        int argc;
     160        int level = HELP_SHORT;
     161
     162        argc = cli_count_args(argv);
     163
     164        if (argc > 3) {
     165                printf("\nToo many arguments to `%s', try:\n", cmdname);
     166                help_cmd_help(HELP_SHORT);
     167                return CMD_FAILURE;
     168        }
     169
     170        if (argc == 3) {
     171                if (!str_cmp("extended", argv[2]))
     172                        level = HELP_LONG;
     173                else
     174                        level = HELP_SHORT;
     175        }
     176
     177        if (argc > 1) {
     178                rc = is_mod_or_builtin(argv[1]);
     179                switch (rc) {
     180                case HELP_IS_RUBBISH:
     181                        printf("Invalid topic %s\n", argv[1]);
     182                        return CMD_FAILURE;
     183                case HELP_IS_COMMANDS:
     184                        help_commands();
     185                        return CMD_SUCCESS;
     186                case HELP_IS_MODULE:
     187                        help_module(mod_switch, level);
     188                        return CMD_SUCCESS;
     189                case HELP_IS_BUILTIN:
     190                        help_builtin(mod_switch, level);
     191                        return CMD_SUCCESS;
     192                }
     193        }
     194
     195        help_survival();
    156196
    157197        return CMD_SUCCESS;

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

    rfb150d78 r46c20c8  
    4040#include "cmds.h"
    4141
    42 static char *cmdname = "kcon";
     42static const char *cmdname = "kcon";
    4343
    4444/* Dispays help for kcon in various levels */

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

    rfb150d78 r46c20c8  
    4040#include <sys/types.h>
    4141#include <sys/stat.h>
    42 #include <string.h>
     42#include <str.h>
    4343
    4444#include "errors.h"
    … …  
    4949#include "cmds.h"
    5050
    51 static char *cmdname = "ls";
     51static const char *cmdname = "ls";
    5252
    5353static void ls_scan_dir(const char *d, DIR *dirp)

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

    rfb150d78 r46c20c8  
    3838#include <getopt.h>
    3939#include <stdarg.h>
    40 #include <string.h>
     40#include <str.h>
    4141
    4242#include "config.h"
    … …  
    4949#define MKDIR_VERSION "0.0.1"
    5050
    51 static char *cmdname = "mkdir";
     51static const char *cmdname = "mkdir";
    5252
    5353static struct option const long_options[] = {

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

    rfb150d78 r46c20c8  
    3838#include <getopt.h>
    3939#include <stdarg.h>
    40 #include <string.h>
     40#include <str.h>
    4141#include <ctype.h>
    4242
    … …  
    5151#define BUFFER_SIZE 16384
    5252
    53 static char *cmdname = "mkfile";
     53static const char *cmdname = "mkfile";
    5454
    5555static struct option const long_options[] = {
    … …  
    168168                rc = write(fd, buffer, to_write);
    169169                if (rc <= 0) {
    170                         printf("%s: Error writing file (%d).\n", cmdname, rc);
     170                        printf("%s: Error writing file (%zd).\n", cmdname, rc);
    171171                        close(fd);
    172172                        return CMD_FAILURE;
    … …  
    177177        rc = close(fd);
    178178        if (rc != 0) {
    179                 printf("%s: Error writing file (%d).\n", cmdname, rc);
     179                printf("%s: Error writing file (%zd).\n", cmdname, rc);
    180180                return CMD_FAILURE;
    181181        }

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

    rfb150d78 r46c20c8  
    1212 * the entry point being reached. */
    1313
    14 char *mod_aliases[] = {
     14const char *mod_aliases[] = {
    1515        "ren", "mv",
    1616        "umount", "unmount",

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

    rfb150d78 r46c20c8  
    5858{
    5959        unsigned int argc;
    60         char *mopts = "";
     60        const char *mopts = "";
    6161        int rc;
    6262

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

    rfb150d78 r46c20c8  
    3939#include "pwd.h"
    4040
    41 static char * cmdname = "pwd";
     41static const char *cmdname = "pwd";
    4242
    4343void help_cmd_pwd(unsigned int level)

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

    rfb150d78 r46c20c8  
    3636#include <getopt.h>
    3737#include <mem.h>
    38 #include <string.h>
     38#include <str.h>
    3939
    4040#include "config.h"
    … …  
    4545#include "cmds.h"
    4646
    47 static char *cmdname = "rm";
     47static const char *cmdname = "rm";
    4848#define RM_VERSION "0.0.1"
    4949

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

    rfb150d78 r46c20c8  
    3838#include "cmds.h"
    3939
    40 static char *cmdname = "sleep";
     40static const char *cmdname = "sleep";
    4141
    4242/* Dispays help for sleep in various levels */

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

    rfb150d78 r46c20c8  
    3838#include <dirent.h>
    3939#include <sys/types.h>
    40 #include <string.h>
     40#include <str.h>
    4141
    4242#include "config.h"
    … …  
    4747#include "cmds.h"
    4848
    49 static char *cmdname = "touch";
     49static const char *cmdname = "touch";
    5050
    5151/* Dispays help for touch in various levels */

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

    rfb150d78 r46c20c8  
    4747        } else {
    4848                help_cmd_unmount(HELP_SHORT);
    49                 printf("Usage:  %s <mp>\n", cmdname);
     49                printf("Usage: %s <mp>\n", cmdname);
    5050        }
    5151        return;
    … …  
    6868        rc = unmount(argv[1]);
    6969        if (rc != EOK) {
    70                 printf("Unable to unmount %s (rc=%d)\n", argv[1]);
     70                printf("Unable to unmount %s (rc=%d)\n", argv[1], rc);
    7171                return CMD_FAILURE;
    7272        }
Note: See TracChangeset for help on using the changeset viewer.