Subversion Repositories Kolibri OS

/*

    UMKa - User-Mode KolibriOS developer tools

    umka_shell - interactive shell

    Copyright (C) 2018--2020  Ivan Baravy 

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see .

*/

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include "getopt.h"

#include "vdisk.h"

#include "umka.h"

#include "trace.h"

#include "pci.h"

#include "lodepng.h"

#define PATH_MAX 4096

#define FGETS_BUF_LEN 4096

#define MAX_COMMAND_ARGS 42

#define PRINT_BYTES_PER_LINE 32

#define MAX_DIRENTS_TO_READ 100

#define MAX_BYTES_TO_READ (1024*1024)

#define DEFAULT_READDIR_ENCODING UTF8

#define DEFAULT_PATH_ENCODING UTF8

FILE *fin, *fout;

char cur_dir[PATH_MAX] = "/";

const char *last_dir = cur_dir;

bool cur_dir_changed = true;

char cmd_buf[FGETS_BUF_LEN];

typedef struct {

    char *name;

    void (*func) (int, char **);

} func_table_t;

const char *f70_status_name[] = {

                                 "success",

                                 "disk_base",

                                 "unsupported_fs",

                                 "unknown_fs",

                                 "partition",

                                 "file_not_found",

                                 "end_of_file",

                                 "memory_pointer",

                                 "disk_full",

                                 "fs_fail",

                                 "access_denied",

                                 "device",

                                 "out_of_memory"

                                };

static const char *

get_f70_status_name(int s) {

    switch (s) {

    case ERROR_SUCCESS:

//        return "";

    case ERROR_DISK_BASE:

    case ERROR_UNSUPPORTED_FS:

    case ERROR_UNKNOWN_FS:

    case ERROR_PARTITION:

    case ERROR_FILE_NOT_FOUND:

    case ERROR_END_OF_FILE:

    case ERROR_MEMORY_POINTER:

    case ERROR_DISK_FULL:

    case ERROR_FS_FAIL:

    case ERROR_ACCESS_DENIED:

    case ERROR_DEVICE:

    case ERROR_OUT_OF_MEMORY:

        return f70_status_name[s];

    default:

        return "unknown";

    }

}

static void

convert_f70_file_attr(uint32_t attr, char s[KF_ATTR_CNT+1]) {

    s[0] = (attr & KF_READONLY) ? 'r' : '-';

    s[1] = (attr & KF_HIDDEN)   ? 'h' : '-';

    s[2] = (attr & KF_SYSTEM)   ? 's' : '-';

    s[3] = (attr & KF_LABEL)    ? 'l' : '-';

    s[4] = (attr & KF_FOLDER)   ? 'f' : '-';

    s[5] = '\0';

}

static void

print_f70_status(f7080ret_t *r, int use_ebx) {

    fprintf(fout, "status = %d %s", r->status, get_f70_status_name(r->status));

    if (use_ebx &&

        (r->status == ERROR_SUCCESS || r->status == ERROR_END_OF_FILE))

        fprintf(fout, ", count = %d", r->count);

    fputc('\n', fout);

}

static bool

parse_uintmax(const char *str, uintmax_t *res) {

    char *endptr;

    *res = strtoumax(str, &endptr, 0);

    bool ok = (str != endptr) && (*endptr == '\0');

    return ok;

}

static bool

parse_uint32(const char *str, uint32_t *res) {

    uintmax_t x;

    if (parse_uintmax(str, &x) && x <= UINT32_MAX) {

        *res = (uint32_t)x;

        return true;

    } else {

        perror("invalid number");

        return false;

    }

}

static bool

parse_uint64(const char *str, uint64_t *res) {

    uintmax_t x;

    if (parse_uintmax(str, &x) && x <= UINT64_MAX) {

        *res = x;

        return true;

    } else {

        perror("invalid number");

        return false;

    }

}

static void

print_bytes(uint8_t *x, size_t len) {

    for (size_t i = 0; i < len; i++) {

        if (i % PRINT_BYTES_PER_LINE == 0 && i != 0) {

            fputc('\n', fout);

        }

        fprintf(fout, "%2.2x", x[i]);

    }

    fputc('\n', fout);

}

static void

print_hash(uint8_t *x, size_t len) {

    hash_context ctx;

    hash_oneshot(&ctx, x, len);

    for (size_t i = 0; i < HASH_SIZE; i++) {

        fprintf(fout, "%2.2x", ctx.hash[i]);

    }

    fputc('\n', fout);

}

static const char *

get_last_dir(const char *path) {

    const char *last = strrchr(path, '/');

    if (!last) {

        last = path;

    } else if (last != path || last[1] != '\0') {

        last++;

    }

    return last;

}

static void

prompt() {

    if (cur_dir_changed) {

        if (umka_initialized) {

            COVERAGE_ON();

            umka_sys_get_cwd(cur_dir, PATH_MAX);

            COVERAGE_OFF();

        }

        last_dir = get_last_dir(cur_dir);

        cur_dir_changed = false;

    }

    fprintf(fout, "%s> ", last_dir);

    fflush(fout);

}

static int

next_line(int is_tty) {

    if (is_tty) {

        prompt();

    }

    return fgets(cmd_buf, FGETS_BUF_LEN, fin) != NULL;

}

static int

split_args(char *s, char **argv) {

    int argc = -1;

    for (; (argv[++argc] = strtok(s, " \t\n\r")) != NULL; s = NULL);

    return argc;

}

static void

shell_umka_init(int argc, char **argv) {

    const char *usage = \

        "usage: umka_init";

    (void)argv;

    if (argc < 0) {

        fputs(usage, fout);

        return;

    }

    COVERAGE_ON();

    umka_init();

    COVERAGE_OFF();

}

static void

shell_umka_set_boot_params(int argc, char **argv) {

    const char *usage = \

        "usage: umka_set_boot_params [--x_res ] [--y_res ]\n"

        "  --x_res     screen width\n"

        "  --y_res     screen height";

    argc -= 1;

    argv += 1;

    while (argc) {

        if (!strcmp(argv[0], "--x_res") && argc > 1) {

            kos_boot.x_res = strtoul(argv[1], NULL, 0);

            kos_boot.pitch = kos_boot.x_res * 4;    // assume 32bpp

            argc -= 2;

            argv += 2;

            continue;

        } else if (!strcmp(argv[0], "--y_res") && argc > 1) {

            kos_boot.y_res = strtoul(argv[1], NULL, 0);

            argc -= 2;

            argv += 2;

            continue;

        } else {

            printf("bad option: %s\n", argv[0]);

            puts(usage);

            exit(1);

        }

    }

}

static void

shell_i40(int argc, char **argv) {

    const char *usage = \

        "usage: i40  [ebx [ecx [edx [esi [edi [ebp]]]]]]...\n"

        "  see '/kernel/docs/sysfuncs.txt' for details";

    if (argc < 2 || argc > 8) {

        fputs(usage, fout);

        return;

    }

    pushad_t regs = {0, 0, 0, 0, 0, 0, 0, 0};

    if (argv[1]) regs.eax = strtoul(argv[1], NULL, 0);

    if (argv[2]) regs.ebx = strtoul(argv[2], NULL, 0);

    if (argv[3]) regs.ecx = strtoul(argv[3], NULL, 0);

    if (argv[4]) regs.edx = strtoul(argv[4], NULL, 0);

    if (argv[5]) regs.esi = strtoul(argv[5], NULL, 0);

    if (argv[6]) regs.edi = strtoul(argv[6], NULL, 0);

    if (argv[7]) regs.ebp = strtoul(argv[7], NULL, 0);

    COVERAGE_ON();

    umka_i40(®s);

    COVERAGE_OFF();

    fprintf(fout, "eax = %8.8x  %" PRIu32 "  %" PRIi32 "\n"

           "ebx = %8.8x  %" PRIu32 "  %" PRIi32 "\n",

           regs.eax, regs.eax, (int32_t)regs.eax,

           regs.ebx, regs.ebx, (int32_t)regs.ebx);

}

static void

disk_list_partitions(disk_t *d) {

    for (size_t i = 0; i < d->num_partitions; i++) {

        fprintf(fout, "/%s/%d: ", d->name, i+1);

        if (d->partitions[i]->fs_user_functions == xfs_user_functions) {

            fputs("xfs\n", fout);

        } else if (d->partitions[i]->fs_user_functions == ext_user_functions) {

            fputs("ext\n", fout);

        } else if (d->partitions[i]->fs_user_functions == fat_user_functions) {

            fputs("fat\n", fout);

        } else if (d->partitions[i]->fs_user_functions == ntfs_user_functions) {

            fputs("ntfs\n", fout);

        } else {

            fputs("???\n", fout);

        }

    }

}

static void

shell_ramdisk_init(int argc, char **argv) {

    const char *usage = \

        "usage: ramdisk_init \n"

        "             absolute or relative path";

    if (argc != 2) {

        fputs(usage, fout);

        return;

    }

    const char *fname = argv[1];

    FILE *f = fopen(fname, "rb");

    if (!f) {

        fprintf(fout, "[!] can't open file '%s': %s\n", fname, strerror(errno));

        return;

    }

    fseek(f, 0, SEEK_END);

    size_t fsize = ftell(f);

    if (fsize > 2880*512) {

        fprintf(fout, "[!] file '%s' is too big, max size is 1474560 bytes\n",

                fname);

        return;

    }

    rewind(f);

    fread(kos_ramdisk, fsize, 1, f);

    fclose(f);

    COVERAGE_ON();

    void *ramdisk = kos_ramdisk_init();

    COVERAGE_OFF();

    disk_list_partitions(ramdisk);

}

static void

shell_disk_add(int argc, char **argv) {

    const char *usage = \

        "usage: disk_add   [option]...\n"

        "             absolute or relative path\n"

        "             disk name, e.g. hd0 or rd\n"

        "  -c cache size    size of disk cache in bytes";

    if (argc < 3) {

        fputs(usage, fout);

        return;

    }

    size_t cache_size = 0;

    int adjust_cache_size = 0;

    int opt;

    optind = 1;

    const char *file_name = argv[optind++];

    const char *disk_name = argv[optind++];

    while ((opt = getopt(argc, argv, "c:")) != -1) {

        switch (opt) {

        case 'c':

            cache_size = strtoul(optarg, NULL, 0);

            adjust_cache_size = 1;

            break;

        default:

            fputs(usage, fout);

            return;

        }

    }

    void *userdata = vdisk_init(file_name, adjust_cache_size, cache_size);

    if (userdata) {

        COVERAGE_ON();

        void *vdisk = disk_add(&vdisk_functions, disk_name, userdata, 0);

        COVERAGE_OFF();

        if (vdisk) {

            COVERAGE_ON();

            disk_media_changed(vdisk, 1);

            COVERAGE_OFF();

            disk_list_partitions(vdisk);

            return;

        }

    }

    fprintf(fout, "umka: can't add file '%s' as disk '%s'\n", file_name,

            disk_name);

    return;

}

static void

disk_del_by_name(const char *name) {

    for(disk_t *d = disk_list.next; d != &disk_list; d = d->next) {

        if (!strcmp(d->name, name)) {

            COVERAGE_ON();

            disk_del(d);

            COVERAGE_OFF();

            return;

        }

    }

    fprintf(fout, "umka: can't find disk '%s'\n", name);

}

static void

shell_disk_del(int argc, char **argv) {

    const char *usage = \

        "usage: disk_del \n"

        "  name             disk name, i.e. rd or hd0";

    if (argc != 2) {

        fputs(usage, fout);

        return;

    }

    const char *name = argv[1];

    disk_del_by_name(name);

    return;

}

static void

shell_pwd(int argc, char **argv) {

    const char *usage = \

        "usage: pwd";

    if (argc != 1) {

        fputs(usage, fout);

        return;

    }

    (void)argv;

    bool quoted = false;

    const char *quote = quoted ? "'" : "";

    COVERAGE_ON();

    umka_sys_get_cwd(cur_dir, PATH_MAX);

    COVERAGE_OFF();

    fprintf(fout, "%s%s%s\n", quote, cur_dir, quote);

}

static void

shell_set_pixel(int argc, char **argv) {

    const char *usage = \

        "usage: set_pixel    [-i]\n"

        "  x                x window coordinate\n"

        "  y                y window coordinate\n"

        "  color            argb in hex\n"

        "  -i               inverted color";

    if (argc < 4) {

        fputs(usage, fout);

        return;

    }

    size_t x = strtoul(argv[1], NULL, 0);

    size_t y = strtoul(argv[2], NULL, 0);

    uint32_t color = strtoul(argv[3], NULL, 16);

    int invert = (argc == 5) && !strcmp(argv[4], "-i");

    COVERAGE_ON();

    umka_sys_set_pixel(x, y, color, invert);

    COVERAGE_OFF();

}

static void

shell_write_text(int argc, char **argv) {

    const char *usage = \

        "usage: write_text      "

            "    "

            " \n"

        "  x                x window coordinate\n"

        "  y                y window coordinate\n"

        "  color            argb in hex\n"

        "  string           escape spaces\n"

        "  asciiz           1 if the string is zero-terminated\n"

        "  fill_bg          fill text background with specified color\n"

        "  font_and_enc     font size and string encoding\n"

        "  draw_to_buf      draw to the buffer pointed to by the next param\n"

        "  length           length of the string if it is non-asciiz\n"

        "  bg_color_or_buf  argb or pointer";

    if (argc != 12) {

        fputs(usage, fout);

        return;

    }

    size_t x = strtoul(argv[1], NULL, 0);

    size_t y = strtoul(argv[2], NULL, 0);

    uint32_t color = strtoul(argv[3], NULL, 16);

    const char *string = argv[4];

    int asciiz = strtoul(argv[5], NULL, 0);

    int fill_background = strtoul(argv[6], NULL, 0);

    int font_and_encoding = strtoul(argv[7], NULL, 0);

    int draw_to_buffer = strtoul(argv[8], NULL, 0);

    int scale_factor = strtoul(argv[9], NULL, 0);

    int length = strtoul(argv[10], NULL, 0);

    int background_color_or_buffer = strtoul(argv[11], NULL, 0);

    COVERAGE_ON();

    umka_sys_write_text(x, y, color, asciiz, fill_background, font_and_encoding,

                        draw_to_buffer, scale_factor, string, length,

                        background_color_or_buffer);

    COVERAGE_OFF();

}

static void

shell_dump_win_stack(int argc, char **argv) {

    const char *usage = \

        "usage: dump_win_stack [count]\n"

        "  count            how many items to dump";

    if (argc < 1) {

        fputs(usage, fout);

        return;

    }

    int depth = 5;

    if (argc > 1) {

        depth = strtol(argv[1], NULL, 0);

    }

    for (int i = 0; i < depth; i++) {

        fprintf(fout, "%3i: %3u\n", i, kos_win_stack[i]);

    }

}

static void

shell_dump_win_pos(int argc, char **argv) {

    const char *usage = \

        "usage: dump_win_pos [count]\n"

        "  count            how many items to dump";

    if (argc < 1) {

        fputs(usage, fout);

        return;

    }

    int depth = 5;

    if (argc > 1) {

        depth = strtol(argv[1], NULL, 0);

    }

    for (int i = 0; i < depth; i++) {

        fprintf(fout, "%3i: %3u\n", i, kos_win_pos[i]);

    }

}

static void

shell_dump_win_map(int argc, char **argv) {

    const char *usage = \

        "usage: dump_win_map";

    (void)argv;

    if (argc < 0) {

        fputs(usage, fout);

        return;

    }

    for (size_t y = 0; y < kos_display.height; y++) {

        for (size_t x = 0; x < kos_display.width; x++) {

            fputc(kos_display.win_map[y * kos_display.width + x] + '0', fout);

        }

        fputc('\n', fout);

    }

}

static void

shell_dump_appdata(int argc, char **argv) {

    const char *usage = \

        "usage: dump_appdata  [-p]\n"

        "  index            index into appdata array to dump\n"

        "  -p               print fields that are pointers";

    if (argc < 2) {

        fputs(usage, fout);

        return;

    }

    int show_pointers = 0;

    int idx = strtol(argv[1], NULL, 0);

    if (argc > 2 && !strcmp(argv[2], "-p")) {

        show_pointers = 1;

    }

    appdata_t *a = kos_slot_base + idx;

    fprintf(fout, "app_name: %s\n", a->app_name);

    if (show_pointers) {

        fprintf(fout, "process: %p\n", (void*)a->process);

        fprintf(fout, "fpu_state: %p\n", (void*)a->fpu_state);

        fprintf(fout, "exc_handler: %p\n", (void*)a->exc_handler);

    }

    fprintf(fout, "except_mask: %" PRIx32 "\n", a->except_mask);

    if (show_pointers) {

        fprintf(fout, "pl0_stack: %p\n", (void*)a->pl0_stack);

        fprintf(fout, "cursor: %p\n", (void*)a->cursor);

        fprintf(fout, "fd_ev: %p\n", (void*)a->fd_ev);

        fprintf(fout, "bk_ev: %p\n", (void*)a->bk_ev);

        fprintf(fout, "fd_obj: %p\n", (void*)a->fd_obj);

        fprintf(fout, "bk_obj: %p\n", (void*)a->bk_obj);

        fprintf(fout, "saved_esp: %p\n", (void*)a->saved_esp);

    }

    fprintf(fout, "dbg_state: %u\n", a->dbg_state);

    fprintf(fout, "cur_dir: %s\n", a->cur_dir);

    fprintf(fout, "draw_bgr_x: %u\n", a->draw_bgr_x);

    fprintf(fout, "draw_bgr_y: %u\n", a->draw_bgr_y);

    fprintf(fout, "event_mask: %" PRIx32 "\n", a->event_mask);

    fprintf(fout, "terminate_protection: %u\n", a->terminate_protection);

    fprintf(fout, "keyboard_mode: %u\n", a->keyboard_mode);

    fprintf(fout, "captionEncoding: %u\n", a->captionEncoding);

    fprintf(fout, "exec_params: %s\n", a->exec_params);

    fprintf(fout, "wnd_caption: %s\n", a->wnd_caption);

    fprintf(fout, "wnd_clientbox (ltwh): %u %u %u %u\n", a->wnd_clientbox.left,

            a->wnd_clientbox.top, a->wnd_clientbox.width,

            a->wnd_clientbox.height);

    fprintf(fout, "priority: %u\n", a->priority);

    fprintf(fout, "in_schedule: prev");

    if (show_pointers) {

        fprintf(fout, " %p", (void*)a->in_schedule.prev);

    }

    fprintf(fout, " (%u), next",

            (appdata_t*)a->in_schedule.prev - kos_slot_base);

    if (show_pointers) {

        fprintf(fout, " %p", (void*)a->in_schedule.next);

    }

    fprintf(fout, " (%u)\n",

            (appdata_t*)a->in_schedule.next - kos_slot_base);

}

static void

shell_dump_taskdata(int argc, char **argv) {

    const char *usage = \

        "usage: dump_taskdata \n"

        "  index            index into taskdata array to dump";

    if (argc < 2) {

        fputs(usage, fout);

        return;

    }

    int idx = strtol(argv[1], NULL, 0);

    taskdata_t *t = kos_task_table + idx;

    fprintf(fout, "event_mask: %" PRIx32 "\n", t->event_mask);

    fprintf(fout, "pid: %" PRId32 "\n", t->pid);

    fprintf(fout, "state: 0x%" PRIx8 "\n", t->state);

    fprintf(fout, "wnd_number: %" PRIu8 "\n", t->wnd_number);

    fprintf(fout, "counter_sum: %" PRIu32 "\n", t->counter_sum);

    fprintf(fout, "counter_add: %" PRIu32 "\n", t->counter_add);

    fprintf(fout, "cpu_usage: %" PRIu32 "\n", t->cpu_usage);

}

static void

shell_switch_to_thread(int argc, char **argv) {

    const char *usage = \

        "usage: switch_to_thread \n"

        "            thread id to switch to";

    if (argc != 2) {

        fputs(usage, fout);

        return;

    }

    uint8_t tid = strtoul(argv[1], NULL, 0);

    kos_current_slot_idx = tid;

    kos_task_base = kos_task_table + tid;

    kos_current_slot = kos_slot_base + tid;

}

static void

shell_set(int argc, char **argv) {

    const char *usage = \

        "usage: set  \n"

        "            variable to set\n"

        "          decimal or hex value";

    if (argc != 3) {

        fputs(usage, fout);

        return;

    }

    const char *var = argv[1];

    size_t value = strtoul(argv[2], NULL, 0);

    if (!strcmp(var, "redraw_background")) {

        kos_redraw_background = value;

    } else {

        printf("bad option: %s\n", argv[0]);

        puts(usage);

        exit(1);

    }

}

static void

shell_new_sys_thread(int argc, char **argv) {

    const char *usage = \

        "usage: new_sys_thread";

    if (!argc) {

        fputs(usage, fout);

        return;

    }

    (void)argv;

    size_t tid = umka_new_sys_threads(0, NULL, NULL);

    fprintf(fout, "tid: %u\n", tid);

}

static void

shell_mouse_move(int argc, char **argv) {

    const char *usage = \

        "usage: mouse_move [-l] [-m] [-r] [-x {+|-|=}]"

            "[-y {+|-|=}] [-h {+|-}] [-v {+|-}]\n"

        "  -l             left button is held\n"

        "  -m             middle button is held\n"

        "  -r             right button is held\n"

        "  -x             increase, decrease or set x coordinate\n"

        "  -y             increase, decrease or set y coordinate\n"

        "  -h             scroll horizontally\n"

        "  -v             scroll vertically\n";

    if (!argc) {

        fputs(usage, fout);

        return;

    }

    int lbheld = 0, mbheld = 0, rbheld = 0, xabs = 0, yabs = 0;

    int32_t xmoving = 0, ymoving = 0, hscroll = 0, vscroll = 0;

    int opt;

    optind = 1;

    while ((opt = getopt(argc, argv, "lmrx:y:h:v:")) != -1) {

        switch (opt) {

        case 'l':

            lbheld = 1;

            break;

        case 'm':

            mbheld = 1;

            break;

        case 'r':

            rbheld = 1;

            break;

        case 'x':

            switch (*optarg++) {

            case '=':

                xabs = 1;

                __attribute__ ((fallthrough));

            case '+':

                xmoving = strtol(optarg, NULL, 0);

                break;

            case '-':

                xmoving = -strtol(optarg, NULL, 0);

                break;

            default:

                fputs(usage, fout);

                return;

            }

            break;

        case 'y':

            switch (*optarg++) {

            case '=':

                yabs = 1;

                __attribute__ ((fallthrough));

            case '+':

                ymoving = strtol(optarg, NULL, 0);

                break;

            case '-':

                ymoving = -strtol(optarg, NULL, 0);

                break;

            default:

                fputs(usage, fout);

                return;

            }

            break;

        case 'h':

            if ((optarg[0] != '+') && (optarg[0] != '-')) {

                fputs(usage, fout);

                return;

            }

            hscroll = strtol(optarg, NULL, 0);

            break;

        case 'v':

            if ((optarg[0] != '+') && (optarg[0] != '-')) {

                fputs(usage, fout);

                return;

            }

            vscroll = strtol(optarg, NULL, 0);

            break;

        default:

            fputs(usage, fout);

            return;

        }

    }

    COVERAGE_ON();

    umka_mouse_move(lbheld, mbheld, rbheld, xabs, xmoving, yabs, ymoving,

                    hscroll, vscroll);

    COVERAGE_OFF();

}

static void

shell_process_info(int argc, char **argv) {

    const char *usage = \

        "usage: process_info \n"

        "  pid              process id to dump, -1 for self";

    if (argc != 2) {

        fputs(usage, fout);

        return;

    }

    process_information_t info;

    int32_t pid = strtol(argv[1], NULL, 0);

    COVERAGE_ON();

    umka_sys_process_info(pid, &info);

    COVERAGE_OFF();

    fprintf(fout, "cpu_usage: %u\n", info.cpu_usage);

    fprintf(fout, "window_stack_position: %u\n", info.window_stack_position);

    fprintf(fout, "window_stack_value: %u\n", info.window_stack_value);

    fprintf(fout, "process_name: %s\n", info.process_name);

    fprintf(fout, "memory_start: 0x%.8" PRIx32 "\n", info.memory_start);

    fprintf(fout, "used_memory: %u (0x%x)\n", info.used_memory,

            info.used_memory);

    fprintf(fout, "pid: %u\n", info.pid);

    fprintf(fout, "box: %u %u %u %u\n", info.box.left, info.box.top,

            info.box.width, info.box.height);

    fprintf(fout, "slot_state: %u\n", info.slot_state);

    fprintf(fout, "client_box: %u %u %u %u\n", info.client_box.left,

            info.client_box.top, info.client_box.width, info.client_box.height);

    fprintf(fout, "wnd_state: 0x%.2" PRIx8 "\n", info.wnd_state);

}

static void

shell_display_number(int argc, char **argv) {

    const char *usage = \

        "usage: display_number    "

            "       "

            "   \n"

        "  is_pointer       if num_or_ptr argument is a pointer\n"

        "  base             0 - dec, 1 - hex, 2 - bin\n"

        "  num_digits       how many digits to print\n"

        "  is_qword         if 1, is_pointer = 1 and num_or_ptr is pointer\n"

        "  show_lead_zeros  0/1\n"

        "  num_or_ptr       number itself or a pointer to it\n"

        "  x                x window coord\n"

        "  y                y window coord\n"

        "  color            argb in hex\n"

        "  fill_bg          0/1\n"

        "  font             0 = 6x9, 1 = 8x16\n"

        "  draw_to_buf      0/1\n"

        "  scale_factor     0 = x1, ..., 7 = x8\n"

        "  bg_color_or_buf  depending on flags fill_bg and draw_to_buf";

    if (argc != 15) {

        fputs(usage, fout);

        return;

    }

    int is_pointer = strtoul(argv[1], NULL, 0);

    int base = strtoul(argv[2], NULL, 0);

    if (base == 10) base = 0;

    else if (base == 16) base = 1;

    else if (base == 2) base = 2;

    else base = 0;

    size_t digits_to_display = strtoul(argv[3], NULL, 0);

    int is_qword = strtoul(argv[4], NULL, 0);

    int show_leading_zeros = strtoul(argv[5], NULL, 0);

    uintptr_t number_or_pointer = strtoul(argv[6], NULL, 0);

    size_t x = strtoul(argv[7], NULL, 0);

    size_t y = strtoul(argv[8], NULL, 0);

    uint32_t color = strtoul(argv[9], NULL, 16);

    int fill_background = strtoul(argv[10], NULL, 0);

    int font = strtoul(argv[11], NULL, 0);

    int draw_to_buffer = strtoul(argv[12], NULL, 0);

    int scale_factor = strtoul(argv[13], NULL, 0);

    uintptr_t background_color_or_buffer = strtoul(argv[14], NULL, 16);

    COVERAGE_ON();

    umka_sys_display_number(is_pointer, base, digits_to_display, is_qword,

                            show_leading_zeros, number_or_pointer, x, y, color,

                            fill_background, font, draw_to_buffer, scale_factor,

                            background_color_or_buffer);

    COVERAGE_OFF();

}

static void

shell_set_window_colors(int argc, char **argv) {

    const char *usage = \

        "usage: set_window_colors    "

            "     "

            " \n"

        "  *                all colors are in hex";

    if (argc != (1 + sizeof(system_colors_t)/4)) {

        fputs(usage, fout);

        return;

    }

    system_colors_t colors;

    colors.frame            = strtoul(argv[1], NULL, 16);

    colors.grab             = strtoul(argv[2], NULL, 16);

    colors.work_3d_dark     = strtoul(argv[3], NULL, 16);

    colors.work_3d_light    = strtoul(argv[4], NULL, 16);

    colors.grab_text        = strtoul(argv[5], NULL, 16);

    colors.work             = strtoul(argv[6], NULL, 16);

    colors.work_button      = strtoul(argv[7], NULL, 16);

    colors.work_button_text = strtoul(argv[8], NULL, 16);

    colors.work_text        = strtoul(argv[9], NULL, 16);

    colors.work_graph       = strtoul(argv[10], NULL, 16);

    COVERAGE_ON();

    umka_sys_set_window_colors(&colors);

    COVERAGE_OFF();

}

static void

shell_get_window_colors(int argc, char **argv) {

    const char *usage = \

        "usage: get_window_colors";

    if (argc != 1) {

        fputs(usage, fout);

        return;

    }

    (void)argv;

    system_colors_t colors;

    memset(&colors, 0xaa, sizeof(colors));

    COVERAGE_ON();

    umka_sys_get_window_colors(&colors);

    COVERAGE_OFF();

    fprintf(fout, "0x%.8" PRIx32 " frame\n", colors.frame);

    fprintf(fout, "0x%.8" PRIx32 " grab\n", colors.grab);

    fprintf(fout, "0x%.8" PRIx32 " work_3d_dark\n", colors.work_3d_dark);

    fprintf(fout, "0x%.8" PRIx32 " work_3d_light\n", colors.work_3d_light);

    fprintf(fout, "0x%.8" PRIx32 " grab_text\n", colors.grab_text);

    fprintf(fout, "0x%.8" PRIx32 " work\n", colors.work);

    fprintf(fout, "0x%.8" PRIx32 " work_button\n", colors.work_button);

    fprintf(fout, "0x%.8" PRIx32 " work_button_text\n",

            colors.work_button_text);

    fprintf(fout, "0x%.8" PRIx32 " work_text\n", colors.work_text);

    fprintf(fout, "0x%.8" PRIx32 " work_graph\n", colors.work_graph);

}

static void

shell_get_skin_height(int argc, char **argv) {

    const char *usage = \

        "usage: get_skin_height";

    if (argc != 1) {

        fputs(usage, fout);

        return;

    }

    (void)argv;

    COVERAGE_ON();

    uint32_t skin_height = umka_sys_get_skin_height();

    COVERAGE_OFF();

    fprintf(fout, "%" PRIu32 "\n", skin_height);

}

static void

shell_get_screen_area(int argc, char **argv) {

    const char *usage = \

        "usage: get_screen_area";

    if (argc != 1) {

        fputs(usage, fout);

        return;

    }

    (void)argv;

    rect_t wa;

    COVERAGE_ON();

    umka_sys_get_screen_area(&wa);

    COVERAGE_OFF();

    fprintf(fout, "%" PRIu32 " left\n", wa.left);

    fprintf(fout, "%" PRIu32 " top\n", wa.top);

    fprintf(fout, "%" PRIu32 " right\n", wa.right);

    fprintf(fout, "%" PRIu32 " bottom\n", wa.bottom);

}

static void

shell_set_screen_area(int argc, char **argv) {

    const char *usage = \

        "usage: set_screen_area    \n"

        "  left             left x coord\n"

        "  top              top y coord\n"

        "  right            right x coord (not length!)\n"

        "  bottom           bottom y coord";

    if (argc != 5) {

        fputs(usage, fout);

        return;

    }

    rect_t wa;

    wa.left   = strtoul(argv[1], NULL, 0);

    wa.top    = strtoul(argv[2], NULL, 0);

    wa.right  = strtoul(argv[3], NULL, 0);

    wa.bottom = strtoul(argv[4], NULL, 0);

    COVERAGE_ON();

    umka_sys_set_screen_area(&wa);

    COVERAGE_OFF();

}

static void

shell_get_skin_margins(int argc, char **argv) {

    const char *usage = \

        "usage: get_skin_margins";

    if (argc != 1) {

        fputs(usage, fout);

        return;

    }

    (void)argv;

    rect_t wa;

    COVERAGE_ON();

    umka_sys_get_skin_margins(&wa);

    COVERAGE_OFF();

    fprintf(fout, "%" PRIu32 " left\n", wa.left);

    fprintf(fout, "%" PRIu32 " top\n", wa.top);

    fprintf(fout, "%" PRIu32 " right\n", wa.right);

    fprintf(fout, "%" PRIu32 " bottom\n", wa.bottom);

}

static void

shell_set_button_style(int argc, char **argv) {

    const char *usage = \

        "usage: set_button_style