Changeset 7cfe5c0 in mainline for uspace/app


Ignore:
Timestamp:
2012-08-20T19:16:24Z (14 years ago)
Author:
Adam Hraska <adam.hraska+hos@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6b99156
Parents:
b9cb911 (diff), 01e397ac (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:

Merged with mainline 0.5.0 changes.

Location:
uspace/app
Files:
11 added
15 edited
1 moved

Legend:

Unmodified
Added
Removed

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

    rb9cb911 r7cfe5c0  
    3838#include "cmds.h"
    3939
    40 #include <libblock.h>
     40#include <block.h>
    4141#include <loc.h>
    4242#include <errno.h>

  • uspace/app/bdsh/input.c

    rb9cb911 r7cfe5c0  
    6767int process_input(cliuser_t *usr)
    6868{
    69         token_t *tokens = calloc(WORD_MAX, sizeof(token_t));
    70         if (tokens == NULL)
     69        token_t *tokens_buf = calloc(WORD_MAX, sizeof(token_t));
     70        if (tokens_buf == NULL)
    7171                return ENOMEM;
     72        token_t *tokens = tokens_buf;
    7273       
    7374        char *cmd[WORD_MAX];
    … …  
    8081
    8182        if (usr->line == NULL) {
    82                 free(tokens);
     83                free(tokens_buf);
    8384                return CL_EFAIL;
    8485        }
    … …  
    213214        }
    214215        tok_fini(&tok);
    215         free(tokens);
     216        free(tokens_buf);
    216217
    217218        return rc;
    … …  
    268269        if (rc != EOK) {
    269270                /* Error in communication with console */
     271                cli_quit = 1;
    270272                return;
    271273        }

  • uspace/app/blkdump/blkdump.c

    rb9cb911 r7cfe5c0  
    4040#include <stdio.h>
    4141#include <stdlib.h>
    42 #include <libblock.h>
     42#include <block.h>
    4343#include <mem.h>
    4444#include <loc.h>

  • uspace/app/edit/Makefile

    rb9cb911 r7cfe5c0  
    3333SOURCES = \
    3434        edit.c \
    35         sheet.c
     35        sheet.c \
     36        search.c
    3637
    3738include $(USPACE_PREFIX)/Makefile.common

  • uspace/app/edit/edit.c

    rb9cb911 r7cfe5c0  
    11/*
    22 * Copyright (c) 2009 Jiri Svoboda
     3 * Copyright (c) 2012 Martin Sucha
    34 * All rights reserved.
    45 *
    … …  
    4950
    5051#include "sheet.h"
     52#include "search.h"
    5153
    5254enum redraw_flags {
    … …  
    8385         */
    8486        int ideal_column;
     87       
     88        char *previous_search;
     89        bool previous_search_reverse;
    8590} pane_t;
    8691
    … …  
    9196typedef struct {
    9297        char *file_name;
    93         sheet_t sh;
     98        sheet_t *sh;
    9499} doc_t;
    95100
    … …  
    126131static int file_save_range(char const *fname, spt_t const *spos,
    127132    spt_t const *epos);
    128 static char *filename_prompt(char const *prompt, char const *init_value);
    129133static char *range_get_str(spt_t const *spos, spt_t const *epos);
     134
     135static char *prompt(char const *prompt, char const *init_value);
    130136
    131137static void pane_text_display(void);
    … …  
    139145static void delete_char_after(void);
    140146static void caret_update(void);
    141 static void caret_move(int drow, int dcolumn, enum dir_spec align_dir);
    142 static void caret_move_word_left(void);
    143 static void caret_move_word_right(void);
     147static void caret_move_relative(int drow, int dcolumn, enum dir_spec align_dir, bool select);
     148static void caret_move_absolute(int row, int column, enum dir_spec align_dir, bool select);
     149static void caret_move(spt_t spt, bool select, bool update_ideal_column);
     150static void caret_move_word_left(bool select);
     151static void caret_move_word_right(bool select);
     152static void caret_go_to_line_ask(void);
    144153
    145154static bool selection_active(void);
    146155static void selection_sel_all(void);
    147156static void selection_sel_range(spt_t pa, spt_t pb);
    148 static void selection_sel_prev_word(void);
    149 static void selection_sel_next_word(void);
    150157static void selection_get_points(spt_t *pa, spt_t *pb);
    151158static void selection_delete(void);
    152159static void selection_copy(void);
    153160static void insert_clipboard_data(void);
     161
     162static void search(char *pattern, bool reverse);
     163static void search_prompt(bool reverse);
     164static void search_repeat(void);
    154165
    155166static void pt_get_sof(spt_t *pt);
    … …  
    160171static bool pt_is_delimiter(spt_t *pt);
    161172static bool pt_is_punctuation(spt_t *pt);
     173static spt_t pt_find_word_left(spt_t spt);
     174static spt_t pt_find_word_left(spt_t spt);
     175
    162176static int tag_cmp(tag_t const *a, tag_t const *b);
    163177static int spt_cmp(spt_t const *a, spt_t const *b);
    … …  
    170184{
    171185        kbd_event_t ev;
    172         coord_t coord;
    173186        bool new_file;
    174 
    175         spt_t pt;
     187        int rc;
    176188
    177189        con = console_init(stdin, stdout);
    … …  
    186198
    187199        /* Start with an empty sheet. */
    188         sheet_init(&doc.sh);
     200        rc = sheet_create(&doc.sh);
     201        if (rc != EOK) {
     202                printf("Out of memory.\n");
     203                return -1;
     204        }
    189205
    190206        /* Place caret at the beginning of file. */
    191         coord.row = coord.column = 1;
    192         sheet_get_cell_pt(&doc.sh, &coord, dir_before, &pt);
    193         sheet_place_tag(&doc.sh, &pt, &pane.caret_pos);
    194         pane.ideal_column = coord.column;
     207        spt_t sof;
     208        pt_get_sof(&sof);
     209        sheet_place_tag(doc.sh, &sof, &pane.caret_pos);
     210        pane.ideal_column = 1;
    195211
    196212        if (argc == 2) {
    … …  
    208224                new_file = true;
    209225
     226        /* Place selection start tag. */
     227        sheet_place_tag(doc.sh, &sof, &pane.sel_start);
     228
    210229        /* Move to beginning of file. */
    211         caret_move(-ED_INFTY, -ED_INFTY, dir_before);
    212 
    213         /* Place selection start tag. */
    214         tag_get_pt(&pane.caret_pos, &pt);
    215         sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
     230        pt_get_sof(&sof);
     231        caret_move(sof, true, true);
    216232
    217233        /* Initial display */
    … …  
    361377static void key_handle_ctrl(kbd_event_t const *ev)
    362378{
     379        spt_t pt;
    363380        switch (ev->key) {
    364381        case KC_Q:
    … …  
    392409                selection_sel_all();
    393410                break;
    394         case KC_W:
    395                 if (selection_active())
    396                         break;
    397                 selection_sel_prev_word();
    398                 selection_delete();
    399                 break;
    400411        case KC_RIGHT:
    401                 caret_move_word_right();
     412                caret_move_word_right(false);
    402413                break;
    403414        case KC_LEFT:
    404                 caret_move_word_left();
     415                caret_move_word_left(false);
     416                break;
     417        case KC_L:
     418                caret_go_to_line_ask();
     419                break;
     420        case KC_F:
     421                search_prompt(false);
     422                break;
     423        case KC_N:
     424                search_repeat();
     425                break;
     426        case KC_HOME:
     427                pt_get_sof(&pt);
     428                caret_move(pt, false, true);
     429                break;
     430        case KC_END:
     431                pt_get_eof(&pt);
     432                caret_move(pt, false, true);
    405433                break;
    406434        default:
    … …  
    411439static void key_handle_shift_ctrl(kbd_event_t const *ev)
    412440{
     441        spt_t pt;
    413442        switch(ev->key) {
    414443        case KC_LEFT:
    415                 selection_sel_prev_word();
     444                caret_move_word_left(true);
    416445                break;
    417446        case KC_RIGHT:
    418                 selection_sel_next_word();
     447                caret_move_word_right(true);
     448                break;
     449        case KC_F:
     450                search_prompt(true);
     451                break;
     452        case KC_HOME:
     453                pt_get_sof(&pt);
     454                caret_move(pt, true, true);
     455                break;
     456        case KC_END:
     457                pt_get_eof(&pt);
     458                caret_move(pt, true, true);
    419459                break;
    420460        default:
    … …  
    423463}
    424464
    425 static void key_handle_movement(unsigned int key, bool select)
    426 {
    427         spt_t pt;
    428         spt_t caret_pt;
     465/** Move caret while preserving or resetting selection. */
     466static void caret_move(spt_t new_caret_pt, bool select, bool update_ideal_column)
     467{
     468        spt_t old_caret_pt, old_sel_pt;
    429469        coord_t c_old, c_new;
    430470        bool had_sel;
    431471
    432472        /* Check if we had selection before. */
    433         tag_get_pt(&pane.caret_pos, &caret_pt);
    434         tag_get_pt(&pane.sel_start, &pt);
    435         had_sel = !spt_equal(&caret_pt, &pt);
    436 
    437         switch (key) {
    438         case KC_LEFT:
    439                 caret_move(0, -1, dir_before);
    440                 break;
    441         case KC_RIGHT:
    442                 caret_move(0, 0, dir_after);
    443                 break;
    444         case KC_UP:
    445                 caret_move(-1, 0, dir_before);
    446                 break;
    447         case KC_DOWN:
    448                 caret_move(+1, 0, dir_before);
    449                 break;
    450         case KC_HOME:
    451                 caret_move(0, -ED_INFTY, dir_before);
    452                 break;
    453         case KC_END:
    454                 caret_move(0, +ED_INFTY, dir_before);
    455                 break;
    456         case KC_PAGE_UP:
    457                 caret_move(-pane.rows, 0, dir_before);
    458                 break;
    459         case KC_PAGE_DOWN:
    460                 caret_move(+pane.rows, 0, dir_before);
    461                 break;
    462         default:
    463                 break;
    464         }
     473        tag_get_pt(&pane.caret_pos, &old_caret_pt);
     474        tag_get_pt(&pane.sel_start, &old_sel_pt);
     475        had_sel = !spt_equal(&old_caret_pt, &old_sel_pt);
     476
     477        /* Place tag of the caret */
     478        sheet_remove_tag(doc.sh, &pane.caret_pos);
     479        sheet_place_tag(doc.sh, &new_caret_pt, &pane.caret_pos);
    465480
    466481        if (select == false) {
    467482                /* Move sel_start to the same point as caret. */
    468                 sheet_remove_tag(&doc.sh, &pane.sel_start);
    469                 tag_get_pt(&pane.caret_pos, &pt);
    470                 sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
    471         }
    472 
     483                sheet_remove_tag(doc.sh, &pane.sel_start);
     484                sheet_place_tag(doc.sh, &new_caret_pt, &pane.sel_start);
     485        }
     486
     487        spt_get_coord(&new_caret_pt, &c_new);
    473488        if (select) {
    474                 tag_get_pt(&pane.caret_pos, &pt);
    475                 spt_get_coord(&caret_pt, &c_old);
    476                 spt_get_coord(&pt, &c_new);
     489                spt_get_coord(&old_caret_pt, &c_old);
    477490
    478491                if (c_old.row == c_new.row)
    … …  
    485498                pane.rflags |= REDRAW_TEXT;
    486499        }
     500       
     501        if (update_ideal_column)
     502                pane.ideal_column = c_new.column;
     503       
     504        caret_update();
     505}
     506
     507static void key_handle_movement(unsigned int key, bool select)
     508{
     509        switch (key) {
     510        case KC_LEFT:
     511                caret_move_relative(0, -1, dir_before, select);
     512                break;
     513        case KC_RIGHT:
     514                caret_move_relative(0, 0, dir_after, select);
     515                break;
     516        case KC_UP:
     517                caret_move_relative(-1, 0, dir_before, select);
     518                break;
     519        case KC_DOWN:
     520                caret_move_relative(+1, 0, dir_before, select);
     521                break;
     522        case KC_HOME:
     523                caret_move_relative(0, -ED_INFTY, dir_after, select);
     524                break;
     525        case KC_END:
     526                caret_move_relative(0, +ED_INFTY, dir_before, select);
     527                break;
     528        case KC_PAGE_UP:
     529                caret_move_relative(-pane.rows, 0, dir_before, select);
     530                break;
     531        case KC_PAGE_DOWN:
     532                caret_move_relative(+pane.rows, 0, dir_before, select);
     533                break;
     534        default:
     535                break;
     536        }
    487537}
    488538
    … …  
    520570        char *fname;
    521571       
    522         fname = filename_prompt("Save As", old_fname);
     572        fname = prompt("Save As", old_fname);
    523573        if (fname == NULL) {
    524574                status_display("Save cancelled.");
    … …  
    535585}
    536586
    537 /** Ask for a file name. */
    538 static char *filename_prompt(char const *prompt, char const *init_value)
     587/** Ask for a string. */
     588static char *prompt(char const *prompt, char const *init_value)
    539589{
    540590        kbd_event_t ev;
    … …  
    657707
    658708        do {
    659                 sheet_copy_out(&doc.sh, &sp, epos, buf, BUF_SIZE, &bep);
     709                sheet_copy_out(doc.sh, &sp, epos, buf, BUF_SIZE, &bep);
    660710                bytes = str_size(buf);
    661711
    … …  
    692742
    693743        while (true) {
    694                 sheet_copy_out(&doc.sh, &sp, epos, &buf[bpos], buf_size - bpos,
     744                sheet_copy_out(doc.sh, &sp, epos, &buf[bpos], buf_size - bpos,
    695745                    &bep);
    696746                bytes = str_size(&buf[bpos]);
    … …  
    714764        int sh_rows, rows;
    715765
    716         sheet_get_num_rows(&doc.sh, &sh_rows);
     766        sheet_get_num_rows(doc.sh, &sh_rows);
    717767        rows = min(sh_rows - pane.sh_row + 1, pane.rows);
    718768
    … …  
    784834                rbc.row = pane.sh_row + i;
    785835                rbc.column = pane.sh_column;
    786                 sheet_get_cell_pt(&doc.sh, &rbc, dir_before, &rb);
     836                sheet_get_cell_pt(doc.sh, &rbc, dir_before, &rb);
    787837
    788838                /* Ending point for row display */
    789839                rec.row = pane.sh_row + i;
    790840                rec.column = pane.sh_column + pane.columns;
    791                 sheet_get_cell_pt(&doc.sh, &rec, dir_before, &re);
     841                sheet_get_cell_pt(doc.sh, &rec, dir_before, &re);
    792842
    793843                /* Copy the text of the row to the buffer. */
    794                 sheet_copy_out(&doc.sh, &rb, &re, row_buf, ROW_BUF_SIZE, &dep);
     844                sheet_copy_out(doc.sh, &rb, &re, row_buf, ROW_BUF_SIZE, &dep);
    795845
    796846                /* Display text from the buffer. */
    … …  
    842892                /* Fill until the end of display area. */
    843893
    844                 if (str_length(row_buf) < (unsigned) scr_columns)
    845                         fill = scr_columns - str_length(row_buf);
     894                if ((unsigned)s_column - 1 < scr_columns)
     895                        fill = scr_columns - (s_column - 1);
    846896                else
    847897                        fill = 0;
    … …  
    861911        spt_t caret_pt;
    862912        coord_t coord;
     913        int last_row;
    863914
    864915        tag_get_pt(&pane.caret_pos, &caret_pt);
    865916        spt_get_coord(&caret_pt, &coord);
    866917
     918        sheet_get_num_rows(doc.sh, &last_row);
     919
    867920        const char *fname = (doc.file_name != NULL) ? doc.file_name : "<unnamed>";
    868921
    869922        console_set_pos(con, 0, scr_rows - 1);
    870923        console_set_style(con, STYLE_INVERTED);
    871         int n = printf(" %d, %d: File '%s'. Ctrl-Q Quit  Ctrl-S Save  "
    872             "Ctrl-E Save As", coord.row, coord.column, fname);
     924        int n = printf(" %d, %d (%d): File '%s'. Ctrl-Q Quit  Ctrl-S Save  "
     925            "Ctrl-E Save As", coord.row, coord.column, last_row, fname);
    873926       
    874927        int pos = scr_columns - 1 - n;
    … …  
    906959        cbuf[offs] = '\0';
    907960
    908         (void) sheet_insert(&doc.sh, &pt, dir_before, cbuf);
     961        (void) sheet_insert(doc.sh, &pt, dir_before, cbuf);
    909962
    910963        pane.rflags |= REDRAW_ROW;
    … …  
    923976
    924977        coord.column -= 1;
    925         sheet_get_cell_pt(&doc.sh, &coord, dir_before, &sp);
    926 
    927         (void) sheet_delete(&doc.sh, &sp, &ep);
     978        sheet_get_cell_pt(doc.sh, &coord, dir_before, &sp);
     979
     980        (void) sheet_delete(doc.sh, &sp, &ep);
    928981
    929982        pane.rflags |= REDRAW_ROW;
    … …  
    941994        spt_get_coord(&sp, &sc);
    942995
    943         sheet_get_cell_pt(&doc.sh, &sc, dir_after, &ep);
     996        sheet_get_cell_pt(doc.sh, &sc, dir_after, &ep);
    944997        spt_get_coord(&ep, &ec);
    945998
    946         (void) sheet_delete(&doc.sh, &sp, &ep);
     999        (void) sheet_delete(doc.sh, &sp, &ep);
    9471000
    9481001        pane.rflags |= REDRAW_ROW;
    … …  
    9911044}
    9921045
    993 /** Change the caret position.
     1046/** Relatively move caret position.
    9941047 *
    9951048 * Moves caret relatively to the current position. Looking at the first
    … …  
    9971050 * to a new character cell, and thus a new character. Then we either go to the
    9981051 * point before the the character or after it, depending on @a align_dir.
     1052 *
     1053 * @param select true if the selection tag should stay where it is
    9991054 */
    1000 static void caret_move(int drow, int dcolumn, enum dir_spec align_dir)
     1055static void caret_move_relative(int drow, int dcolumn, enum dir_spec align_dir,
     1056    bool select)
    10011057{
    10021058        spt_t pt;
    … …  
    10161072                else {
    10171073                        coord.row--;
    1018                         sheet_get_row_width(&doc.sh, coord.row, &coord.column);
     1074                        sheet_get_row_width(doc.sh, coord.row, &coord.column);
    10191075                }
    10201076        }
    10211077        if (drow > 0) {
    1022                 sheet_get_num_rows(&doc.sh, &num_rows);
     1078                sheet_get_num_rows(doc.sh, &num_rows);
    10231079                if (coord.row > num_rows) coord.row = num_rows;
    10241080        }
    … …  
    10331089         * coordinates. The character can be wider than one cell (e.g. tab).
    10341090         */
    1035         sheet_get_cell_pt(&doc.sh, &coord, align_dir, &pt);
    1036         sheet_remove_tag(&doc.sh, &pane.caret_pos);
    1037         sheet_place_tag(&doc.sh, &pt, &pane.caret_pos);
     1091        sheet_get_cell_pt(doc.sh, &coord, align_dir, &pt);
    10381092
    10391093        /* For non-vertical movement set the new value for @c ideal_column. */
    1040         if (!pure_vertical) {
    1041                 spt_get_coord(&pt, &coord);
    1042                 pane.ideal_column = coord.column;
    1043         }
    1044 
    1045         caret_update();
    1046 }
    1047 
    1048 static void caret_move_word_left(void)
    1049 {
     1094        caret_move(pt, select, !pure_vertical);
     1095}
     1096
     1097/** Absolutely move caret position.
     1098 *
     1099 * Moves caret to a specified position. We get to a new character cell, and
     1100 * thus a new character. Then we either go to the point before the the character
     1101 * or after it, depending on @a align_dir.
     1102 *
     1103 * @param select true if the selection tag should stay where it is
     1104 */
     1105static void caret_move_absolute(int row, int column, enum dir_spec align_dir,
     1106    bool select)
     1107{
     1108        coord_t coord;
     1109        coord.row = row;
     1110        coord.column = column;
     1111       
    10501112        spt_t pt;
    1051 
     1113        sheet_get_cell_pt(doc.sh, &coord, align_dir, &pt);
     1114       
     1115        caret_move(pt, select, true);
     1116}
     1117
     1118/** Find beginning of a word to the left of spt */
     1119static spt_t pt_find_word_left(spt_t spt)
     1120{
    10521121        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 
    1064 static void caret_move_word_right(void)
     1122                spt_prev_char(spt, &spt);
     1123        } while (!pt_is_word_beginning(&spt));
     1124        return spt;
     1125}
     1126
     1127/** Find beginning of a word to the right of spt */
     1128static spt_t pt_find_word_right(spt_t spt)
     1129{
     1130        do {
     1131                spt_next_char(spt, &spt);
     1132        } while (!pt_is_word_beginning(&spt));
     1133        return spt;
     1134}
     1135
     1136static void caret_move_word_left(bool select)
    10651137{
    10661138        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;
     1139        tag_get_pt(&pane.caret_pos, &pt);
     1140        spt_t word_left = pt_find_word_left(pt);
     1141        caret_move(word_left, select, true);
     1142}
     1143
     1144static void caret_move_word_right(bool select)
     1145{
     1146        spt_t pt;
     1147        tag_get_pt(&pane.caret_pos, &pt);
     1148        spt_t word_right = pt_find_word_right(pt);
     1149        caret_move(word_right, select, true);
     1150}
     1151
     1152/** Ask for line and go to it. */
     1153static void caret_go_to_line_ask(void)
     1154{
     1155        char *sline;
     1156       
     1157        sline = prompt("Go to line", "");
     1158        if (sline == NULL) {
     1159                status_display("Go to line cancelled.");
     1160                return;
     1161        }
     1162       
     1163        char *endptr;
     1164        int line = strtol(sline, &endptr, 10);
     1165        if (*endptr != '\0') {
     1166                free(sline);
     1167                status_display("Invalid number entered.");
     1168                return;
     1169        }
     1170        free(sline);
     1171       
     1172        caret_move_absolute(line, pane.ideal_column, dir_before, false);
     1173}
     1174
     1175/* Search operations */
     1176static int search_spt_producer(void *data, wchar_t *ret)
     1177{
     1178        assert(data != NULL);
     1179        assert(ret != NULL);
     1180        spt_t *spt = data;
     1181        *ret = spt_next_char(*spt, spt);
     1182        return EOK;
     1183}
     1184
     1185static int search_spt_reverse_producer(void *data, wchar_t *ret)
     1186{
     1187        assert(data != NULL);
     1188        assert(ret != NULL);
     1189        spt_t *spt = data;
     1190        *ret = spt_prev_char(*spt, spt);
     1191        return EOK;
     1192}
     1193
     1194static int search_spt_mark(void *data, void **mark)
     1195{
     1196        assert(data != NULL);
     1197        assert(mark != NULL);
     1198        spt_t *spt = data;
     1199        spt_t *new = calloc(1, sizeof(spt_t));
     1200        *mark = new;
     1201        if (new == NULL)
     1202                return ENOMEM;
     1203        *new = *spt;
     1204        return EOK;
     1205}
     1206
     1207static void search_spt_mark_free(void *data)
     1208{
     1209        free(data);
     1210}
     1211
     1212static search_ops_t search_spt_ops = {
     1213        .equals = char_exact_equals,
     1214        .producer = search_spt_producer,
     1215        .mark = search_spt_mark,
     1216        .mark_free = search_spt_mark_free,
     1217};
     1218
     1219static search_ops_t search_spt_reverse_ops = {
     1220        .equals = char_exact_equals,
     1221        .producer = search_spt_reverse_producer,
     1222        .mark = search_spt_mark,
     1223        .mark_free = search_spt_mark_free,
     1224};
     1225
     1226/** Ask for line and go to it. */
     1227static void search_prompt(bool reverse)
     1228{
     1229        char *pattern;
     1230       
     1231        const char *prompt_text = "Find next";
     1232        if (reverse)
     1233                prompt_text = "Find previous";
     1234       
     1235        const char *default_value = "";
     1236        if (pane.previous_search)
     1237                default_value = pane.previous_search;
     1238       
     1239        pattern = prompt(prompt_text, default_value);
     1240        if (pattern == NULL) {
     1241                status_display("Search cancelled.");
     1242                return;
     1243        }
     1244       
     1245        if (pane.previous_search)
     1246                free(pane.previous_search);
     1247        pane.previous_search = pattern;
     1248        pane.previous_search_reverse = reverse;
     1249       
     1250        search(pattern, reverse);
     1251}
     1252
     1253static void search_repeat(void)
     1254{
     1255        if (pane.previous_search == NULL) {
     1256                status_display("No previous search to repeat.");
     1257                return;
     1258        }
     1259       
     1260        search(pane.previous_search, pane.previous_search_reverse);
     1261}
     1262
     1263static void search(char *pattern, bool reverse)
     1264{
     1265        status_display("Searching...");
     1266       
     1267        spt_t sp, producer_pos;
     1268        tag_get_pt(&pane.caret_pos, &sp);
     1269       
     1270        /* Start searching on the position before/after caret */
     1271        if (!reverse) {
     1272                spt_next_char(sp, &sp);
     1273        }
     1274        else {
     1275                spt_prev_char(sp, &sp);
     1276        }
     1277        producer_pos = sp;
     1278       
     1279        search_ops_t ops = search_spt_ops;
     1280        if (reverse)
     1281                ops = search_spt_reverse_ops;
     1282       
     1283        search_t *search = search_init(pattern, &producer_pos, ops, reverse);
     1284        if (search == NULL) {
     1285                status_display("Failed initializing search.");
     1286                return;
     1287        }
     1288       
     1289        match_t match;
     1290        int rc = search_next_match(search, &match);
     1291        if (rc != EOK) {
     1292                status_display("Failed searching.");
     1293                search_fini(search);
     1294        }
     1295       
     1296        if (match.end) {
     1297                status_display("Match found.");
     1298                assert(match.end != NULL);
     1299                spt_t *end = match.end;
     1300                caret_move(*end, false, true);
     1301                while (match.length > 0) {
     1302                        match.length--;
     1303                        if (reverse) {
     1304                                spt_next_char(*end, end);
     1305                        }
     1306                        else {
     1307                                spt_prev_char(*end, end);
     1308                        }
     1309                }
     1310                caret_move(*end, true, true);
     1311                free(end);
     1312        }
     1313        else {
     1314                status_display("Not found.");
     1315        }
     1316       
     1317        search_fini(search);
    10781318}
    10791319
    … …  
    11151355
    11161356        if (rel < 0)
    1117                 sheet_delete(&doc.sh, &pa, &pb);
     1357                sheet_delete(doc.sh, &pa, &pb);
    11181358        else
    1119                 sheet_delete(&doc.sh, &pb, &pa);
     1359                sheet_delete(doc.sh, &pb, &pa);
    11201360
    11211361        if (ca.row == cb.row)
    … …  
    11391379static void selection_sel_range(spt_t pa, spt_t pb)
    11401380{
    1141         sheet_remove_tag(&doc.sh, &pane.sel_start);
    1142         sheet_place_tag(&doc.sh, &pa, &pane.sel_start);
    1143         sheet_remove_tag(&doc.sh, &pane.caret_pos);
    1144         sheet_place_tag(&doc.sh, &pb, &pane.caret_pos);
     1381        sheet_remove_tag(doc.sh, &pane.sel_start);
     1382        sheet_place_tag(doc.sh, &pa, &pane.sel_start);
     1383        sheet_remove_tag(doc.sh, &pane.caret_pos);
     1384        sheet_place_tag(doc.sh, &pb, &pane.caret_pos);
    11451385
    11461386        pane.rflags |= REDRAW_TEXT;
    11471387        caret_update();
    1148 }
    1149 
    1150 /** Add the previous word to the selection */
    1151 static 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 */
    1168 static 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);
    11821388}
    11831389
    … …  
    12251431
    12261432        coord.row = coord.column = 1;
    1227         sheet_get_cell_pt(&doc.sh, &coord, dir_before, pt);
     1433        sheet_get_cell_pt(doc.sh, &coord, dir_before, pt);
    12281434}
    12291435
    … …  
    12341440        int num_rows;
    12351441
    1236         sheet_get_num_rows(&doc.sh, &num_rows);
     1442        sheet_get_num_rows(doc.sh, &num_rows);
    12371443        coord.row = num_rows + 1;
    12381444        coord.column = 1;
    12391445
    1240         sheet_get_cell_pt(&doc.sh, &coord, dir_after, pt);
     1446        sheet_get_cell_pt(doc.sh, &coord, dir_after, pt);
    12411447}
    12421448
    … …  
    12491455        coord.column = 1;
    12501456
    1251         sheet_get_cell_pt(&doc.sh, &coord, dir_before, spt);
     1457        sheet_get_cell_pt(doc.sh, &coord, dir_before, spt);
    12521458}
    12531459
    … …  
    12591465
    12601466        spt_get_coord(cpt, &coord);
    1261         sheet_get_row_width(&doc.sh, coord.row, &row_width);
     1467        sheet_get_row_width(doc.sh, coord.row, &row_width);
    12621468        coord.column = row_width - 1;
    12631469
    1264         sheet_get_cell_pt(&doc.sh, &coord, dir_after, ept);
     1470        sheet_get_cell_pt(doc.sh, &coord, dir_after, ept);
    12651471}
    12661472
    … …  
    12881494
    12891495        coord.column -= 1;
    1290         sheet_get_cell_pt(&doc.sh, &coord, dir_before, &lp);
     1496        sheet_get_cell_pt(doc.sh, &coord, dir_before, &lp);
    12911497
    12921498        return pt_is_delimiter(&lp)
    … …  
    13101516
    13111517        coord.column += 1;
    1312         sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
     1518        sheet_get_cell_pt(doc.sh, &coord, dir_after, &rp);
    13131519
    13141520        ch = range_get_str(pt, &rp);
    … …  
    13361542
    13371543        coord.column += 1;
    1338         sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
     1544        sheet_get_cell_pt(doc.sh, &coord, dir_after, &rp);
    13391545
    13401546        ch = range_get_str(pt, &rp);

  • uspace/app/edit/sheet.c

    rb9cb911 r7cfe5c0  
    5757
    5858#include "sheet.h"
     59#include "sheet_impl.h"
    5960
    6061enum {
    … …  
    6667
    6768/** Initialize an empty sheet. */
    68 int sheet_init(sheet_t *sh)
    69 {
     69int sheet_create(sheet_t **rsh)
     70{
     71        sheet_t *sh;
     72
     73        sh = calloc(1, sizeof(sheet_t));
     74        if (sh == NULL)
     75                return ENOMEM;
     76
    7077        sh->dbuf_size = INITIAL_SIZE;
    7178        sh->text_size = 0;
    … …  
    7784        list_initialize(&sh->tags);
    7885
     86        *rsh = sh;
    7987        return EOK;
    8088}
    … …  
    315323}
    316324
     325/** Get a character at spt and return next spt */
     326wchar_t spt_next_char(spt_t spt, spt_t *next)
     327{
     328        wchar_t ch = str_decode(spt.sh->data, &spt.b_off, spt.sh->text_size);
     329        if (next)
     330                *next = spt;
     331        return ch;
     332}
     333
     334wchar_t spt_prev_char(spt_t spt, spt_t *prev)
     335{
     336        wchar_t ch = str_decode_reverse(spt.sh->data, &spt.b_off, spt.sh->text_size);
     337        if (prev)
     338                *prev = spt;
     339        return ch;
     340}
     341
    317342/** Place a tag on the specified s-point. */
    318343void sheet_place_tag(sheet_t *sh, spt_t const *pt, tag_t *tag)

  • uspace/app/edit/sheet.h

    rb9cb911 r7cfe5c0  
    5050
    5151/** Sheet */
    52 typedef struct {
    53         /* Note: This structure is opaque for the user. */
    54 
    55         size_t text_size;
    56         size_t dbuf_size;
    57         char *data;
    58 
    59         list_t tags;
    60 } sheet_t;
     52struct sheet;
     53typedef struct sheet sheet_t;
    6154
    6255/** Character cell coordinates
    … …  
    9790} tag_t;
    9891
    99 extern int sheet_init(sheet_t *);
     92extern int sheet_create(sheet_t **);
    10093extern int sheet_insert(sheet_t *, spt_t *, enum dir_spec, char *);
    10194extern int sheet_delete(sheet_t *, spt_t *, spt_t *);
    … …  
    108101extern void spt_get_coord(spt_t const *, coord_t *);
    109102extern bool spt_equal(spt_t const *, spt_t const *);
     103extern wchar_t spt_next_char(spt_t, spt_t *);
     104extern wchar_t spt_prev_char(spt_t, spt_t *);
    110105
    111106extern void sheet_place_tag(sheet_t *, spt_t const *, tag_t *);

  • uspace/app/ext2info/ext2info.c

    rb9cb911 r7cfe5c0  
    4040#include <stdio.h>
    4141#include <stdlib.h>
    42 #include <libblock.h>
     42#include <block.h>
    4343#include <mem.h>
    4444#include <loc.h>

  • uspace/app/init/init.c

    rb9cb911 r7cfe5c0  
    3737#include <stdio.h>
    3838#include <unistd.h>
     39#include <stdarg.h>
    3940#include <vfs/vfs.h>
    4041#include <bool.h>
    … …  
    6566#define SRV_CONSOLE  "/srv/console"
    6667#define APP_GETTERM  "/app/getterm"
     68
     69#define SRV_COMPOSITOR  "/srv/compositor"
     70
     71#define HID_INPUT              "hid/input"
     72#define HID_OUTPUT             "hid/output"
     73#define HID_COMPOSITOR_SERVER  ":0"
     74
     75#define srv_start(path, ...) \
     76        srv_startl(path, path, ##__VA_ARGS__, NULL)
    6777
    6878/** Print banner */
    … …  
    143153}
    144154
    145 static void spawn(const char *fname)
    146 {
    147         int rc;
     155static int srv_startl(const char *path, ...)
     156{
    148157        struct stat s;
    149        
    150         if (stat(fname, &s) == ENOENT)
    151                 return;
    152        
    153         printf("%s: Spawning %s\n", NAME, fname);
    154         rc = task_spawnl(NULL, fname, fname, NULL);
    155         if (rc != EOK) {
    156                 printf("%s: Error spawning %s (%s)\n", NAME, fname,
    157                     str_error(rc));
    158         }
    159 }
    160 
    161 static void srv_start(const char *fname)
    162 {
     158        if (stat(path, &s) == ENOENT) {
     159                printf("%s: Unable to stat %s\n", NAME, path);
     160                return ENOENT;
     161        }
     162       
     163        printf("%s: Starting %s\n", NAME, path);
     164       
     165        va_list ap;
     166        const char *arg;
     167        int cnt = 0;
     168       
     169        va_start(ap, path);
     170        do {
     171                arg = va_arg(ap, const char *);
     172                cnt++;
     173        } while (arg != NULL);
     174        va_end(ap);
     175       
     176        va_start(ap, path);
    163177        task_id_t id;
     178        int rc = task_spawn(&id, path, cnt, ap);
     179        va_end(ap);
     180       
     181        if (rc != EOK) {
     182                printf("%s: Error spawning %s (%s)\n", NAME, path,
     183                    str_error(rc));
     184                return rc;
     185        }
     186       
     187        if (!id) {
     188                printf("%s: Error spawning %s (invalid task id)\n", NAME,
     189                    path);
     190                return EINVAL;
     191        }
     192       
    164193        task_exit_t texit;
    165         int rc, retval;
    166         struct stat s;
    167        
    168         if (stat(fname, &s) == ENOENT)
    169                 return;
    170        
    171         printf("%s: Starting %s\n", NAME, fname);
    172         rc = task_spawnl(&id, fname, fname, NULL);
    173         if (!id) {
    174                 printf("%s: Error spawning %s (%s)\n", NAME, fname,
    175                     str_error(rc));
    176                 return;
    177         }
    178        
     194        int retval;
    179195        rc = task_wait(id, &texit, &retval);
    180196        if (rc != EOK) {
    181                 printf("%s: Error waiting for %s (%s)\n", NAME, fname,
    182                     str_error(rc));
    183                 return;
     197                printf("%s: Error waiting for %s (%s)\n", NAME, path,
     198                    str_error(rc));
     199                return rc;
    184200        }
    185201       
    186202        if (texit != TASK_EXIT_NORMAL) {
    187203                printf("%s: Server %s failed to start (unexpectedly "
    188                     "terminated)\n", NAME, fname);
    189                 return;
    190         }
    191 
    192         if (retval != 0) {
     204                    "terminated)\n", NAME, path);
     205                return EINVAL;
     206        }
     207       
     208        if (retval != 0)
    193209                printf("%s: Server %s failed to start (exit code %d)\n", NAME,
    194                         fname, retval);
    195         }
    196 }
    197 
    198 static void console(const char *isvc, const char *fbsvc)
    199 {
    200         printf("%s: Spawning %s %s %s\n", NAME, SRV_CONSOLE, isvc, fbsvc);
    201        
     210                    path, retval);
     211       
     212        return retval;
     213}
     214
     215static int console(const char *isvc, const char *osvc)
     216{
    202217        /* Wait for the input service to be ready */
    203218        service_id_t service_id;
    … …  
    206221                printf("%s: Error waiting on %s (%s)\n", NAME, isvc,
    207222                    str_error(rc));
    208                 return;
    209         }
    210        
    211         /* Wait for the framebuffer service to be ready */
    212         rc = loc_service_get_id(fbsvc, &service_id, IPC_FLAG_BLOCKING);
    213         if (rc != EOK) {
    214                 printf("%s: Error waiting on %s (%s)\n", NAME, fbsvc,
    215                     str_error(rc));
    216                 return;
    217         }
    218        
    219         rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, isvc, fbsvc, NULL);
    220         if (rc != EOK) {
    221                 printf("%s: Error spawning %s %s %s (%s)\n", NAME, SRV_CONSOLE,
    222                     isvc, fbsvc, str_error(rc));
    223         }
     223                return rc;
     224        }
     225       
     226        /* Wait for the output service to be ready */
     227        rc = loc_service_get_id(osvc, &service_id, IPC_FLAG_BLOCKING);
     228        if (rc != EOK) {
     229                printf("%s: Error waiting on %s (%s)\n", NAME, osvc,
     230                    str_error(rc));
     231                return rc;
     232        }
     233       
     234        return srv_start(SRV_CONSOLE, isvc, osvc);
     235}
     236
     237static int compositor(const char *isvc, const char *name)
     238{
     239        /* Wait for the input service to be ready */
     240        service_id_t service_id;
     241        int rc = loc_service_get_id(isvc, &service_id, IPC_FLAG_BLOCKING);
     242        if (rc != EOK) {
     243                printf("%s: Error waiting on %s (%s)\n", NAME, isvc,
     244                    str_error(rc));
     245                return rc;
     246        }
     247       
     248        return srv_start(SRV_COMPOSITOR, isvc, name);
     249}
     250
     251static int gui_start(const char *app, const char *srv_name)
     252{
     253        char winreg[50];
     254        snprintf(winreg, sizeof(winreg), "%s%s%s", "comp", srv_name, "/winreg");
     255       
     256        printf("%s: Spawning %s %s\n", NAME, app, winreg);
     257       
     258        task_id_t id;
     259        int rc = task_spawnl(&id, app, app, winreg, NULL);
     260        if (rc != EOK) {
     261                printf("%s: Error spawning %s %s (%s)\n", NAME, app,
     262                    winreg, str_error(rc));
     263                return -1;
     264        }
     265       
     266        task_exit_t texit;
     267        int retval;
     268        rc = task_wait(id, &texit, &retval);
     269        if ((rc != EOK) || (texit != TASK_EXIT_NORMAL)) {
     270                printf("%s: Error retrieving retval from %s (%s)\n", NAME,
     271                    app, str_error(rc));
     272                return -1;
     273        }
     274       
     275        return retval;
    224276}
    225277
    … …  
    227279{
    228280        char term[LOC_NAME_MAXLEN];
    229         int rc;
    230        
    231281        snprintf(term, LOC_NAME_MAXLEN, "%s/%s", LOCFS_MOUNT_POINT, svc);
    232282       
    … …  
    235285        /* Wait for the terminal service to be ready */
    236286        service_id_t service_id;
    237         rc = loc_service_get_id(svc, &service_id, IPC_FLAG_BLOCKING);
     287        int rc = loc_service_get_id(svc, &service_id, IPC_FLAG_BLOCKING);
    238288        if (rc != EOK) {
    239289                printf("%s: Error waiting on %s (%s)\n", NAME, term,
    … …  
    279329        if (!mount_root(STRING(RDFMT))) {
    280330                printf("%s: Exiting\n", NAME);
    281                 return -1;
     331                return 1;
    282332        }
    283333       
    284334        /* Make sure tmpfs is running. */
    285         if (str_cmp(STRING(RDFMT), "tmpfs") != 0) {
    286                 spawn("/srv/tmpfs");
    287         }
    288        
    289         spawn("/srv/locfs");
    290         spawn("/srv/taskmon");
     335        if (str_cmp(STRING(RDFMT), "tmpfs") != 0)
     336                srv_start("/srv/tmpfs");
     337       
     338        srv_start("/srv/locfs");
     339        srv_start("/srv/taskmon");
    291340       
    292341        if (!mount_locfs()) {
    293342                printf("%s: Exiting\n", NAME);
    294                 return -2;
     343                return 2;
    295344        }
    296345       
    297346        mount_tmpfs();
    298347       
    299         spawn("/srv/devman");
    300         spawn("/srv/apic");
    301         spawn("/srv/i8259");
    302         spawn("/srv/obio");
     348        srv_start("/srv/devman");
     349        srv_start("/srv/apic");
     350        srv_start("/srv/i8259");
     351        srv_start("/srv/obio");
    303352        srv_start("/srv/cuda_adb");
    304353        srv_start("/srv/s3c24xx_uart");
    305354        srv_start("/srv/s3c24xx_ts");
    306355       
    307         spawn("/srv/loopip");
    308         spawn("/srv/ethip");
    309         spawn("/srv/inetsrv");
    310         spawn("/srv/tcp");
    311         spawn("/srv/udp");
    312        
    313         spawn("/srv/fb");
    314         spawn("/srv/input");
    315         console("hid/input", "hid/fb0");
    316        
    317         spawn("/srv/clipboard");
    318         spawn("/srv/remcons");
     356        srv_start("/srv/loopip");
     357        srv_start("/srv/ethip");
     358        srv_start("/srv/inetsrv");
     359        srv_start("/srv/tcp");
     360        srv_start("/srv/udp");
     361       
     362        srv_start("/srv/clipboard");
     363        srv_start("/srv/remcons");
    319364       
    320365        /*
    … …  
    325370        srv_start("/srv/ata_bd");
    326371        srv_start("/srv/gxe_bd");
    327 #else
    328         (void) srv_start;
    329372#endif
    330373       
    331374#ifdef CONFIG_MOUNT_DATA
    332375        /* Make sure fat is running. */
    333         if (str_cmp(STRING(RDFMT), "fat") != 0) {
     376        if (str_cmp(STRING(RDFMT), "fat") != 0)
    334377                srv_start("/srv/fat");
    335         }
     378       
    336379        mount_data();
    337380#else
    … …  
    339382#endif
    340383       
    341         getterm("term/vc0", "/app/bdsh", true);
    342         getterm("term/vc1", "/app/bdsh", false);
    343         getterm("term/vc2", "/app/bdsh", false);
    344         getterm("term/vc3", "/app/bdsh", false);
    345         getterm("term/vc4", "/app/bdsh", false);
    346         getterm("term/vc5", "/app/bdsh", false);
    347         getterm("term/vc6", "/app/klog", false);
     384        srv_start("/srv/input", HID_INPUT);
     385        srv_start("/srv/output", HID_OUTPUT);
     386       
     387        int rc = compositor(HID_INPUT, HID_COMPOSITOR_SERVER);
     388        if (rc == EOK) {
     389                gui_start("/app/vlaunch", HID_COMPOSITOR_SERVER);
     390                gui_start("/app/vterm", HID_COMPOSITOR_SERVER);
     391        } else {
     392                rc = console(HID_INPUT, HID_OUTPUT);
     393                if (rc == EOK) {
     394                        getterm("term/vc0", "/app/bdsh", true);
     395                        getterm("term/vc1", "/app/bdsh", false);
     396                        getterm("term/vc2", "/app/bdsh", false);
     397                        getterm("term/vc3", "/app/bdsh", false);
     398                        getterm("term/vc4", "/app/bdsh", false);
     399                        getterm("term/vc5", "/app/bdsh", false);
     400                        getterm("term/vc6", "/app/klog", false);
     401                }
     402        }
    348403       
    349404        return 0;

  • uspace/app/mkexfat/mkexfat.c

    rb9cb911 r7cfe5c0  
    3838
    3939#include <stdio.h>
    40 #include <libblock.h>
     40#include <block.h>
    4141#include <assert.h>
    4242#include <errno.h>

  • uspace/app/mkfat/mkfat.c

    rb9cb911 r7cfe5c0  
    4040#include <stdio.h>
    4141#include <stdlib.h>
    42 #include <libblock.h>
     42#include <block.h>
    4343#include <mem.h>
    4444#include <loc.h>

  • uspace/app/mkmfs/mkmfs.c

    rb9cb911 r7cfe5c0  
    3939#include <stdio.h>
    4040#include <stdlib.h>
    41 #include <libblock.h>
     41#include <block.h>
    4242#include <unistd.h>
    4343#include <errno.h>

  • uspace/app/sportdmp/sportdmp.c

    rb9cb911 r7cfe5c0  
    140140                ssize_t i;
    141141                for (i = 0; i < read; i++) {
    142                         if ((buf[i] >= 32) && (buf[i] < 128))
    143                                 putchar((wchar_t) buf[i]);
    144                         else
    145                                 putchar('.');
    146                         fflush(stdout);
     142                        printf("%02hhx ", buf[i]);
    147143                }
     144                fflush(stdout);
    148145        }
    149146       

  • uspace/app/testwrit/Makefile

    rb9cb911 r7cfe5c0  
    11#
    2 # Copyright (c) 2011 Martin Decky
     2# Copyright (c) 2011 Frantisek Princ
    33# All rights reserved.
    44#
    … …  
    2828
    2929USPACE_PREFIX = ../..
    30 LIBRARY = libfb
     30BINARY = testwrit
    3131
    3232SOURCES = \
    33         fb.c \
    34         imgmap.c \
    35         screenbuffer.c
     33        testwrit.c
    3634
    3735include $(USPACE_PREFIX)/Makefile.common

  • uspace/app/trace/syscalls.c

    rb9cb911 r7cfe5c0  
    5353    [SYS_AS_AREA_DESTROY] = { "as_area_destroy",        1,      V_ERRNO },
    5454
    55     [SYS_IPC_CALL_SYNC_FAST] = { "ipc_call_sync_fast",  6,      V_ERRNO },
    56     [SYS_IPC_CALL_SYNC_SLOW] = { "ipc_call_sync_slow",  3,      V_ERRNO },
    5755    [SYS_IPC_CALL_ASYNC_FAST] = { "ipc_call_async_fast", 6,     V_HASH },
    5856    [SYS_IPC_CALL_ASYNC_SLOW] = { "ipc_call_async_slow", 2,     V_HASH },

  • uspace/app/trace/trace.c

    rb9cb911 r7cfe5c0  
    318318}
    319319
    320 static void sc_ipc_call_sync_fast(sysarg_t *sc_args)
    321 {
    322         ipc_call_t question, reply;
    323         int rc;
    324         int phoneid;
    325 
    326         phoneid = sc_args[0];
    327 
    328         IPC_SET_IMETHOD(question, sc_args[1]);
    329         IPC_SET_ARG1(question, sc_args[2]);
    330         IPC_SET_ARG2(question, sc_args[3]);
    331         IPC_SET_ARG3(question, sc_args[4]);
    332         IPC_SET_ARG4(question, 0);
    333         IPC_SET_ARG5(question, 0);
    334 
    335         memset(&reply, 0, sizeof(reply));
    336         rc = udebug_mem_read(sess, &reply.args, sc_args[5], sizeof(reply.args));
    337         if (rc < 0)
    338                 return;
    339        
    340         ipcp_call_sync(phoneid, &question, &reply);
    341 }
    342 
    343 static void sc_ipc_call_sync_slow_b(unsigned thread_id, sysarg_t *sc_args)
    344 {
    345         ipc_call_t question;
    346         int rc;
    347 
    348         memset(&question, 0, sizeof(question));
    349         rc = udebug_mem_read(sess, &question.args, sc_args[1],
    350             sizeof(question.args));
    351 
    352         if (rc < 0) {
    353                 printf("Error: mem_read->%d\n", rc);
    354                 return;
    355         }
    356 
    357         thread_ipc_req[thread_id] = question;
    358 }
    359 
    360 static void sc_ipc_call_sync_slow_e(unsigned thread_id, sysarg_t *sc_args)
    361 {
    362         ipc_call_t reply;
    363         int rc;
    364 
    365         memset(&reply, 0, sizeof(reply));
    366         rc = udebug_mem_read(sess, &reply.args, sc_args[2],
    367             sizeof(reply.args));
    368 
    369         if (rc < 0) {
    370                 printf("Error: mem_read->%d\n", rc);
    371                 return;
    372         }
    373 
    374         ipcp_call_sync(sc_args[0], &thread_ipc_req[thread_id], &reply);
    375 }
    376 
    377320static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc)
    378321{
    … …  
    408351                print_sc_args(sc_args, syscall_desc[sc_id].n_args);
    409352        }
    410 
    411         switch (sc_id) {
    412         case SYS_IPC_CALL_SYNC_SLOW:
    413                 sc_ipc_call_sync_slow_b(thread_id, sc_args);
    414                 break;
    415         default:
    416                 break;
    417         }
    418353}
    419354
    … …  
    447382        case SYS_IPC_CALL_ASYNC_SLOW:
    448383                sc_ipc_call_async_slow(sc_args, sc_rc);
    449                 break;
    450         case SYS_IPC_CALL_SYNC_FAST:
    451                 sc_ipc_call_sync_fast(sc_args);
    452                 break;
    453         case SYS_IPC_CALL_SYNC_SLOW:
    454                 sc_ipc_call_sync_slow_e(thread_id, sc_args);
    455384                break;
    456385        case SYS_IPC_WAIT:
Note: See TracChangeset for help on using the changeset viewer.