Changeset 03362fbd in mainline for uspace/app

Timestamp:

2013-02-09T23:14:45Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

22dfd38

Parents:

b5d2e57 (diff), 005b765 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Conflict resulting from bool.h → stdbool.h move and ddf structs turning opaque.
Fails to boot to shell console.

Location:

uspace/app

Files:

• bdsh/Makefile (modified) (1 diff)
• bdsh/cmds/modules/bdd/bdd.c (modified) (1 diff)
• bdsh/cmds/modules/cmp/cmp.c (added)
• bdsh/cmds/modules/cmp/cmp.h (added)
• bdsh/cmds/modules/cmp/cmp_def.h (added)
• bdsh/cmds/modules/cmp/entry.h (added)
• bdsh/cmds/modules/modules.h (modified) (2 diffs)
• bdsh/compl.c (modified) (1 diff)
• bdsh/config.h (modified) (1 diff)
• bdsh/errors.h (modified) (2 diffs)
• bdsh/input.c (modified) (5 diffs)
• bithenge/Makefile (moved) (moved from uspace/app/ext2info/Makefile ) (2 diffs)
• bithenge/Makefile.linux (added)
• bithenge/test.c (added)
• blkdump/blkdump.c (modified) (1 diff)
• date/Makefile (moved) (moved from uspace/lib/fb/Makefile ) (2 diffs)
• date/date.c (added)
• devctl/devctl.c (modified) (1 diff)
• edit/Makefile (modified) (1 diff)
• edit/edit.c (modified) (40 diffs)
• edit/search.c (added)
• edit/search.h (added)
• edit/search_impl.h (added)
• edit/sheet.c (modified) (4 diffs)
• edit/sheet.h (modified) (4 diffs)
• edit/sheet_impl.h (added)
• ext2info/ext2info.c (deleted)
• init/init.c (modified) (9 diffs)
• klog/Makefile (modified) (1 diff)
• klog/klog.c (modified) (2 diffs)
• logset/Makefile (moved) (moved from uspace/app/lsusb/Makefile ) (2 diffs)
• logset/main.c (added)
• mkbd/main.c (modified) (1 diff)
• mkexfat/exfat.h (modified) (1 diff)
• mkexfat/mkexfat.c (modified) (3 diffs)
• mkfat/mkfat.c (modified) (1 diff)
• mkmfs/mkmfs.c (modified) (1 diff)
• msim/arch_helenos/input.c (modified) (2 diffs)
• msim/arch_helenos/misc.c (modified) (1 diff)
• nettest2/nettest2.c (modified) (1 diff)
• nterm/conn.c (modified) (1 diff)
• nterm/nterm.c (modified) (1 diff)
• ping/ping.c (modified) (1 diff)
• sportdmp/sportdmp.c (modified) (3 diffs)
• stats/stats.c (modified) (1 diff)
• taskdump/taskdump.c (modified) (1 diff)
• tester/Makefile (modified) (3 diffs)
• tester/float/float1.c (added)
• tester/float/float1.def (added)
• tester/float/softfloat1.c (added)
• tester/float/softfloat1.def (added)
• tester/libext2/libext2_1.c (deleted)
• tester/libext2/libext2_1.def (deleted)
• tester/mm/common.c (modified) (1 diff)
• tester/mm/common.h (modified) (1 diff)
• tester/mm/mapping1.c (modified) (1 diff)
• tester/print/print5.def (modified) (1 diff)
• tester/print/print6.c (added)
• tester/print/print6.def (added)
• tester/stdio/logger1.c (added)
• tester/stdio/logger1.def (added)
• tester/stdio/logger2.c (added)
• tester/stdio/logger2.def (added)
• tester/tester.c (modified) (4 diffs)
• tester/tester.h (modified) (3 diffs)
• testwrit/Makefile (added)
• testwrit/testwrit.c (added)
• tetris/screen.c (modified) (1 diff)
• tetris/screen.h (modified) (1 diff)
• top/screen.h (modified) (2 diffs)
• trace/ipcp.c (modified) (10 diffs)
• trace/proto.c (modified) (3 diffs)
• trace/proto.h (modified) (1 diff)
• trace/syscalls.c (modified) (1 diff)
• trace/trace.c (modified) (4 diffs)
• usbinfo/Makefile (modified) (1 diff)
• usbinfo/desctree.c (modified) (1 diff)
• usbinfo/dump.c (modified) (1 diff)
• usbinfo/list.c (moved) (moved from uspace/app/lsusb/main.c ) (6 diffs)
• usbinfo/main.c (modified) (8 diffs)
• usbinfo/usbinfo.h (modified) (1 diff)
• vdemo/Makefile (added)
• vdemo/vdemo.c (added)
• vlaunch/Makefile (added)
• vlaunch/vlaunch.c (added)
• vterm/Makefile (added)
• vterm/vterm.c (added)
• vuhid/main.c (modified) (1 diff)
• websrv/websrv.c (modified) (1 diff)

uspace/app/bdsh/Makefile

@@ -53 +53 @@
         cmds/modules/unmount/unmount.c \
         cmds/modules/kcon/kcon.c \
+        cmds/modules/cmp/cmp.c \
         cmds/builtins/batch/batch.c \
         cmds/builtins/exit/exit.c \

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

@@ -38 +38 @@
 #include "cmds.h"
 
-#include <libblock.h>
+#include <block.h>
 #include <loc.h>
 #include <errno.h>

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

@@ -63 +63 @@
 #include "printf/entry.h"
 #include "echo/entry.h"
+#include "cmp/entry.h"
 
 /* Each .def function fills the module_t struct with the individual name, entry
@@ -86 +87 @@
 #include "printf/printf_def.h"
 #include "echo/echo_def.h"
+#include "cmp/cmp_def.h"
 
         {NULL, NULL, NULL, NULL}

uspace/app/bdsh/compl.c

@@ -28 +28 @@
  */
 
-#include <bool.h>
+#include <stdbool.h>
 #include <dirent.h>
 #include <errno.h>

uspace/app/bdsh/config.h

@@ -55 +55 @@
 #define PACKAGE_STRING "The brain dead shell"
 #define PACKAGE_TARNAME "bdsh"
-#define PACKAGE_VERSION "0.0.1"
-
-
-
+#define PACKAGE_VERSION "0.1.0"

uspace/app/bdsh/errors.h

@@ -30 +30 @@
 #define ERRORS_H
 
+#include <io/verify.h>
+
 /* Various error levels */
 #define CL_EFATAL  -1
@@ -46 +48 @@
 extern volatile int cli_errno;
 
-extern void cli_error(int, const char *, ...);
+extern void cli_error(int, const char *, ...)
+    PRINTF_ATTRIBUTE(2, 3);
 
 #endif

uspace/app/bdsh/input.c

@@ -41 +41 @@
 #include <errno.h>
 #include <assert.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <tinput.h>
 
@@ -67 +67 @@
 int process_input(cliuser_t *usr)
 {
-        token_t *tokens = calloc(WORD_MAX, sizeof(token_t));
-        if (tokens == NULL)
+        token_t *tokens_buf = calloc(WORD_MAX, sizeof(token_t));
+        if (tokens_buf == NULL)
                 return ENOMEM;
+        token_t *tokens = tokens_buf;
         
         char *cmd[WORD_MAX];
@@ -80 +81 @@
 
         if (usr->line == NULL) {
-                free(tokens);
+                free(tokens_buf);
                 return CL_EFAIL;
         }
@@ -213 +214 @@
         }
         tok_fini(&tok);
-        free(tokens);
+        free(tokens_buf);
 
         return rc;
@@ -268 +269 @@
         if (rc != EOK) {
                 /* Error in communication with console */
+                cli_quit = 1;
                 return;
         }

uspace/app/bithenge/Makefile

@@ -1 +1 @@
 #
-# Copyright (c) 2005 Martin Decky
-# Copyright (c) 2007 Jakub Jermar
+# Copyright (c) 2012 Sean Bartell
 # All rights reserved.
 #
@@ -29 +28 @@
 
 USPACE_PREFIX = ../..
-LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBEXT2_PREFIX)/libext2.a
-EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBEXT2_PREFIX)
-BINARY = ext2info
+LIBS = $(LIBBITHENGE_PREFIX)/libbithenge.a $(LIBBLOCK_PREFIX)/libblock.a
+EXTRA_CFLAGS = -I$(LIBBITHENGE_PREFIX)/include -D__HELENOS__
+BINARY = bithenge
 
 SOURCES = \
-        ext2info.c
+        test.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/blkdump/blkdump.c

@@ -40 +40 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <libblock.h>
+#include <block.h>
 #include <mem.h>
 #include <loc.h>

uspace/app/date/Makefile

@@ -1 +1 @@
 #
-# Copyright (c) 2011 Martin Decky
+# Copyright (c) 2012 Maurizio Lombardi
 # All rights reserved.
 #
@@ -28 +28 @@
 
 USPACE_PREFIX = ../..
-LIBRARY = libfb
+BINARY = date
 
 SOURCES = \
-        fb.c \
-        imgmap.c \
-        screenbuffer.c
+        date.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/devctl/devctl.c

@@ -151 +151 @@
         rc = devman_fun_offline(funh);
         if (rc != EOK) {
-                printf(NAME ": Failed to offline function '%s'.\n", path);
+                printf(NAME ": Failed to offline function '%s' (%s)\n", path,
+                    str_error(rc));
                 return rc;
         }

uspace/app/edit/Makefile

@@ -33 +33 @@
 SOURCES = \
         edit.c \
-        sheet.c
+        sheet.c \
+        search.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/edit/edit.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Jiri Svoboda
+ * Copyright (c) 2012 Martin Sucha
  * All rights reserved.
  *
@@ -46 +47 @@
 #include <macros.h>
 #include <clipboard.h>
-#include <bool.h>
+#include <stdbool.h>
 
 #include "sheet.h"
+#include "search.h"
 
 enum redraw_flags {
@@ -83 +85 @@
          */
         int ideal_column;
+        
+        char *previous_search;
+        bool previous_search_reverse;
 } pane_t;
 
@@ -91 +96 @@
 typedef struct {
         char *file_name;
-        sheet_t sh;
+        sheet_t *sh;
 } doc_t;
 
@@ -106 +111 @@
 #define BUF_SIZE 64
 #define TAB_WIDTH 8
-#define ED_INFTY 65536
 
 /** Maximum filename length that can be entered. */
@@ -126 +130 @@
 static int file_save_range(char const *fname, spt_t const *spos,
     spt_t const *epos);
-static char *filename_prompt(char const *prompt, char const *init_value);
 static char *range_get_str(spt_t const *spos, spt_t const *epos);
+
+static char *prompt(char const *prompt, char const *init_value);
 
 static void pane_text_display(void);
@@ -139 +144 @@
 static void delete_char_after(void);
 static void caret_update(void);
-static void caret_move(int drow, int dcolumn, enum dir_spec align_dir);
-static void caret_move_word_left(void);
-static void caret_move_word_right(void);
+static void caret_move_relative(int drow, int dcolumn, enum dir_spec align_dir, bool select);
+static void caret_move_absolute(int row, int column, enum dir_spec align_dir, bool select);
+static void caret_move(spt_t spt, bool select, bool update_ideal_column);
+static void caret_move_word_left(bool select);
+static void caret_move_word_right(bool select);
+static void caret_go_to_line_ask(void);
 
 static bool selection_active(void);
 static void selection_sel_all(void);
 static void selection_sel_range(spt_t pa, spt_t pb);
-static void selection_sel_prev_word(void);
-static void selection_sel_next_word(void);
 static void selection_get_points(spt_t *pa, spt_t *pb);
 static void selection_delete(void);
 static void selection_copy(void);
 static void insert_clipboard_data(void);
+
+static void search(char *pattern, bool reverse);
+static void search_prompt(bool reverse);
+static void search_repeat(void);
 
 static void pt_get_sof(spt_t *pt);
@@ -160 +170 @@
 static bool pt_is_delimiter(spt_t *pt);
 static bool pt_is_punctuation(spt_t *pt);
+static spt_t pt_find_word_left(spt_t spt);
+static spt_t pt_find_word_left(spt_t spt);
+
 static int tag_cmp(tag_t const *a, tag_t const *b);
 static int spt_cmp(spt_t const *a, spt_t const *b);
@@ -170 +183 @@
 {
         kbd_event_t ev;
-        coord_t coord;
         bool new_file;
-
-        spt_t pt;
+        int rc;
 
         con = console_init(stdin, stdout);
@@ -186 +197 @@
 
         /* Start with an empty sheet. */
-        sheet_init(&doc.sh);
+        rc = sheet_create(&doc.sh);
+        if (rc != EOK) {
+                printf("Out of memory.\n");
+                return -1;
+        }
 
         /* Place caret at the beginning of file. */
-        coord.row = coord.column = 1;
-        sheet_get_cell_pt(&doc.sh, &coord, dir_before, &pt);
-        sheet_place_tag(&doc.sh, &pt, &pane.caret_pos);
-        pane.ideal_column = coord.column;
+        spt_t sof;
+        pt_get_sof(&sof);
+        sheet_place_tag(doc.sh, &sof, &pane.caret_pos);
+        pane.ideal_column = 1;
 
         if (argc == 2) {
@@ -208 +223 @@
                 new_file = true;
 
+        /* Place selection start tag. */
+        sheet_place_tag(doc.sh, &sof, &pane.sel_start);
+
         /* Move to beginning of file. */
-        caret_move(-ED_INFTY, -ED_INFTY, dir_before);
-
-        /* Place selection start tag. */
-        tag_get_pt(&pane.caret_pos, &pt);
-        sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
+        pt_get_sof(&sof);
+        caret_move(sof, true, true);
 
         /* Initial display */
@@ -361 +376 @@
 static void key_handle_ctrl(kbd_event_t const *ev)
 {
+        spt_t pt;
         switch (ev->key) {
         case KC_Q:
@@ -392 +408 @@
                 selection_sel_all();
                 break;
-        case KC_W:
-                if (selection_active())
-                        break;
-                selection_sel_prev_word();
-                selection_delete();
-                break;
         case KC_RIGHT:
-                caret_move_word_right();
+                caret_move_word_right(false);
                 break;
         case KC_LEFT:
-                caret_move_word_left();
+                caret_move_word_left(false);
+                break;
+        case KC_L:
+                caret_go_to_line_ask();
+                break;
+        case KC_F:
+                search_prompt(false);
+                break;
+        case KC_N:
+                search_repeat();
+                break;
+        case KC_HOME:
+                pt_get_sof(&pt);
+                caret_move(pt, false, true);
+                break;
+        case KC_END:
+                pt_get_eof(&pt);
+                caret_move(pt, false, true);
                 break;
         default:
@@ -411 +438 @@
 static void key_handle_shift_ctrl(kbd_event_t const *ev)
 {
+        spt_t pt;
         switch(ev->key) {
         case KC_LEFT:
-                selection_sel_prev_word();
+                caret_move_word_left(true);
                 break;
         case KC_RIGHT:
-                selection_sel_next_word();
+                caret_move_word_right(true);
+                break;
+        case KC_F:
+                search_prompt(true);
+                break;
+        case KC_HOME:
+                pt_get_sof(&pt);
+                caret_move(pt, true, true);
+                break;
+        case KC_END:
+                pt_get_eof(&pt);
+                caret_move(pt, true, true);
                 break;
         default:
@@ -423 +462 @@
 }
 
-static void key_handle_movement(unsigned int key, bool select)
-{
-        spt_t pt;
-        spt_t caret_pt;
+/** Move caret while preserving or resetting selection. */
+static void caret_move(spt_t new_caret_pt, bool select, bool update_ideal_column)
+{
+        spt_t old_caret_pt, old_sel_pt;
         coord_t c_old, c_new;
         bool had_sel;
 
         /* Check if we had selection before. */
-        tag_get_pt(&pane.caret_pos, &caret_pt);
-        tag_get_pt(&pane.sel_start, &pt);
-        had_sel = !spt_equal(&caret_pt, &pt);
-
-        switch (key) {
-        case KC_LEFT:
-                caret_move(0, -1, dir_before);
-                break;
-        case KC_RIGHT:
-                caret_move(0, 0, dir_after);
-                break;
-        case KC_UP:
-                caret_move(-1, 0, dir_before);
-                break;
-        case KC_DOWN:
-                caret_move(+1, 0, dir_before);
-                break;
-        case KC_HOME:
-                caret_move(0, -ED_INFTY, dir_before);
-                break;
-        case KC_END:
-                caret_move(0, +ED_INFTY, dir_before);
-                break;
-        case KC_PAGE_UP:
-                caret_move(-pane.rows, 0, dir_before);
-                break;
-        case KC_PAGE_DOWN:
-                caret_move(+pane.rows, 0, dir_before);
-                break;
-        default:
-                break;
-        }
+        tag_get_pt(&pane.caret_pos, &old_caret_pt);
+        tag_get_pt(&pane.sel_start, &old_sel_pt);
+        had_sel = !spt_equal(&old_caret_pt, &old_sel_pt);
+
+        /* Place tag of the caret */
+        sheet_remove_tag(doc.sh, &pane.caret_pos);
+        sheet_place_tag(doc.sh, &new_caret_pt, &pane.caret_pos);
 
         if (select == false) {
                 /* Move sel_start to the same point as caret. */
-                sheet_remove_tag(&doc.sh, &pane.sel_start);
-                tag_get_pt(&pane.caret_pos, &pt);
-                sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
-        }
-
+                sheet_remove_tag(doc.sh, &pane.sel_start);
+                sheet_place_tag(doc.sh, &new_caret_pt, &pane.sel_start);
+        }
+
+        spt_get_coord(&new_caret_pt, &c_new);
         if (select) {
-                tag_get_pt(&pane.caret_pos, &pt);
-                spt_get_coord(&caret_pt, &c_old);
-                spt_get_coord(&pt, &c_new);
+                spt_get_coord(&old_caret_pt, &c_old);
 
                 if (c_old.row == c_new.row)
@@ -485 +497 @@
                 pane.rflags |= REDRAW_TEXT;
         }
+        
+        if (update_ideal_column)
+                pane.ideal_column = c_new.column;
+        
+        caret_update();
+}
+
+static void key_handle_movement(unsigned int key, bool select)
+{
+        spt_t pt;
+        switch (key) {
+        case KC_LEFT:
+                caret_move_relative(0, -1, dir_before, select);
+                break;
+        case KC_RIGHT:
+                caret_move_relative(0, 0, dir_after, select);
+                break;
+        case KC_UP:
+                caret_move_relative(-1, 0, dir_before, select);
+                break;
+        case KC_DOWN:
+                caret_move_relative(+1, 0, dir_before, select);
+                break;
+        case KC_HOME:
+                tag_get_pt(&pane.caret_pos, &pt);
+                pt_get_sol(&pt, &pt);
+                caret_move(pt, select, true);
+                break;
+        case KC_END:
+                tag_get_pt(&pane.caret_pos, &pt);
+                pt_get_eol(&pt, &pt);
+                caret_move(pt, select, true);
+                break;
+        case KC_PAGE_UP:
+                caret_move_relative(-pane.rows, 0, dir_before, select);
+                break;
+        case KC_PAGE_DOWN:
+                caret_move_relative(+pane.rows, 0, dir_before, select);
+                break;
+        default:
+                break;
+        }
 }
 
@@ -520 +574 @@
         char *fname;
         
-        fname = filename_prompt("Save As", old_fname);
+        fname = prompt("Save As", old_fname);
         if (fname == NULL) {
                 status_display("Save cancelled.");
@@ -535 +589 @@
 }
 
-/** Ask for a file name. */
-static char *filename_prompt(char const *prompt, char const *init_value)
+/** Ask for a string. */
+static char *prompt(char const *prompt, char const *init_value)
 {
         kbd_event_t ev;
@@ -657 +711 @@
 
         do {
-                sheet_copy_out(&doc.sh, &sp, epos, buf, BUF_SIZE, &bep);
+                sheet_copy_out(doc.sh, &sp, epos, buf, BUF_SIZE, &bep);
                 bytes = str_size(buf);
 
@@ -692 +746 @@
 
         while (true) {
-                sheet_copy_out(&doc.sh, &sp, epos, &buf[bpos], buf_size - bpos,
+                sheet_copy_out(doc.sh, &sp, epos, &buf[bpos], buf_size - bpos,
                     &bep);
                 bytes = str_size(&buf[bpos]);
@@ -714 +768 @@
         int sh_rows, rows;
 
-        sheet_get_num_rows(&doc.sh, &sh_rows);
+        sheet_get_num_rows(doc.sh, &sh_rows);
         rows = min(sh_rows - pane.sh_row + 1, pane.rows);
 
@@ -784 +838 @@
                 rbc.row = pane.sh_row + i;
                 rbc.column = pane.sh_column;
-                sheet_get_cell_pt(&doc.sh, &rbc, dir_before, &rb);
+                sheet_get_cell_pt(doc.sh, &rbc, dir_before, &rb);
 
                 /* Ending point for row display */
                 rec.row = pane.sh_row + i;
                 rec.column = pane.sh_column + pane.columns;
-                sheet_get_cell_pt(&doc.sh, &rec, dir_before, &re);
+                sheet_get_cell_pt(doc.sh, &rec, dir_before, &re);
 
                 /* Copy the text of the row to the buffer. */
-                sheet_copy_out(&doc.sh, &rb, &re, row_buf, ROW_BUF_SIZE, &dep);
+                sheet_copy_out(doc.sh, &rb, &re, row_buf, ROW_BUF_SIZE, &dep);
 
                 /* Display text from the buffer. */
@@ -842 +896 @@
                 /* Fill until the end of display area. */
 
-                if (str_length(row_buf) < (unsigned) scr_columns)
-                        fill = scr_columns - str_length(row_buf);
+                if ((unsigned)s_column - 1 < scr_columns)
+                        fill = scr_columns - (s_column - 1);
                 else
                         fill = 0;
@@ -861 +915 @@
         spt_t caret_pt;
         coord_t coord;
+        int last_row;
 
         tag_get_pt(&pane.caret_pos, &caret_pt);
         spt_get_coord(&caret_pt, &coord);
 
+        sheet_get_num_rows(doc.sh, &last_row);
+
         const char *fname = (doc.file_name != NULL) ? doc.file_name : "<unnamed>";
 
         console_set_pos(con, 0, scr_rows - 1);
         console_set_style(con, STYLE_INVERTED);
-        int n = printf(" %d, %d: File '%s'. Ctrl-Q Quit  Ctrl-S Save  "
-            "Ctrl-E Save As", coord.row, coord.column, fname);
+        int n = printf(" %d, %d (%d): File '%s'. Ctrl-Q Quit  Ctrl-S Save  "
+            "Ctrl-E Save As", coord.row, coord.column, last_row, fname);
         
         int pos = scr_columns - 1 - n;
@@ -906 +963 @@
         cbuf[offs] = '\0';
 
-        (void) sheet_insert(&doc.sh, &pt, dir_before, cbuf);
+        (void) sheet_insert(doc.sh, &pt, dir_before, cbuf);
 
         pane.rflags |= REDRAW_ROW;
@@ -923 +980 @@
 
         coord.column -= 1;
-        sheet_get_cell_pt(&doc.sh, &coord, dir_before, &sp);
-
-        (void) sheet_delete(&doc.sh, &sp, &ep);
+        sheet_get_cell_pt(doc.sh, &coord, dir_before, &sp);
+
+        (void) sheet_delete(doc.sh, &sp, &ep);
 
         pane.rflags |= REDRAW_ROW;
@@ -941 +998 @@
         spt_get_coord(&sp, &sc);
 
-        sheet_get_cell_pt(&doc.sh, &sc, dir_after, &ep);
+        sheet_get_cell_pt(doc.sh, &sc, dir_after, &ep);
         spt_get_coord(&ep, &ec);
 
-        (void) sheet_delete(&doc.sh, &sp, &ep);
+        (void) sheet_delete(doc.sh, &sp, &ep);
 
         pane.rflags |= REDRAW_ROW;
@@ -991 +1048 @@
 }
 
-/** Change the caret position.
+/** Relatively move caret position.
  *
  * Moves caret relatively to the current position. Looking at the first
@@ -997 +1054 @@
  * to a new character cell, and thus a new character. Then we either go to the
  * point before the the character or after it, depending on @a align_dir.
+ *
+ * @param select true if the selection tag should stay where it is
  */
-static void caret_move(int drow, int dcolumn, enum dir_spec align_dir)
+static void caret_move_relative(int drow, int dcolumn, enum dir_spec align_dir,
+    bool select)
 {
         spt_t pt;
@@ -1016 +1076 @@
                 else {
                         coord.row--;
-                        sheet_get_row_width(&doc.sh, coord.row, &coord.column);
+                        sheet_get_row_width(doc.sh, coord.row, &coord.column);
                 }
         }
         if (drow > 0) {
-                sheet_get_num_rows(&doc.sh, &num_rows);
+                sheet_get_num_rows(doc.sh, &num_rows);
                 if (coord.row > num_rows) coord.row = num_rows;
         }
@@ -1033 +1093 @@
          * coordinates. The character can be wider than one cell (e.g. tab).
          */
-        sheet_get_cell_pt(&doc.sh, &coord, align_dir, &pt);
-        sheet_remove_tag(&doc.sh, &pane.caret_pos);
-        sheet_place_tag(&doc.sh, &pt, &pane.caret_pos);
+        sheet_get_cell_pt(doc.sh, &coord, align_dir, &pt);
 
         /* For non-vertical movement set the new value for @c ideal_column. */
-        if (!pure_vertical) {
-                spt_get_coord(&pt, &coord);
-                pane.ideal_column = coord.column;
-        }
-
-        caret_update();
-}
-
-static void caret_move_word_left(void) 
-{
+        caret_move(pt, select, !pure_vertical);
+}
+
+/** Absolutely move caret position.
+ *
+ * Moves caret to a specified position. We get to a new character cell, and
+ * thus a new character. Then we either go to the point before the the character
+ * or after it, depending on @a align_dir.
+ *
+ * @param select true if the selection tag should stay where it is
+ */
+static void caret_move_absolute(int row, int column, enum dir_spec align_dir,
+    bool select)
+{
+        coord_t coord;
+        coord.row = row;
+        coord.column = column;
+        
         spt_t pt;
-
+        sheet_get_cell_pt(doc.sh, &coord, align_dir, &pt);
+        
+        caret_move(pt, select, true);
+}
+
+/** Find beginning of a word to the left of spt */
+static spt_t pt_find_word_left(spt_t spt) 
+{
         do {
-                caret_move(0, -1, dir_before);
-
-                tag_get_pt(&pane.caret_pos, &pt);
-
-                sheet_remove_tag(&doc.sh, &pane.sel_start);
-                sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
-        } while (!pt_is_word_beginning(&pt));
-
-        pane.rflags |= REDRAW_TEXT;
-}
-
-static void caret_move_word_right(void) 
+                spt_prev_char(spt, &spt);
+        } while (!pt_is_word_beginning(&spt));
+        return spt;
+}
+
+/** Find beginning of a word to the right of spt */
+static spt_t pt_find_word_right(spt_t spt) 
+{
+        do {
+                spt_next_char(spt, &spt);
+        } while (!pt_is_word_beginning(&spt));
+        return spt;
+}
+
+static void caret_move_word_left(bool select) 
 {
         spt_t pt;
-
-        do {
-                caret_move(0, 0, dir_after);
-
-                tag_get_pt(&pane.caret_pos, &pt);
-
-                sheet_remove_tag(&doc.sh, &pane.sel_start);
-                sheet_place_tag(&doc.sh, &pt, &pane.sel_start);
-        } while (!pt_is_word_beginning(&pt));
-
-        pane.rflags |= REDRAW_TEXT;
+        tag_get_pt(&pane.caret_pos, &pt);
+        spt_t word_left = pt_find_word_left(pt);
+        caret_move(word_left, select, true);
+}
+
+static void caret_move_word_right(bool select) 
+{
+        spt_t pt;
+        tag_get_pt(&pane.caret_pos, &pt);
+        spt_t word_right = pt_find_word_right(pt);
+        caret_move(word_right, select, true);
+}
+
+/** Ask for line and go to it. */
+static void caret_go_to_line_ask(void)
+{
+        char *sline;
+        
+        sline = prompt("Go to line", "");
+        if (sline == NULL) {
+                status_display("Go to line cancelled.");
+                return;
+        }
+        
+        char *endptr;
+        int line = strtol(sline, &endptr, 10);
+        if (*endptr != '\0') {
+                free(sline);
+                status_display("Invalid number entered.");
+                return;
+        }
+        free(sline);
+        
+        caret_move_absolute(line, pane.ideal_column, dir_before, false);
+}
+
+/* Search operations */
+static int search_spt_producer(void *data, wchar_t *ret)
+{
+        assert(data != NULL);
+        assert(ret != NULL);
+        spt_t *spt = data;
+        *ret = spt_next_char(*spt, spt);
+        return EOK;
+}
+
+static int search_spt_reverse_producer(void *data, wchar_t *ret)
+{
+        assert(data != NULL);
+        assert(ret != NULL);
+        spt_t *spt = data;
+        *ret = spt_prev_char(*spt, spt);
+        return EOK;
+}
+
+static int search_spt_mark(void *data, void **mark)
+{
+        assert(data != NULL);
+        assert(mark != NULL);
+        spt_t *spt = data;
+        spt_t *new = calloc(1, sizeof(spt_t));
+        *mark = new;
+        if (new == NULL)
+                return ENOMEM;
+        *new = *spt;
+        return EOK;
+}
+
+static void search_spt_mark_free(void *data)
+{
+        free(data);
+}
+
+static search_ops_t search_spt_ops = {
+        .equals = char_exact_equals,
+        .producer = search_spt_producer,
+        .mark = search_spt_mark,
+        .mark_free = search_spt_mark_free,
+};
+
+static search_ops_t search_spt_reverse_ops = {
+        .equals = char_exact_equals,
+        .producer = search_spt_reverse_producer,
+        .mark = search_spt_mark,
+        .mark_free = search_spt_mark_free,
+};
+
+/** Ask for line and go to it. */
+static void search_prompt(bool reverse)
+{
+        char *pattern;
+        
+        const char *prompt_text = "Find next";
+        if (reverse)
+                prompt_text = "Find previous";
+        
+        const char *default_value = "";
+        if (pane.previous_search)
+                default_value = pane.previous_search;
+        
+        pattern = prompt(prompt_text, default_value);
+        if (pattern == NULL) {
+                status_display("Search cancelled.");
+                return;
+        }
+        
+        if (pane.previous_search)
+                free(pane.previous_search);
+        pane.previous_search = pattern;
+        pane.previous_search_reverse = reverse;
+        
+        search(pattern, reverse);
+}
+
+static void search_repeat(void)
+{
+        if (pane.previous_search == NULL) {
+                status_display("No previous search to repeat.");
+                return;
+        }
+        
+        search(pane.previous_search, pane.previous_search_reverse);
+}
+
+static void search(char *pattern, bool reverse)
+{
+        status_display("Searching...");
+        
+        spt_t sp, producer_pos;
+        tag_get_pt(&pane.caret_pos, &sp);
+        
+        /* Start searching on the position before/after caret */
+        if (!reverse) {
+                spt_next_char(sp, &sp);
+        }
+        else {
+                spt_prev_char(sp, &sp);
+        }
+        producer_pos = sp;
+        
+        search_ops_t ops = search_spt_ops;
+        if (reverse)
+                ops = search_spt_reverse_ops;
+        
+        search_t *search = search_init(pattern, &producer_pos, ops, reverse);
+        if (search == NULL) {
+                status_display("Failed initializing search.");
+                return;
+        }
+        
+        match_t match;
+        int rc = search_next_match(search, &match);
+        if (rc != EOK) {
+                status_display("Failed searching.");
+                search_fini(search);
+        }
+        
+        if (match.end) {
+                status_display("Match found.");
+                assert(match.end != NULL);
+                spt_t *end = match.end;
+                caret_move(*end, false, true);
+                while (match.length > 0) {
+                        match.length--;
+                        if (reverse) {
+                                spt_next_char(*end, end);
+                        }
+                        else {
+                                spt_prev_char(*end, end);
+                        }
+                }
+                caret_move(*end, true, true);
+                free(end);
+        }
+        else {
+                status_display("Not found.");
+        }
+        
+        search_fini(search);
 }
 
@@ -1115 +1359 @@
 
         if (rel < 0)
-                sheet_delete(&doc.sh, &pa, &pb);
+                sheet_delete(doc.sh, &pa, &pb);
         else
-                sheet_delete(&doc.sh, &pb, &pa);
+                sheet_delete(doc.sh, &pb, &pa);
 
         if (ca.row == cb.row)
@@ -1139 +1383 @@
 static void selection_sel_range(spt_t pa, spt_t pb)
 {
-        sheet_remove_tag(&doc.sh, &pane.sel_start);
-        sheet_place_tag(&doc.sh, &pa, &pane.sel_start);
-        sheet_remove_tag(&doc.sh, &pane.caret_pos);
-        sheet_place_tag(&doc.sh, &pb, &pane.caret_pos);
+        sheet_remove_tag(doc.sh, &pane.sel_start);
+        sheet_place_tag(doc.sh, &pa, &pane.sel_start);
+        sheet_remove_tag(doc.sh, &pane.caret_pos);
+        sheet_place_tag(doc.sh, &pb, &pane.caret_pos);
 
         pane.rflags |= REDRAW_TEXT;
         caret_update();
-}
-
-/** Add the previous word to the selection */
-static void selection_sel_prev_word(void)
-{
-        spt_t cpt, wpt, spt, ept;
-
-        selection_get_points(&spt, &ept);
-
-        tag_get_pt(&pane.caret_pos, &cpt);
-        caret_move_word_left();
-        tag_get_pt(&pane.caret_pos, &wpt);
-
-        if (spt_cmp(&spt, &cpt) == 0)
-                selection_sel_range(ept, wpt);
-        else
-                selection_sel_range(spt, wpt);
-}
-
-/** Add the next word to the selection */
-static void selection_sel_next_word(void)
-{
-        spt_t cpt, wpt, spt, ept;
-
-        selection_get_points(&spt, &ept);
-
-        tag_get_pt(&pane.caret_pos, &cpt);
-        caret_move_word_right();
-        tag_get_pt(&pane.caret_pos, &wpt);
-
-        if (spt_cmp(&ept, &cpt) == 0)
-                selection_sel_range(spt, wpt);
-        else
-                selection_sel_range(ept, wpt);
 }
 
@@ -1225 +1435 @@
 
         coord.row = coord.column = 1;
-        sheet_get_cell_pt(&doc.sh, &coord, dir_before, pt);
+        sheet_get_cell_pt(doc.sh, &coord, dir_before, pt);
 }
 
@@ -1234 +1444 @@
         int num_rows;
 
-        sheet_get_num_rows(&doc.sh, &num_rows);
+        sheet_get_num_rows(doc.sh, &num_rows);
         coord.row = num_rows + 1;
         coord.column = 1;
 
-        sheet_get_cell_pt(&doc.sh, &coord, dir_after, pt);
+        sheet_get_cell_pt(doc.sh, &coord, dir_after, pt);
 }
 
@@ -1249 +1459 @@
         coord.column = 1;
 
-        sheet_get_cell_pt(&doc.sh, &coord, dir_before, spt);
+        sheet_get_cell_pt(doc.sh, &coord, dir_before, spt);
 }
 
@@ -1259 +1469 @@
 
         spt_get_coord(cpt, &coord);
-        sheet_get_row_width(&doc.sh, coord.row, &row_width);
+        sheet_get_row_width(doc.sh, coord.row, &row_width);
         coord.column = row_width - 1;
 
-        sheet_get_cell_pt(&doc.sh, &coord, dir_after, ept);
+        sheet_get_cell_pt(doc.sh, &coord, dir_after, ept);
 }
 
@@ -1288 +1498 @@
 
         coord.column -= 1;
-        sheet_get_cell_pt(&doc.sh, &coord, dir_before, &lp);
+        sheet_get_cell_pt(doc.sh, &coord, dir_before, &lp);
 
         return pt_is_delimiter(&lp)
@@ -1310 +1520 @@
 
         coord.column += 1;
-        sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
+        sheet_get_cell_pt(doc.sh, &coord, dir_after, &rp);
 
         ch = range_get_str(pt, &rp);
@@ -1336 +1546 @@
 
         coord.column += 1;
-        sheet_get_cell_pt(&doc.sh, &coord, dir_after, &rp);
+        sheet_get_cell_pt(doc.sh, &coord, dir_after, &rp);
 
         ch = range_get_str(pt, &rp);

uspace/app/edit/sheet.c

@@ -57 +57 @@
 
 #include "sheet.h"
+#include "sheet_impl.h"
 
 enum {
@@ -66 +67 @@
 
 /** Initialize an empty sheet. */
-int sheet_init(sheet_t *sh)
-{
+int sheet_create(sheet_t **rsh)
+{
+        sheet_t *sh;
+
+        sh = calloc(1, sizeof(sheet_t));
+        if (sh == NULL)
+                return ENOMEM;
+
         sh->dbuf_size = INITIAL_SIZE;
         sh->text_size = 0;
@@ -77 +84 @@
         list_initialize(&sh->tags);
 
+        *rsh = sh;
         return EOK;
 }
@@ -315 +323 @@
 }
 
+/** Get a character at spt and return next spt */
+wchar_t spt_next_char(spt_t spt, spt_t *next)
+{
+        wchar_t ch = str_decode(spt.sh->data, &spt.b_off, spt.sh->text_size);
+        if (next)
+                *next = spt;
+        return ch;
+}
+
+wchar_t spt_prev_char(spt_t spt, spt_t *prev)
+{
+        wchar_t ch = str_decode_reverse(spt.sh->data, &spt.b_off, spt.sh->text_size);
+        if (prev)
+                *prev = spt;
+        return ch;
+}
+
 /** Place a tag on the specified s-point. */
 void sheet_place_tag(sheet_t *sh, spt_t const *pt, tag_t *tag)

uspace/app/edit/sheet.h

@@ -39 +39 @@
 #include <adt/list.h>
 #include <sys/types.h>
-#include <bool.h>
+#include <stdbool.h>
 
 /** Direction (in linear space) */
@@ -50 +50 @@
 
 /** Sheet */
-typedef struct {
-        /* Note: This structure is opaque for the user. */
-
-        size_t text_size;
-        size_t dbuf_size;
-        char *data;
-
-        list_t tags;
-} sheet_t;
+struct sheet;
+typedef struct sheet sheet_t;
 
 /** Character cell coordinates
@@ -97 +90 @@
 } tag_t;
 
-extern int sheet_init(sheet_t *);
+extern int sheet_create(sheet_t **);
 extern int sheet_insert(sheet_t *, spt_t *, enum dir_spec, char *);
 extern int sheet_delete(sheet_t *, spt_t *, spt_t *);
@@ -108 +101 @@
 extern void spt_get_coord(spt_t const *, coord_t *);
 extern bool spt_equal(spt_t const *, spt_t const *);
+extern wchar_t spt_next_char(spt_t, spt_t *);
+extern wchar_t spt_prev_char(spt_t, spt_t *);
 
 extern void sheet_place_tag(sheet_t *, spt_t const *, tag_t *);

uspace/app/init/init.c

@@ -37 +37 @@
 #include <stdio.h>
 #include <unistd.h>
+#include <stdarg.h>
 #include <vfs/vfs.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -65 +66 @@
 #define SRV_CONSOLE  "/srv/console"
 #define APP_GETTERM  "/app/getterm"
+
+#define SRV_COMPOSITOR  "/srv/compositor"
+
+#define HID_INPUT              "hid/input"
+#define HID_OUTPUT             "hid/output"
+#define HID_COMPOSITOR_SERVER  ":0"
+
+#define srv_start(path, ...) \
+        srv_startl(path, path, ##__VA_ARGS__, NULL)
 
 /** Print banner */
@@ -143 +153 @@
 }
 
-static void spawn(const char *fname)
-{
-        int rc;
+static int srv_startl(const char *path, ...)
+{
         struct stat s;
-        
-        if (stat(fname, &s) == ENOENT)
-                return;
-        
-        printf("%s: Spawning %s\n", NAME, fname);
-        rc = task_spawnl(NULL, fname, fname, NULL);
-        if (rc != EOK) {
-                printf("%s: Error spawning %s (%s)\n", NAME, fname,
-                    str_error(rc));
-        }
-}
-
-static void srv_start(const char *fname)
-{
+        if (stat(path, &s) == ENOENT) {
+                printf("%s: Unable to stat %s\n", NAME, path);
+                return ENOENT;
+        }
+        
+        printf("%s: Starting %s\n", NAME, path);
+        
+        va_list ap;
+        const char *arg;
+        int cnt = 0;
+        
+        va_start(ap, path);
+        do {
+                arg = va_arg(ap, const char *);
+                cnt++;
+        } while (arg != NULL);
+        va_end(ap);
+        
+        va_start(ap, path);
         task_id_t id;
+        int rc = task_spawn(&id, path, cnt, ap);
+        va_end(ap);
+        
+        if (rc != EOK) {
+                printf("%s: Error spawning %s (%s)\n", NAME, path,
+                    str_error(rc));
+                return rc;
+        }
+        
+        if (!id) {
+                printf("%s: Error spawning %s (invalid task id)\n", NAME,
+                    path);
+                return EINVAL;
+        }
+        
         task_exit_t texit;
-        int rc, retval;
-        struct stat s;
-        
-        if (stat(fname, &s) == ENOENT)
-                return;
-        
-        printf("%s: Starting %s\n", NAME, fname);
-        rc = task_spawnl(&id, fname, fname, NULL);
-        if (!id) {
-                printf("%s: Error spawning %s (%s)\n", NAME, fname,
-                    str_error(rc));
-                return;
-        }
-        
+        int retval;
         rc = task_wait(id, &texit, &retval);
         if (rc != EOK) {
-                printf("%s: Error waiting for %s (%s)\n", NAME, fname,
-                    str_error(rc));
-                return;
+                printf("%s: Error waiting for %s (%s)\n", NAME, path,
+                    str_error(rc));
+                return rc;
         }
         
         if (texit != TASK_EXIT_NORMAL) {
                 printf("%s: Server %s failed to start (unexpectedly "
-                    "terminated)\n", NAME, fname);
-                return;
-        }
-
-        if (retval != 0) {
+                    "terminated)\n", NAME, path);
+                return EINVAL;
+        }
+        
+        if (retval != 0)
                 printf("%s: Server %s failed to start (exit code %d)\n", NAME,
-                        fname, retval);
-        }
-}
-
-static void console(const char *isvc, const char *fbsvc)
-{
-        printf("%s: Spawning %s %s %s\n", NAME, SRV_CONSOLE, isvc, fbsvc);
-        
+                    path, retval);
+        
+        return retval;
+}
+
+static int console(const char *isvc, const char *osvc)
+{
         /* Wait for the input service to be ready */
         service_id_t service_id;
@@ -206 +221 @@
                 printf("%s: Error waiting on %s (%s)\n", NAME, isvc,
                     str_error(rc));
-                return;
-        }
-        
-        /* Wait for the framebuffer service to be ready */
-        rc = loc_service_get_id(fbsvc, &service_id, IPC_FLAG_BLOCKING);
-        if (rc != EOK) {
-                printf("%s: Error waiting on %s (%s)\n", NAME, fbsvc,
-                    str_error(rc));
-                return;
-        }
-        
-        rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, isvc, fbsvc, NULL);
-        if (rc != EOK) {
-                printf("%s: Error spawning %s %s %s (%s)\n", NAME, SRV_CONSOLE,
-                    isvc, fbsvc, str_error(rc));
-        }
+                return rc;
+        }
+        
+        /* Wait for the output service to be ready */
+        rc = loc_service_get_id(osvc, &service_id, IPC_FLAG_BLOCKING);
+        if (rc != EOK) {
+                printf("%s: Error waiting on %s (%s)\n", NAME, osvc,
+                    str_error(rc));
+                return rc;
+        }
+        
+        return srv_start(SRV_CONSOLE, isvc, osvc);
+}
+
+static int compositor(const char *isvc, const char *name)
+{
+        /* Wait for the input service to be ready */
+        service_id_t service_id;
+        int rc = loc_service_get_id(isvc, &service_id, IPC_FLAG_BLOCKING);
+        if (rc != EOK) {
+                printf("%s: Error waiting on %s (%s)\n", NAME, isvc,
+                    str_error(rc));
+                return rc;
+        }
+        
+        return srv_start(SRV_COMPOSITOR, isvc, name);
+}
+
+static int gui_start(const char *app, const char *srv_name)
+{
+        char winreg[50];
+        snprintf(winreg, sizeof(winreg), "%s%s%s", "comp", srv_name, "/winreg");
+        
+        printf("%s: Spawning %s %s\n", NAME, app, winreg);
+        
+        task_id_t id;
+        int rc = task_spawnl(&id, app, app, winreg, NULL);
+        if (rc != EOK) {
+                printf("%s: Error spawning %s %s (%s)\n", NAME, app,
+                    winreg, str_error(rc));
+                return -1;
+        }
+        
+        task_exit_t texit;
+        int retval;
+        rc = task_wait(id, &texit, &retval);
+        if ((rc != EOK) || (texit != TASK_EXIT_NORMAL)) {
+                printf("%s: Error retrieving retval from %s (%s)\n", NAME,
+                    app, str_error(rc));
+                return -1;
+        }
+        
+        return retval;
 }
 
@@ -227 +279 @@
 {
         char term[LOC_NAME_MAXLEN];
-        int rc;
-        
         snprintf(term, LOC_NAME_MAXLEN, "%s/%s", LOCFS_MOUNT_POINT, svc);
         
@@ -235 +285 @@
         /* Wait for the terminal service to be ready */
         service_id_t service_id;
-        rc = loc_service_get_id(svc, &service_id, IPC_FLAG_BLOCKING);
+        int rc = loc_service_get_id(svc, &service_id, IPC_FLAG_BLOCKING);
         if (rc != EOK) {
                 printf("%s: Error waiting on %s (%s)\n", NAME, term,
@@ -279 +329 @@
         if (!mount_root(STRING(RDFMT))) {
                 printf("%s: Exiting\n", NAME);
-                return -1;
+                return 1;
         }
         
         /* Make sure tmpfs is running. */
-        if (str_cmp(STRING(RDFMT), "tmpfs") != 0) {
-                spawn("/srv/tmpfs");
-        }
-        
-        spawn("/srv/locfs");
-        spawn("/srv/taskmon");
+        if (str_cmp(STRING(RDFMT), "tmpfs") != 0)
+                srv_start("/srv/tmpfs");
+        
+        srv_start("/srv/locfs");
+        srv_start("/srv/taskmon");
         
         if (!mount_locfs()) {
                 printf("%s: Exiting\n", NAME);
-                return -2;
+                return 2;
         }
         
         mount_tmpfs();
         
-        spawn("/srv/devman");
-        spawn("/srv/apic");
-        spawn("/srv/i8259");
-        spawn("/srv/obio");
+        srv_start("/srv/devman");
+        srv_start("/srv/apic");
+        srv_start("/srv/i8259");
+        srv_start("/srv/obio");
         srv_start("/srv/cuda_adb");
         srv_start("/srv/s3c24xx_uart");
         srv_start("/srv/s3c24xx_ts");
         
-        spawn("/srv/loopip");
-        spawn("/srv/ethip");
-        spawn("/srv/inetsrv");
-        spawn("/srv/tcp");
-        spawn("/srv/udp");
-        
-        spawn("/srv/fb");
-        spawn("/srv/input");
-        console("hid/input", "hid/fb0");
-        
-        spawn("/srv/clipboard");
-        spawn("/srv/remcons");
+        srv_start("/srv/loopip");
+        srv_start("/srv/ethip");
+        srv_start("/srv/inetsrv");
+        srv_start("/srv/tcp");
+        srv_start("/srv/udp");
+        
+        srv_start("/srv/clipboard");
+        srv_start("/srv/remcons");
         
         /*
@@ -325 +370 @@
         srv_start("/srv/ata_bd");
         srv_start("/srv/gxe_bd");
-#else
-        (void) srv_start;
 #endif
         
 #ifdef CONFIG_MOUNT_DATA
         /* Make sure fat is running. */
-        if (str_cmp(STRING(RDFMT), "fat") != 0) {
+        if (str_cmp(STRING(RDFMT), "fat") != 0)
                 srv_start("/srv/fat");
-        }
+        
         mount_data();
 #else
@@ -339 +382 @@
 #endif
         
-        spawn("/srv/hound");
-        switch((unsigned)CONFIG_VC_COUNT) {
-        default:
-        case 6: getterm("term/vc5", "/app/bdsh", false);
-        case 5: getterm("term/vc4", "/app/bdsh", false);
-        case 4: getterm("term/vc3", "/app/bdsh", false);
-        case 3: getterm("term/vc2", "/app/bdsh", false);
-        case 2: getterm("term/vc1", "/app/bdsh", false);
-        case 1: getterm("term/vc0", "/app/bdsh", true);
-        }
+        srv_start("/srv/hound");
+        srv_start("/srv/input", HID_INPUT);
+        srv_start("/srv/output", HID_OUTPUT);
+        
+        int rc = compositor(HID_INPUT, HID_COMPOSITOR_SERVER);
+        if (rc == EOK) {
+                gui_start("/app/vlaunch", HID_COMPOSITOR_SERVER);
+                gui_start("/app/vterm", HID_COMPOSITOR_SERVER);
+        } else {
+                rc = console(HID_INPUT, HID_OUTPUT);
+                if (rc == EOK) {
+                        switch((unsigned)CONFIG_VC_COUNT) {
+                        default:
+                        case 6: getterm("term/vc5", "/app/bdsh", false);
+                        case 5: getterm("term/vc4", "/app/bdsh", false);
+                        case 4: getterm("term/vc3", "/app/bdsh", false);
+                        case 3: getterm("term/vc2", "/app/bdsh", false);
+                        case 2: getterm("term/vc1", "/app/bdsh", false);
+                        case 1: getterm("term/vc0", "/app/bdsh", true);
+                        }
 #ifdef CONFIG_KERNEL_LOG_VC_6
-        getterm("term/vc6", "/app/klog", false);
+                        getterm("term/vc6", "/app/klog", false);
 #endif
+                }
+        }
         
         return 0;

uspace/app/klog/Makefile

@@ -29 +29 @@
 
 USPACE_PREFIX = ../..
+LIBS = $(LIBCLUI_PREFIX)/libclui.a
+EXTRA_CFLAGS = -I$(LIBCLUI_PREFIX)
 BINARY = klog
 

uspace/app/klog/klog.c

@@ -48 +48 @@
 #include <adt/list.h>
 #include <adt/prodcons.h>
+#include <tinput.h>
 
 #define NAME       "klog"
@@ -228 +229 @@
         }
         
+        tinput_t *input = tinput_new();
+        if (!input) {
+                fprintf(stderr, "%s: Could not create input\n", NAME);
+                return ENOMEM;
+        }       
+
         fibril_add_ready(fid);
         event_unmask(EVENT_KLOG);
         klog_update();
         
-        task_retval(0);
-        async_manager();
-        
-        return 0;
+        tinput_set_prompt(input, "klog> ");
+
+        char *str;
+        while ((rc = tinput_read(input, &str)) == EOK) {
+                if (str_cmp(str, "") == 0) {
+                        free(str);
+                        continue;
+                }
+
+                klog_command(str, str_size(str));
+                free(str);
+        }
+ 
+        if (rc == ENOENT)
+                rc = EOK;       
+
+        return EOK;
 }
 

uspace/app/logset/Makefile

@@ -1 +1 @@
 #
-# Copyright (c) 2011 Vojtech Horky
+# Copyright (c) 2012 Vojtech Horky
 # All rights reserved.
 #
@@ -28 +28 @@
 
 USPACE_PREFIX = ../..
-BINARY = lsusb
-
-LIBS = \
-        $(LIBUSBDEV_PREFIX)/libusbdev.a \
-        $(LIBUSB_PREFIX)/libusb.a \
-        $(LIBDRV_PREFIX)/libdrv.a
-EXTRA_CFLAGS = \
-        -I$(LIBUSB_PREFIX)/include \
-        -I$(LIBUSBDEV_PREFIX)/include \
-        -I$(LIBDRV_PREFIX)/include
+BINARY = logset
 
 SOURCES = \

uspace/app/mkbd/main.c

@@ -40 +40 @@
 #include <errno.h>
 #include <str_error.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <getopt.h>
 #include <devman.h>

uspace/app/mkexfat/exfat.h

@@ -34 +34 @@
 #include <sys/types.h>
 #include <stdint.h>
-#include <bool.h>
+#include <stdbool.h>
 
 #define EXFAT_FILENAME_LEN      255

uspace/app/mkexfat/mkexfat.c

@@ -38 +38 @@
 
 #include <stdio.h>
-#include <libblock.h>
+#include <block.h>
 #include <assert.h>
 #include <errno.h>
@@ -46 +46 @@
 #include <sys/types.h>
 #include <sys/typefmt.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <str.h>
 #include <getopt.h>
+#include <macros.h>
 #include "exfat.h"
 #include "upcase.h"
@@ -87 +88 @@
 #define FIRST_FREE_CLUSTER   2
 
-#define min(x, y) ((x) < (y) ? (x) : (y))
 
 typedef struct exfat_cfg {

uspace/app/mkfat/mkfat.c

@@ -40 +40 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <libblock.h>
+#include <block.h>
 #include <mem.h>
 #include <loc.h>

uspace/app/mkmfs/mkmfs.c

@@ -39 +39 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <libblock.h>
+#include <block.h>
 #include <unistd.h>
 #include <errno.h>

uspace/app/msim/arch_helenos/input.c

@@ -32 +32 @@
 /** @file HelenOS specific functions for MSIM simulator.
  */
+
+/* Because of asprintf. */
+#define _GNU_SOURCE
 #include "../../io/input.h"
 #include "../../io/output.h"
@@ -38 +41 @@
 #include <tinput.h>
 #include <errno.h>
+#include <stdlib.h>
 
 static tinput_t *input_prompt;

uspace/app/msim/arch_helenos/misc.c

@@ -44 +44 @@
 #include <ctype.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 /* Define when the dprinter device shall try to filter

uspace/app/nettest2/nettest2.c

@@ -45 +45 @@
 #include <time.h>
 #include <arg_parse.h>
-#include <bool.h>
+#include <stdbool.h>
 
 #include <net/in.h>

uspace/app/nterm/conn.c

@@ -33 +33 @@
  */
 
-#include <bool.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <fibril.h>

uspace/app/nterm/nterm.c

@@ -33 +33 @@
  */
 
-#include <bool.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <io/console.h>

uspace/app/ping/ping.c

@@ -34 +34 @@
 
 #include <async.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <fibril_synch.h>

uspace/app/sportdmp/sportdmp.c

@@ -37 +37 @@
 static void syntax_print(void)
 {
-        fprintf(stderr, "Usage: sportdmp <baud> <device_service>\n");
+        fprintf(stderr, "Usage: sportdmp [--baud=<baud>] [device_service]\n");
 }
 
 int main(int argc, char **argv)
 {
-        const char* svc_path = "devices/\\hw\\pci0\\00:01.0\\com1\\a";
         sysarg_t baud = 9600;
+        service_id_t svc_id;
         
-        if (argc > 1) {
+        int arg = 1;
+        int rc;
+                
+        if (argc > arg && str_test_prefix(argv[arg], "--baud=")) {
+                size_t arg_offset = str_lsize(argv[arg], 7);
+                char* arg_str = argv[arg] + arg_offset;
+                if (str_length(arg_str) == 0) {
+                        fprintf(stderr, "--baud requires an argument\n");
+                        syntax_print();
+                        return 1;
+                }
                 char *endptr;
-                baud = strtol(argv[1], &endptr, 10);
+                baud = strtol(arg_str, &endptr, 10);
                 if (*endptr != '\0') {
                         fprintf(stderr, "Invalid value for baud\n");
@@ -53 +63 @@
                         return 1;
                 }
+                arg++;
         }
         
-        if (argc > 2) {
-                svc_path = argv[2];
+        if (argc > arg) {
+                rc = loc_service_get_id(argv[arg], &svc_id, 0);
+                if (rc != EOK) {
+                        fprintf(stderr, "Cannot find device service %s\n",
+                            argv[arg]);
+                        return 1;
+                }
+                arg++;
+        }
+        else {
+                category_id_t serial_cat_id;
+                
+                rc = loc_category_get_id("serial", &serial_cat_id, 0);
+                if (rc != EOK) {
+                        fprintf(stderr, "Failed getting id of category "
+                            "'serial'\n");
+                        return 1;
+                }
+                
+                service_id_t *svc_ids;
+                size_t svc_count;
+                
+                rc = loc_category_get_svcs(serial_cat_id, &svc_ids, &svc_count);                if (rc != EOK) {
+                        fprintf(stderr, "Failed getting list of services\n");
+                        return 1;
+                }
+                
+                if (svc_count == 0) {
+                        fprintf(stderr, "No service in category 'serial'\n");
+                        free(svc_ids);
+                        return 1;
+                }
+                
+                svc_id = svc_ids[0];
+                free(svc_ids);
         }
         
-        if (argc > 3) {
+        if (argc > arg) {
+                fprintf(stderr, "Too many arguments\n");
                 syntax_print();
                 return 1;
         }
         
-        service_id_t svc_id;
-        int rc = loc_service_get_id(svc_path, &svc_id, IPC_FLAG_BLOCKING);
-        if (rc != EOK) {
-                fprintf(stderr, "Cannot find device service %s\n", svc_path);
-                return 1;
-        }
         
         async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
             IPC_FLAG_BLOCKING);
         if (!sess) {
-                fprintf(stderr, "Failed connecting to service %s\n", svc_path);
+                fprintf(stderr, "Failed connecting to service\n");
         }
         
@@ -101 +140 @@
                 ssize_t i;
                 for (i = 0; i < read; i++) {
-                        if ((buf[i] >= 32) && (buf[i] < 128))
-                                putchar((wchar_t) buf[i]);
-                        else
-                                putchar('.');
-                        fflush(stdout);
+                        printf("%02hhx ", buf[i]);
                 }
+                fflush(stdout);
         }
         

uspace/app/stats/stats.c

@@ -44 +44 @@
 #include <malloc.h>
 #include <inttypes.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <str.h>
 #include <arg_parse.h>

uspace/app/taskdump/taskdump.c

@@ -47 +47 @@
 #include <macros.h>
 #include <assert.h>
-#include <bool.h>
+#include <stdbool.h>
 
 #include <symtab.h>

uspace/app/tester/Makefile

@@ -29 +29 @@
 
 USPACE_PREFIX = ../..
-LIBS = $(LIBEXT2_PREFIX)/libext2.a $(LIBBLOCK_PREFIX)/libblock.a
-EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBEXT2_PREFIX)
+LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBSOFTFLOAT_PREFIX)/libsoftfloat.a
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBSOFTFLOAT_PREFIX)
 BINARY = tester
 
@@ -42 +42 @@
         print/print4.c \
         print/print5.c \
+        print/print6.c \
         console/console1.c \
         stdio/stdio1.c \
         stdio/stdio2.c \
+        stdio/logger1.c \
+        stdio/logger2.c \
         fault/fault1.c \
         fault/fault2.c \
         fault/fault3.c \
+        float/float1.c \
+        float/softfloat1.c \
         vfs/vfs1.c \
         ipc/ping_pong.c \
@@ -58 +63 @@
         mm/mapping1.c \
         hw/misc/virtchar1.c \
-        hw/serial/serial1.c \
-        libext2/libext2_1.c
+        hw/serial/serial1.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/app/tester/mm/common.c

@@ -343 +343 @@
         
         area->addr = as_area_create(AS_AREA_ANY, size,
-            AS_AREA_WRITE | AS_AREA_READ);
+            AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
         if (area->addr == AS_MAP_FAILED) {
                 free(area);

uspace/app/tester/mm/common.h

@@ -37 +37 @@
 
 #include <sys/types.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <adt/list.h>
 

uspace/app/tester/mm/mapping1.c

@@ -43 +43 @@
         
         void *result = as_area_create(AS_AREA_ANY, size,
-            AS_AREA_READ | AS_AREA_WRITE);
+            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
         if (result == AS_MAP_FAILED)
                 return NULL;

uspace/app/tester/print/print5.def

@@ -1 +1 @@
 {
-        "print1",
-        "String printf test",
-        &test_print1,
+        "print5",
+        "Char printf test",
+        &test_print5,
         true
 },

uspace/app/tester/tester.c

@@ -39 +39 @@
 #include <stdio.h>
 #include <str.h>
+#include <io/log.h>
 #include "tester.h"
 
@@ -52 +53 @@
 #include "print/print4.def"
 #include "print/print5.def"
+#include "print/print6.def"
 #include "console/console1.def"
 #include "stdio/stdio1.def"
 #include "stdio/stdio2.def"
+#include "stdio/logger1.def"
+#include "stdio/logger2.def"
 #include "fault/fault1.def"
 #include "fault/fault2.def"
 #include "fault/fault3.def"
+#include "float/float1.def"
+#include "float/softfloat1.def"
 #include "vfs/vfs1.def"
 #include "ipc/ping_pong.def"
@@ -68 +74 @@
 #include "hw/serial/serial1.def"
 #include "hw/misc/virtchar1.def"
-#include "libext2/libext2_1.def"
         {NULL, NULL, NULL, false}
 };
@@ -138 +143 @@
         }
         
+        log_init("tester");
+
         test_quiet = false;
         test_argc = argc - 2;

uspace/app/tester/tester.h

@@ -37 +37 @@
 
 #include <sys/types.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <stacktrace.h>
 
@@ -85 +85 @@
 extern const char *test_print4(void);
 extern const char *test_print5(void);
+extern const char *test_print6(void);
 extern const char *test_console1(void);
 extern const char *test_stdio1(void);
 extern const char *test_stdio2(void);
+extern const char *test_logger1(void);
+extern const char *test_logger2(void);
 extern const char *test_fault1(void);
 extern const char *test_fault2(void);
 extern const char *test_fault3(void);
+extern const char *test_float1(void);
+extern const char *test_softfloat1(void);
 extern const char *test_vfs1(void);
 extern const char *test_ping_pong(void);
@@ -101 +106 @@
 extern const char *test_serial1(void);
 extern const char *test_virtchar1(void);
-extern const char *test_libext2_1(void);
 extern const char *test_devman1(void);
 extern const char *test_devman2(void);

uspace/app/tetris/screen.c

@@ -61 +61 @@
 #include <vfs/vfs.h>
 #include <async.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <io/console.h>
 #include <io/style.h>

uspace/app/tetris/screen.h

@@ -58 +58 @@
 #include <io/console.h>
 #include <async.h>
-#include <bool.h>
+#include <stdbool.h>
 
 typedef struct {

uspace/app/top/screen.h

@@ -36 +36 @@
 
 #include <io/console.h>
+#include <io/verify.h>
 #include "top.h"
 
@@ -43 +44 @@
 extern void screen_done(void);
 extern void print_data(data_t *);
-extern void show_warning(const char *, ...);
+extern void show_warning(const char *, ...)
+    PRINTF_ATTRIBUTE(1, 2);
 
 extern int tgetchar(unsigned int);

uspace/app/trace/ipcp.c

@@ -38 +38 @@
 #include <sys/typefmt.h>
 #include <abi/ipc/methods.h>
+#include <macros.h>
 #include "ipc_desc.h"
 #include "proto.h"
@@ -52 +53 @@
         ipc_callid_t call_hash;
 
-        link_t link;
+        ht_link_t link;
 } pending_call_t;
 
@@ -64 +65 @@
 int have_conn[MAX_PHONE];
 
-#define PCALL_TABLE_CHAINS 32
-hash_table_t pending_calls;
+static hash_table_t pending_calls;
 
 /*
@@ -73 +73 @@
 proto_t *proto_unknown;         /**< Protocol with no known methods. */
 
-static hash_index_t pending_call_hash(unsigned long key[]);
-static int pending_call_compare(unsigned long key[], hash_count_t keys,
-    link_t *item);
-static void pending_call_remove_callback(link_t *item);
-
-hash_table_operations_t pending_call_ops = {
+
+static size_t pending_call_key_hash(void *key)
+{
+        ipc_callid_t *call_id = (ipc_callid_t *)key;
+        return *call_id;
+}
+
+static size_t pending_call_hash(const ht_link_t *item)
+{
+        pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
+        return hs->call_hash;
+}
+
+static bool pending_call_key_equal(void *key, const ht_link_t *item)
+{
+        ipc_callid_t *call_id = (ipc_callid_t *)key;
+        pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
+
+        return *call_id == hs->call_hash;
+}
+
+static hash_table_ops_t pending_call_ops = {
         .hash = pending_call_hash,
-        .compare = pending_call_compare,
-        .remove_callback = pending_call_remove_callback
+        .key_hash = pending_call_key_hash,
+        .key_equal = pending_call_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL
 };
-
-
-static hash_index_t pending_call_hash(unsigned long key[])
-{
-//      printf("pending_call_hash\n");
-        return key[0] % PCALL_TABLE_CHAINS;
-}
-
-static int pending_call_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
-{
-        pending_call_t *hs;
-
-//      printf("pending_call_compare\n");
-        hs = hash_table_get_instance(item, pending_call_t, link);
-
-        // FIXME: this will fail if sizeof(long) < sizeof(void *).
-        return key[0] == hs->call_hash;
-}
-
-static void pending_call_remove_callback(link_t *item)
-{
-//      printf("pending_call_remove_callback\n");
-}
 
 
@@ -177 +171 @@
         }
 
-        hash_table_create(&pending_calls, PCALL_TABLE_CHAINS, 1, &pending_call_ops);
+        bool ok = hash_table_create(&pending_calls, 0, 0, &pending_call_ops);
+        assert(ok);
 }
 
@@ -190 +185 @@
         pending_call_t *pcall;
         proto_t *proto;
-        unsigned long key[1];
         oper_t *oper;
         sysarg_t *args;
@@ -254 +248 @@
         pcall->oper = oper;
 
-        key[0] = hash;
-
-        hash_table_insert(&pending_calls, key, &pcall->link);
+        hash_table_insert(&pending_calls, &pcall->link);
 }
 
@@ -334 +326 @@
 void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash)
 {
-        link_t *item;
+        ht_link_t *item;
         pending_call_t *pcall;
-        unsigned long key[1];
         
         if ((hash & IPC_CALLID_ANSWERED) == 0 && hash != IPCP_CALLID_SYNC) {
@@ -347 +338 @@
         
         hash = hash & ~IPC_CALLID_ANSWERED;
-        key[0] = hash;
-        
-        item = hash_table_find(&pending_calls, key);
+        
+        item = hash_table_find(&pending_calls, &hash);
         if (item == NULL)
                 return; /* No matching question found */
@@ -357 +347 @@
          */
         
-        pcall = hash_table_get_instance(item, pending_call_t, link);
-        hash_table_remove(&pending_calls, key, 1);
+        pcall = hash_table_get_inst(item, pending_call_t, link);
+        hash_table_remove(&pending_calls, &hash);
         
         parse_answer(hash, pcall, call);

uspace/app/trace/proto.c

@@ -40 +40 @@
 #include "proto.h"
 
-#define SRV_PROTO_TABLE_CHAINS 32
-#define METHOD_OPER_TABLE_CHAINS 32
-
-hash_table_t srv_proto;
+
+/* Maps service number to protocol */
+static hash_table_t srv_proto;
 
 typedef struct {
-        unsigned srv;
+        int srv;
         proto_t *proto;
-        link_t link;
+        ht_link_t link;
 } srv_proto_t;
 
 typedef struct {
-        sysarg_t method;
+        int method;
         oper_t *oper;
-        link_t link;
+        ht_link_t link;
 } method_oper_t;
 
-static hash_index_t srv_proto_hash(unsigned long key[]);
-static int srv_proto_compare(unsigned long key[], hash_count_t keys,
-    link_t *item);
-static void srv_proto_remove_callback(link_t *item);
-
-hash_table_operations_t srv_proto_ops = {
+/* Hash table operations. */
+
+static size_t srv_proto_key_hash(void *key)
+{
+        return *(int *)key;
+}
+
+static size_t srv_proto_hash(const ht_link_t *item)
+{
+        srv_proto_t *sp = hash_table_get_inst(item, srv_proto_t, link);
+        return sp->srv;
+}
+
+static bool srv_proto_key_equal(void *key, const ht_link_t *item)
+{
+        srv_proto_t *sp = hash_table_get_inst(item, srv_proto_t, link);
+        return sp->srv == *(int *)key;
+}
+
+static hash_table_ops_t srv_proto_ops = {
         .hash = srv_proto_hash,
-        .compare = srv_proto_compare,
-        .remove_callback = srv_proto_remove_callback
+        .key_hash = srv_proto_key_hash,
+        .key_equal = srv_proto_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL
 };
 
-static hash_index_t method_oper_hash(unsigned long key[]);
-static int method_oper_compare(unsigned long key[], hash_count_t keys,
-    link_t *item);
-static void method_oper_remove_callback(link_t *item);
-
-hash_table_operations_t method_oper_ops = {
+
+static size_t method_oper_key_hash(void *key)
+{
+        return *(int *)key;
+}
+
+static size_t method_oper_hash(const ht_link_t *item)
+{
+        method_oper_t *mo = hash_table_get_inst(item, method_oper_t, link);
+        return mo->method;
+}
+
+static bool method_oper_key_equal(void *key, const ht_link_t *item)
+{
+        method_oper_t *mo = hash_table_get_inst(item, method_oper_t, link);
+        return mo->method == *(int *)key;
+}
+
+static hash_table_ops_t method_oper_ops = {
         .hash = method_oper_hash,
-        .compare = method_oper_compare,
-        .remove_callback = method_oper_remove_callback
+        .key_hash = method_oper_key_hash,
+        .key_equal = method_oper_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL
 };
 
-static hash_index_t srv_proto_hash(unsigned long key[])
-{
-        return key[0] % SRV_PROTO_TABLE_CHAINS;
-}
-
-static int srv_proto_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
+
+void proto_init(void)
+{
+        /* todo: check return value. */
+        bool ok = hash_table_create(&srv_proto, 0, 0, &srv_proto_ops);
+        assert(ok);
+}
+
+void proto_cleanup(void)
+{
+        hash_table_destroy(&srv_proto);
+}
+
+void proto_register(int srv, proto_t *proto)
 {
         srv_proto_t *sp;
-
-        sp = hash_table_get_instance(item, srv_proto_t, link);
-
-        return key[0] == sp->srv;
-}
-
-static void srv_proto_remove_callback(link_t *item)
-{
-}
-
-static hash_index_t method_oper_hash(unsigned long key[])
-{
-        return key[0] % METHOD_OPER_TABLE_CHAINS;
-}
-
-static int method_oper_compare(unsigned long key[], hash_count_t keys,
-    link_t *item)
-{
-        method_oper_t *mo;
-
-        mo = hash_table_get_instance(item, method_oper_t, link);
-
-        return key[0] == mo->method;
-}
-
-static void method_oper_remove_callback(link_t *item)
-{
-}
-
-
-void proto_init(void)
-{
-        hash_table_create(&srv_proto, SRV_PROTO_TABLE_CHAINS, 1,
-            &srv_proto_ops);
-}
-
-void proto_cleanup(void)
-{
-        hash_table_destroy(&srv_proto);
-}
-
-void proto_register(int srv, proto_t *proto)
-{
-        srv_proto_t *sp;
-        unsigned long key;
 
         sp = malloc(sizeof(srv_proto_t));
         sp->srv = srv;
         sp->proto = proto;
-        key = srv;
-
-        hash_table_insert(&srv_proto, &key, &sp->link);
+
+        hash_table_insert(&srv_proto, &sp->link);
 }
 
 proto_t *proto_get_by_srv(int srv)
 {
-        unsigned long key;
-        link_t *item;
-        srv_proto_t *sp;
-
-        key = srv;
-        item = hash_table_find(&srv_proto, &key);
+        ht_link_t *item = hash_table_find(&srv_proto, &srv);
         if (item == NULL) return NULL;
 
-        sp = hash_table_get_instance(item, srv_proto_t, link);
+        srv_proto_t *sp = hash_table_get_inst(item, srv_proto_t, link);
         return sp->proto;
 }
@@ -159 +145 @@
 {
         proto->name = name;
-        hash_table_create(&proto->method_oper, SRV_PROTO_TABLE_CHAINS, 1,
-            &method_oper_ops);
+        /* todo: check return value. */
+        bool ok = hash_table_create(&proto->method_oper, 0, 0, &method_oper_ops);
+        assert(ok);
 }
 
@@ -181 +168 @@
 {
         method_oper_t *mo;
-        unsigned long key;
 
         mo = malloc(sizeof(method_oper_t));
         mo->method = method;
         mo->oper = oper;
-        key = method;
-
-        hash_table_insert(&proto->method_oper, &key, &mo->link);        
+
+        hash_table_insert(&proto->method_oper, &mo->link);      
 }
 
 oper_t *proto_get_oper(proto_t *proto, int method)
 {
-        unsigned long key;
-        link_t *item;
-        method_oper_t *mo;
-
-        key = method;
-        item = hash_table_find(&proto->method_oper, &key);
+        ht_link_t *item = hash_table_find(&proto->method_oper, &method);
         if (item == NULL) return NULL;
 
-        mo = hash_table_get_instance(item, method_oper_t, link);
+        method_oper_t *mo = hash_table_get_inst(item, method_oper_t, link);
         return mo->oper;
 }

uspace/app/trace/proto.h

@@ -62 +62 @@
 } proto_t;
 
-/* Maps service number to protocol */
-extern hash_table_t srv_proto;
 
 extern void proto_init(void);

uspace/app/trace/syscalls.c

@@ -53 +53 @@
     [SYS_AS_AREA_DESTROY] = { "as_area_destroy",        1,      V_ERRNO },
 
-    [SYS_IPC_CALL_SYNC_FAST] = { "ipc_call_sync_fast",  6,      V_ERRNO },
-    [SYS_IPC_CALL_SYNC_SLOW] = { "ipc_call_sync_slow",  3,      V_ERRNO },
     [SYS_IPC_CALL_ASYNC_FAST] = { "ipc_call_async_fast", 6,     V_HASH },
     [SYS_IPC_CALL_ASYNC_SLOW] = { "ipc_call_async_slow", 2,     V_HASH },

uspace/app/trace/trace.c

@@ -43 +43 @@
 #include <mem.h>
 #include <str.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <loader/loader.h>
 #include <io/console.h>
@@ -318 +318 @@
 }
 
-static void sc_ipc_call_sync_fast(sysarg_t *sc_args)
-{
-        ipc_call_t question, reply;
-        int rc;
-        int phoneid;
-
-        phoneid = sc_args[0];
-
-        IPC_SET_IMETHOD(question, sc_args[1]);
-        IPC_SET_ARG1(question, sc_args[2]);
-        IPC_SET_ARG2(question, sc_args[3]);
-        IPC_SET_ARG3(question, sc_args[4]);
-        IPC_SET_ARG4(question, 0);
-        IPC_SET_ARG5(question, 0);
-
-        memset(&reply, 0, sizeof(reply));
-        rc = udebug_mem_read(sess, &reply.args, sc_args[5], sizeof(reply.args));
-        if (rc < 0)
-                return;
-        
-        ipcp_call_sync(phoneid, &question, &reply);
-}
-
-static void sc_ipc_call_sync_slow_b(unsigned thread_id, sysarg_t *sc_args)
-{
-        ipc_call_t question;
-        int rc;
-
-        memset(&question, 0, sizeof(question));
-        rc = udebug_mem_read(sess, &question.args, sc_args[1],
-            sizeof(question.args));
-
-        if (rc < 0) {
-                printf("Error: mem_read->%d\n", rc);
-                return;
-        }
-
-        thread_ipc_req[thread_id] = question;
-}
-
-static void sc_ipc_call_sync_slow_e(unsigned thread_id, sysarg_t *sc_args)
-{
-        ipc_call_t reply;
-        int rc;
-
-        memset(&reply, 0, sizeof(reply));
-        rc = udebug_mem_read(sess, &reply.args, sc_args[2],
-            sizeof(reply.args));
-
-        if (rc < 0) {
-                printf("Error: mem_read->%d\n", rc);
-                return;
-        }
-
-        ipcp_call_sync(sc_args[0], &thread_ipc_req[thread_id], &reply);
-}
-
 static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc)
 {
@@ -408 +351 @@
                 print_sc_args(sc_args, syscall_desc[sc_id].n_args);
         }
-
-        switch (sc_id) {
-        case SYS_IPC_CALL_SYNC_SLOW:
-                sc_ipc_call_sync_slow_b(thread_id, sc_args);
-                break;
-        default:
-                break;
-        }
 }
 
@@ -447 +382 @@
         case SYS_IPC_CALL_ASYNC_SLOW:
                 sc_ipc_call_async_slow(sc_args, sc_rc);
-                break;
-        case SYS_IPC_CALL_SYNC_FAST:
-                sc_ipc_call_sync_fast(sc_args);
-                break;
-        case SYS_IPC_CALL_SYNC_SLOW:
-                sc_ipc_call_sync_slow_e(thread_id, sc_args);
                 break;
         case SYS_IPC_WAIT:

uspace/app/usbinfo/Makefile

@@ -47 +47 @@
         hid.c \
         info.c \
+        list.c \
         main.c
 

uspace/app/usbinfo/desctree.c

@@ -39 +39 @@
 #include <errno.h>
 #include <str_error.h>
-#include <bool.h>
+#include <stdbool.h>
 
 #include <usb/usb.h>

uspace/app/usbinfo/dump.c

@@ -39 +39 @@
 #include <errno.h>
 #include <str_error.h>
-#include <bool.h>
+#include <stdbool.h>
 
 #include <usb/usb.h>

uspace/app/usbinfo/list.c

@@ -40 +40 @@
 #include <errno.h>
 #include <str_error.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <getopt.h>
 #include <devman.h>
@@ -47 +47 @@
 #include <usb/hc.h>
 
-#define NAME "lsusb"
+#include "usbinfo.h"
 
 #define MAX_USB_ADDRESS USB11_ADDRESS_MAX
@@ -90 +90 @@
 }
 
-int main(int argc, char *argv[])
+void list(void)
 {
         category_id_t usbhc_cat;
@@ -102 +102 @@
                 printf(NAME ": Error resolving category '%s'",
                     USB_HC_CATEGORY);
-                return 1;
+                return;
         }
 
@@ -108 +108 @@
         if (rc != EOK) {
                 printf(NAME ": Error getting list of host controllers.\n");
-                return 1;
+                return;
         }
 
@@ -131 +131 @@
 
         free(svcs);
-
-        return 0;
 }
 

uspace/app/usbinfo/main.c

@@ -39 +39 @@
 #include <errno.h>
 #include <str_error.h>
-#include <bool.h>
+#include <stdbool.h>
 #include <getopt.h>
 #include <devman.h>
@@ -62 +62 @@
 
         _OPTION("-h --help", "Print this help and exit.");
+        _OPTION("-l --list", "Print a list of host controllers and devices.");
         _OPTION("-i --identification", "Brief device identification.");
         _OPTION("-m --match-ids", "Print match ids generated for the device.");
@@ -82 +83 @@
         {"help", no_argument, NULL, 'h'},
         {"identification", no_argument, NULL, 'i'},
+        {"list", no_argument, NULL, 'l'},
         {"match-ids", no_argument, NULL, 'm'},
         {"descriptor-tree", no_argument, NULL, 't'},
@@ -91 +93 @@
         {0, 0, NULL, 0}
 };
-static const char *short_options = "himtTsSrR";
+static const char *short_options = "hilmtTsSrR";
 
 static usbinfo_action_t actions[] = {
@@ -146 +148 @@
         }
 
+        bool something_active = false;
         /*
          * Process command-line options. They determine what shall be
@@ -156 +159 @@
                 switch (opt) {
                         case -1:
+                                break;
+                        case 'l':
+                                list();
                                 break;
                         case '?':
@@ -168 +174 @@
                                         if (actions[idx].opt == opt) {
                                                 actions[idx].active = true;
+                                                something_active = true;
                                                 break;
                                         }
@@ -178 +185 @@
 
         /* Set the default action. */
-        int idx = 0;
-        bool something_active = false;
-        while (actions[idx].opt != 0) {
-                if (actions[idx].active) {
-                        something_active = true;
-                        break;
-                }
-                idx++;
-        }
         if (!something_active) {
                 actions[0].active = true;

uspace/app/usbinfo/usbinfo.h

@@ -79 +79 @@
     dump_descriptor_in_tree_t, size_t, void *);
 
+void list(void);
 
 void dump_short_device_identification(usbinfo_device_t *);

uspace/app/vuhid/main.c

@@ -155 +155 @@
         int rc;
 
-        usb_log_enable(USB_LOG_LEVEL_DEBUG2, "vusbhid");
+        log_init("vuhid");
 
         fibril_mutex_initialize(&vuhid_data.iface_count_mutex);

uspace/app/websrv/websrv.c

@@ -34 +34 @@
  */
 
-#include <bool.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <assert.h>