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

Changeset b781cc49 in mainline


Ignore:
Timestamp:
2019-07-05T18:37:31Z (16 months ago)
Author:
GitHub <noreply@…>
Branches:
master
Children:
fa603e99
Parents:
53afa639 (diff), 46288ee (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.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2019-07-05 18:37:31)
git-committer:
GitHub <noreply@…> (2019-07-05 18:37:31)
Message:

Merge pull request #135 from matthieuriolo/bdsh_alias

Implements alias/unalias commands in bdsh.

Location:
uspace/app/bdsh
Files:
8 added
8 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/bdsh/Makefile

    r53afa639 rb781cc49  
    3636        cmds/modules/module_aliases.c \
    3737        cmds/modules/modules.c \
     38        cmds/modules/alias/alias.c \
     39        cmds/modules/unalias/unalias.c \
    3840        cmds/modules/help/help.c \
    3941        cmds/modules/mkdir/mkdir.c \
  • uspace/app/bdsh/cmds/modules/modules.c

    r53afa639 rb781cc49  
    6363#include "echo/entry.h"
    6464#include "cmp/entry.h"
     65#include "alias/entry.h"
     66#include "unalias/entry.h"
    6567
    6668/*
     
    8890#include "echo/echo_def.inc"
    8991#include "cmp/cmp_def.inc"
     92#include "alias/alias_def.inc"
     93#include "unalias/unalias_def.inc"
    9094
    9195        { NULL, NULL, NULL, NULL }
  • uspace/app/bdsh/cmds/modules/modules.h

    r53afa639 rb781cc49  
    3131
    3232#include "../cmds.h"
    33 #include "modules.h"
    3433
    3534extern module_t modules[];
  • uspace/app/bdsh/compl.c

    r53afa639 rb781cc49  
    3535#include <vfs/vfs.h>
    3636#include <str.h>
    37 
     37#include <adt/odict.h>
     38
     39#include "scli.h"
    3840#include "cmds/cmds.h"
    3941#include "compl.h"
     
    6365        /** Length of string prefix (number of characters) */
    6466        size_t prefix_len;
     67
     68        /* Pointer to the current alias */
     69        odlink_t *alias_link;
    6570
    6671        /** Pointer inside list of modules */
     
    243248        } else if (cs->is_command) {
    244249                /* Command without path */
     250                cs->alias_link = odict_first(&alias_dict);
    245251                cs->module = modules;
    246252                cs->builtin = builtins;
     
    321327        }
    322328
     329        /* Alias */
     330        if (cs->alias_link != NULL) {
     331                while (*compl == NULL && cs->alias_link != NULL) {
     332                        alias_t *data = odict_get_instance(cs->alias_link, alias_t, odict);
     333                        if (compl_match_prefix(cs, data->name)) {
     334                                asprintf(compl, "%s ", data->name);
     335                                cs->last_compl = *compl;
     336                                if (*compl == NULL)
     337                                        return ENOMEM;
     338                        }
     339                        cs->alias_link = odict_next(cs->alias_link, &alias_dict);
     340                }
     341        }
     342
    323343        /* Modules */
    324344        if (cs->module != NULL) {
    325345                while (*compl == NULL && cs->module->name != NULL) {
     346                        /* prevents multiple listing of an overriden cmd */
    326347                        if (compl_match_prefix(cs, cs->module->name)) {
    327                                 asprintf(compl, "%s ", cs->module->name);
    328                                 cs->last_compl = *compl;
    329                                 if (*compl == NULL)
    330                                         return ENOMEM;
     348                                odlink_t *alias_link = odict_find_eq(&alias_dict, (void *)cs->module->name, NULL);
     349                                if (alias_link == NULL) {
     350                                        asprintf(compl, "%s ", cs->module->name);
     351                                        cs->last_compl = *compl;
     352                                        if (*compl == NULL)
     353                                                return ENOMEM;
     354                                }
    331355                        }
    332356                        cs->module++;
     
    338362                while (*compl == NULL && cs->builtin->name != NULL) {
    339363                        if (compl_match_prefix(cs, cs->builtin->name)) {
    340                                 asprintf(compl, "%s ", cs->builtin->name);
    341                                 cs->last_compl = *compl;
    342                                 if (*compl == NULL)
    343                                         return ENOMEM;
     364                                /* prevents multiple listing of an overriden cmd */
     365                                odlink_t *alias_link = odict_find_eq(&alias_dict, (void *)cs->module->name, NULL);
     366                                if (alias_link == NULL) {
     367                                        asprintf(compl, "%s ", cs->builtin->name);
     368                                        cs->last_compl = *compl;
     369                                        if (*compl == NULL)
     370                                                return ENOMEM;
     371                                }
    344372                        }
    345373                        cs->builtin++;
     
    389417                                free(ent_path);
    390418
     419                                /* prevents multiple listing of an overriden cmd */
     420                                if (cs->is_command && !ent_stat.is_directory) {
     421                                        odlink_t *alias_link = odict_find_eq(&alias_dict, (void *)dent->d_name, NULL);
     422                                        if (alias_link != NULL) {
     423                                                continue;
     424                                        }
     425                                }
     426
    391427                                asprintf(compl, "%s%c", dent->d_name,
    392428                                    ent_stat.is_directory ? '/' : ' ');
  • uspace/app/bdsh/config.h

    r53afa639 rb781cc49  
    4242#endif
    4343
     44/* define maximal nested aliases */
     45#ifndef HUBS_MAX
     46#define HUBS_MAX 20
     47#endif
     48
    4449/* Used in many places */
    4550#define SMALL_BUFLEN 256
  • uspace/app/bdsh/input.c

    r53afa639 rb781cc49  
    33 * Copyright (c) 2011 Jiri Svoboda
    44 * Copyright (c) 2011 Martin Sucha
     5 * Copyright (c) 2018 Matthieu Riolo
    56 * All rights reserved.
    67 *
     
    4344#include <stdbool.h>
    4445#include <tinput.h>
     46#include <adt/odict.h>
     47#include <adt/list.h>
    4548
    4649#include "config.h"
     
    6265static void print_pipe_usage(void);
    6366
     67typedef struct {
     68        link_t alias_hup_link;
     69        alias_t *alias;
     70} alias_hup_t;
     71
     72static bool find_alias_hup(alias_t *alias, list_t *alias_hups)
     73{
     74        list_foreach(*alias_hups, alias_hup_link, alias_hup_t, link) {
     75                if (alias == link->alias) {
     76                        return true;
     77                }
     78        }
     79
     80        return false;
     81}
     82
    6483/*
    6584 * Tokenizes input from console, sees if the first word is a built-in, if so
     
    6786 * the handler
    6887 */
    69 errno_t process_input(cliuser_t *usr)
    70 {
     88static errno_t process_input_nohup(cliuser_t *usr, list_t *alias_hups, size_t count_executed_hups)
     89{
     90        if (count_executed_hups >= HUBS_MAX) {
     91                cli_error(CL_EFAIL, "%s: maximal alias hubs reached\n", PACKAGE_NAME);
     92                return ELIMIT;
     93        }
     94
    7195        token_t *tokens_buf = calloc(WORD_MAX, sizeof(token_t));
    7296        if (tokens_buf == NULL)
     
    171195        }
    172196
     197        /* test if the passed cmd is an alias */
     198        odlink_t *alias_link = odict_find_eq(&alias_dict, (void *)cmd[0], NULL);
     199        if (alias_link != NULL) {
     200                alias_t *data = odict_get_instance(alias_link, alias_t, odict);
     201                /* check if the alias already has been resolved once */
     202                if (!find_alias_hup(data, alias_hups)) {
     203                        alias_hup_t *hup = (alias_hup_t *)calloc(1, sizeof(alias_hup_t));
     204                        if (hup == NULL) {
     205                                cli_error(CL_EFAIL, "%s: cannot allocate alias structure\n", PACKAGE_NAME);
     206                                rc = ENOMEM;
     207                                goto finit;
     208                        }
     209
     210                        hup->alias = data;
     211                        list_append(&hup->alias_hup_link, alias_hups);
     212
     213                        char *oldLine = usr->line;
     214                        const size_t input_length = str_size(usr->line) - str_size(cmd[0]) + str_size(data->value) + 1;
     215                        usr->line = (char *)malloc(input_length);
     216                        if (usr->line == NULL) {
     217                                cli_error(CL_EFAIL, "%s: cannot allocate input structure\n", PACKAGE_NAME);
     218                                rc = ENOMEM;
     219                                goto finit;
     220                        }
     221
     222                        usr->line[0] = '\0';
     223
     224                        unsigned int cmd_replace_index = cmd_token_start;
     225                        for (i = 0; i < tokens_length; i++) {
     226                                if (i == cmd_replace_index) {
     227                                        /* if there is a pipe symbol than cmd_token_start will point at the SPACE after the pipe symbol */
     228                                        if (tokens[i].type == TOKTYPE_SPACE) {
     229                                                cmd_replace_index++;
     230                                                str_append(usr->line, input_length, tokens[i].text);
     231                                                continue;
     232                                        }
     233
     234                                        str_append(usr->line, input_length, data->value);
     235                                } else {
     236                                        str_append(usr->line, input_length, tokens[i].text);
     237                                }
     238                        }
     239
     240                        /* reprocess input after string replace */
     241                        rc = process_input_nohup(usr, alias_hups, count_executed_hups + 1);
     242                        usr->line = oldLine;
     243                        goto finit;
     244                }
     245        }
     246
    173247        iostate_t new_iostate = {
    174248                .stdin = stdin,
     
    225299}
    226300
     301errno_t process_input(cliuser_t *usr)
     302{
     303        list_t alias_hups;
     304        list_initialize(&alias_hups);
     305
     306        errno_t rc = process_input_nohup(usr, &alias_hups, 0);
     307
     308        list_foreach_safe(alias_hups, cur_link, next_link) {
     309                alias_hup_t *cur_item = list_get_instance(cur_link, alias_hup_t, alias_hup_link);
     310                free(cur_item);
     311        }
     312
     313        return rc;
     314}
     315
    227316void print_pipe_usage(void)
    228317{
  • uspace/app/bdsh/scli.c

    r53afa639 rb781cc49  
    11/*
    22 * Copyright (c) 2008 Tim Post
     3 * Copyright (c) 2018 Matthieu Riolo
    34 * All rights reserved.
    45 *
     
    3132#include <stddef.h>
    3233#include <str.h>
     34#include <adt/odict.h>
    3335#include "config.h"
    3436#include "scli.h"
     
    4244static iostate_t *iostate;
    4345static iostate_t stdiostate;
     46
     47odict_t alias_dict;
    4448
    4549/*
     
    5559 */
    5660const char *progname = PACKAGE_NAME;
     61
     62static int alias_cmp(void *a, void *b)
     63{
     64        return str_cmp((char *)a, (char *)b);
     65}
     66
     67static void *alias_key(odlink_t *odlink)
     68{
     69        return (void *)odict_get_instance(odlink, alias_t, odict)->name;
     70}
    5771
    5872/* These are not exposed, even to builtins */
     
    108122        iostate = &stdiostate;
    109123
     124        odict_initialize(&alias_dict, alias_key, alias_cmp);
     125
    110126        if (cli_init(&usr))
    111127                exit(EXIT_FAILURE);
  • uspace/app/bdsh/scli.h

    r53afa639 rb781cc49  
    11/*
    22 * Copyright (c) 2008 Tim Post
     3 * Copyright (c) 2018 Matthieu Riolo
    34 * All rights reserved.
    45 *
     
    3435#include <stdint.h>
    3536#include <stdio.h>
     37#include <types/adt/odict.h>
    3638
    3739typedef struct {
     
    5456extern void set_iostate(iostate_t *);
    5557
     58extern odict_t alias_dict;
     59
     60typedef struct {
     61        odlink_t odict;
     62        char *name;
     63        char *value;
     64} alias_t;
     65
    5666#endif
Note: See TracChangeset for help on using the changeset viewer.