Index: src/modules/vterm/output.c =================================================================== --- src/modules/vterm/output.c (Revision 0) +++ src/modules/vterm/output.c (Revision 0) @@ -0,0 +1,509 @@ +/* + * Copyright (c) 2007 The LOST Project. All rights reserved. + * + * This code is derived from software contributed to the LOST Project + * by Antoine Kaufmann. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the LOST Project + * and its contributors. + * 4. Neither the name of the LOST Project nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "vterm.h" +#include +#include + +#define PORT_HW_CURSOR 0x3D4 + +out_buffer_t* video_memory; + +static void screen_draw(vterm_output_t* out); +static void screen_draw_line(vterm_output_t* out, size_t line); +static void screen_adjust(vterm_output_t* out, position_t pos); +static void screen_cursor_update(vterm_output_t* out); +static inline void buffer_cell_set(vterm_output_t* out, out_buffer_t* buffer, + position_t position, videomem_cell_t c); +static inline videomem_cell_t buffer_cell_get(vterm_output_t* out, + out_buffer_t* buffer, position_t position); +static void buffer_line_clear(vterm_output_t* out, out_buffer_t* buffer, + size_t line); +static void output_add_cell(vterm_output_t* out, videomem_cell_t c); +static void output_newline(vterm_output_t* out); + + +/** + * Ausgabetreiber allgemein vorbereiten + */ +void init_output() +{ + video_memory = mem_allocate_physical(SCREEN_WIDTH_MAX * SCREEN_HEIGHT_MAX * + sizeof(videomem_cell_t), 0xb8000, 0); + + if (request_ports(PORT_HW_CURSOR, 2) == FALSE) { + puts("[ vterm ] Konnte Port fuer Hardware-Cursor nicht registrieren."); + exit(-1); + } +} + + +/** + * Ausgabe fuer ein vterminal vorbereiten + */ +bool vterm_output_init(vterminal_t* vterm, size_t buffer_lines) +{ + size_t buffer_size; + size_t i; + videomem_cell_t c; + vterm_output_t* out = &(vterm->output); + + // Struktur initialisieren + out->buffer_lines = buffer_lines; + out->buffer_pos.line = 0; + out->buffer_pos.column = 0; + + out->active = FALSE; + + out->screen_redraw = FALSE; + out->screen_width = 80; + out->screen_height = 25; + out->screen_topline = 0; + + out->scroll_lock = FALSE; + + // Standardschriftart: Grau auf schwarz + out->current_color.raw = 0x7; + + out->vt100_backup_valid = FALSE; + + // Puffer vorbereiten + buffer_size = sizeof(videomem_cell_t) * out->screen_width * buffer_lines; + out->buffer = malloc(buffer_size); + if (out->buffer == NULL) { + return FALSE; + } + + + c.color = out->current_color; + c.ascii = ' '; + for (i = 0; i < out->screen_width * buffer_lines; i++) { + out->buffer[i] = c; + } + + return TRUE; +} + +/** + * Wird beim Wechsel zu einem neuen virtuellen Terminal aufgerufen + */ +void vterm_output_change(vterminal_t* old, vterminal_t* new) +{ + // Nur wenn vorher ueberhaupt ein terminal aktiviert war, muss es jetzt auf + // inaktiv gesetzt werden + if (old != NULL) { + old->output.active = FALSE; + } + + new->output.active = TRUE; + screen_draw(&new->output); + screen_cursor_update(&new->output); +} + +/** + * Ausgaben eines Prozesses fuer ein Virtuelles Terminal verarbeiten + * + * @param data Pointer auf die auszugebenden Daten + * @param length Laenge der auszugebenden Daten + */ +void vterm_process_output(vterminal_t* vterm, char* data, size_t length) +{ + vterm_output_t* out = &(vterm->output); + + // Ausgaben durch vt100-Emulation taetigen + vt100_process_output(vterm, data, length); + + // Anzeige aktualisieren falls es sich um aenderungen auf dem aktiven + // Terminal handelt. + screen_adjust(out, vterm->output.buffer_pos); + if (out->active) { + screen_cursor_update(out); + + if (out->screen_redraw) { + out->screen_redraw = FALSE; + screen_draw(out); + } + } + +} + +/** + * Ausgaben eines Prozesses in Form von reinem Text ausgeben + * + * @param data Pointer auf die auszugebenden Daten + * @param length Laenge der auszugebenden Daten + */ +void vterm_output_text(vterminal_t* vterm, char* data, size_t length) +{ + size_t i; + videomem_cell_t c; + vterm_output_t* out = &(vterm->output); + + + c.color = out->current_color; + + // Zeichen einzeln ausgeben + for (i = 0; i < length; i++) { + + if (data[i] == '\n') { + output_newline(out); + } else if (data[i] == '\r') { + + output_set_position(out, out->buffer_pos.line, 0); + } else { + c.ascii = data[i]; + output_add_cell(out, c); + } + } +} + + + +/** + * Position auf dem Bildschirm anhand einer beliebigen Position im Puffer + * errechnen. Das klappt natuerlich nur, wenn die Position im Puffer auch + * irgendwo auf dem Bildschirm ist. + * + * @param buffer_pos Position im Puffer + * @param dest_pos Pointer auf die Positionsstruktur, in der das Ergebnis + * abgelegt werden soll. + * + * @return TRUE wenn die Position auch auf dem Bildschirm liegt, FALSE sonst. + */ +bool screen_position(vterm_output_t* out, position_t buffer_pos, + position_t* dest_pos) +{ + size_t screen_bottom = (out->screen_topline + out->screen_height - 1) % + out->buffer_lines;; + + // Wenn die Position ausserhalb des angezeigten Bereiches liegt, ist der + // Fall klar. + if (((screen_bottom > out->screen_topline) && ( + (buffer_pos.line < out->screen_topline) || + (buffer_pos.line > screen_bottom)) + ) || + ((screen_bottom < out->screen_topline) && + (buffer_pos.line > screen_bottom) && + (buffer_pos.line < out->screen_topline) + )) + + { + return FALSE; + } + + // Wenn die Position auf dem Bildschirm liegt, kann sie ganz einfach + // errechnet werden: + if (screen_bottom > out->screen_topline) { + dest_pos->line = buffer_pos.line - out->screen_topline; + } else { + dest_pos->line = (out->buffer_lines - out->screen_topline + + buffer_pos.line) % out->buffer_lines; + } + dest_pos->column = buffer_pos.column; + + return TRUE; +} + +/** + * Position des Hardware-Cursors anpassen + */ +static void screen_cursor_update(vterm_output_t* out) +{ + uint16_t position = 0; + position_t pos; + + // Position errechnen + if (screen_position(out, out->buffer_pos, &pos) == TRUE) { + position = pos.line * out->screen_width + pos.column; + } + + // Hardware Cursor verschieben + outb(PORT_HW_CURSOR, 15); + outb(PORT_HW_CURSOR + 1, position); + outb(PORT_HW_CURSOR, 14); + outb(PORT_HW_CURSOR + 1, position >> 8); +} + +/** + * Den richtigen Teil des Buffers auf in den Videospeicher kopieren. + */ +static void screen_draw(vterm_output_t* out) +{ + size_t i; + for (i = 0; i < out->screen_height; i++) { + screen_draw_line(out, i); + } +} + +/** + * Eine einzelne Zeile aus dem Puffer direkt in den Videospeicher kopieren + * + * @param line Zeilennummer + */ +static void screen_draw_line(vterm_output_t* out, size_t line) +{ + size_t i; + position_t screen_pos; + position_t buffer_pos; + videomem_cell_t c; + + // Nein groessere Zeilennummern als die Bildschirmhoehe gibts nicht. + if (line >= out->screen_height) { + return; + } + + screen_pos.line = line; + + for (i = 0; i < out->screen_width; i++) { + // Position aktualisieren + screen_pos.column = i; + + // Bufferposition aktualisieren und Zeichen aus dem Buffer auslesen + buffer_position(out, screen_pos, &buffer_pos); + c = buffer_cell_get(out, out->buffer, buffer_pos); + + // Zeichen in den Videospeicher kopieren + buffer_cell_set(out, video_memory, screen_pos, c); + } +} + +/** + * Bildschirmfenster um @lines Zeilen herunterschieben und Bildschirminhalt + * entsprechend anpassen. + * + * @param lines Anzahl der Zeilen um die der Inhalt verschoben werden soll. + */ +void screen_scroll(vterm_output_t* out, int lines) +{ + // TODO: Optimierungspotential ;-) + out->screen_topline += lines + out->buffer_lines; + out->screen_topline %= out->buffer_lines; + + // Der Bildschrim muss garantiert neu gezeichnet werden + // TODO: Da sie Funktion auch von aussen aufgerufen wird, muss hier im + // Moment neu gezeichnet werden. Hier waere vielleicht eine eigene Funktion + // dafuer nicht schlecht. + // out->screen_redraw = TRUE; + screen_draw(out); +} + +/** + * Dafuer sorgen, dass das Bildschirmfenster so angepasst wird, dass die + * Pufferposition pos sichtbar ist. + * + * @param pos + */ +static void screen_adjust(vterm_output_t* out, position_t pos) +{ + position_t screen_pos; + // Wenn position noch nicht sichtbar ist, wird jetzt entsprechend + // gescrollt, falls das moeglich ist. + if ((screen_position(out, pos, &screen_pos) == FALSE) && (out->scroll_lock + == FALSE)) + { + // Berechnen wieviele Zeilen gescrollt werden muss + int diff = pos.line - out->screen_topline - out->screen_height + 1; + + // Negative Werte umgehen, die machen irgendwie probleme + diff += out->buffer_lines; + screen_scroll(out, diff); + } +} + + + +/** + * Diese Funktion ist das Gegenstueck zu screen_position. Sie errechnet anhand + * einer gegebenen Bildschirm-Position die Position im Puffer. Im Gegensatz zu + * screen_position kann diese Funktion aber nicht fehlschlagen, da der + * Bildschirm immer irgendwo innerhalb des Puffers sein muss. + * + * @param screen_pos Position auf dem Bildschirm + * @param dest_pos Pointer auf die Positionsstruktur, in der das Ergebnis + * abgelegt werden soll. + */ +inline void buffer_position(vterm_output_t* out, position_t screen_pos, + position_t* dest_pos) +{ + dest_pos->line = out->screen_topline + screen_pos.line; + dest_pos->line %= out->buffer_lines; + dest_pos->column = screen_pos.column; +} + +/** + * Ein einzelnes Zeichen in einem Buffer setzen + * + * @param buffer Puffer in den das Zeichen gesetzt werden soll + * @param positon Position an die das Zeichen gesetzt werden soll + * @param c Das Zeichen mit Farbinformation + */ +static inline void buffer_cell_set(vterm_output_t* out, out_buffer_t* buffer, + position_t position, videomem_cell_t c) +{ + buffer[position.line * out->screen_width + position.column] = c; +} + +/** + * Einzelnes Zeichen aus einem Buffer auslesen + * + * @param buffer + * @param position + * + * @return Das Zeichen + */ +static inline videomem_cell_t buffer_cell_get(vterm_output_t* out, + out_buffer_t* buffer, position_t position) +{ + return buffer[position.line * out->screen_width + position.column]; +} + +/** + * Eine Zeile in einem Puffer leeren + * + * @param line Zeilennummer + */ +static void buffer_line_clear(vterm_output_t* out, out_buffer_t* buffer, + size_t line) +{ + position_t position; + videomem_cell_t c; + size_t i; + + c.color.raw = 0x7; + c.ascii = ' '; + + position.line = line; + + // Jetzt wird sie Zeichenweise geleert + for (i = 0; i < out->screen_width; i++) { + position.column = i; + buffer_cell_set(out, buffer, position, c); + } +} + + + + + + +/** + * Aktuelle Position im Puffer aktualisieren + */ +void output_set_position(vterm_output_t* out, size_t line, + size_t column) +{ + out->buffer_pos.column = column; + out->buffer_pos.line = line; + + // Zeilenumbruch? + if (column >= out->screen_width) { + out->buffer_pos.line += out->buffer_pos.column / out->screen_width; + out->buffer_pos.column %= out->screen_width; + } + + out->buffer_pos.line %= out->buffer_lines; +} + +/** + * Einzelnes Zeichen hinzufuegen und Bildschirminhalt ggf aktualisieren. + * + * @param c Zeichen + */ +static void output_add_cell(vterm_output_t* out, videomem_cell_t c) +{ + position_t screen_pos; + + // Zeichen setzen + buffer_cell_set(out, out->buffer, out->buffer_pos, c); + + // Zeichen gegebenenfalls auch noch auf dem Bildschirm ausgeben + if ((out->active) && (screen_position(out, out->buffer_pos, &screen_pos) + == TRUE)) + { + // Zeichen in den Videospeicher schreiben + buffer_cell_set(out, video_memory, screen_pos, c); + } + + // Position aktalisieren + if (out->buffer_pos.column != out->screen_width - 1) { + // Kein Zeilenumbruch + output_set_position(out, out->buffer_pos.line, out->buffer_pos.column + + 1); + } else { + // Zeilenumbruch + output_newline(out); + } +} + +/** + * Den festgelegten Bereich im Puffer und auf dem Bildschirm leeren + * + * @param count Anzahl der zu loeschenden Zeichen + */ +void output_clear(vterm_output_t* out, size_t count) +{ + size_t i; + videomem_cell_t c; + // Position retten + position_t pos = out->buffer_pos; + + c.color = out->current_color; + c.ascii = ' '; + for (i = 0; i < count; i++) { + output_add_cell(out, c); + } + + // Position wiederherstellen + out->buffer_pos = pos; +} + +/** + * Neue Zeile in Ausgabe anfangen + */ +static void output_newline(vterm_output_t* out) +{ + output_set_position(out, out->buffer_pos.line + 1, 0); + + // Zeile leeren + buffer_line_clear(out, out->buffer, out->buffer_pos.line); +} + Index: src/modules/vterm/vterm.h =================================================================== --- src/modules/vterm/vterm.h (Revision 675) +++ src/modules/vterm/vterm.h (Arbeitskopie) @@ -40,28 +40,96 @@ #define LOSTIO_TYPES_OUT 255 #define LOSTIO_TYPES_IN 254 -// Filehandles fuer Eingabe- und Ausgabekanal -extern FILE* input; -extern FILE* output; +#define SCREEN_WIDTH_MAX 80 +#define SCREEN_HEIGHT_MAX 25 +#define VT100_BUFFER_LEN 16 /// LostIO-Interface vorbereiten void init_lostio_interface(); +/// Output-Treiber vorbereiten +void init_output(); +// Farbe im Videospeicher +typedef union { + byte raw; + struct { + unsigned char foreground : 3; + unsigned char bold : 1; + unsigned char background : 3; + unsigned char blink : 1; + } __attribute__((packed)); +} __attribute__((packed)) con_color_t; + +// Zelle im Videospeicher +typedef struct { + char ascii; + con_color_t color; +} __attribute__((packed)) videomem_cell_t; + + + +typedef videomem_cell_t out_buffer_t; +typedef struct position { + /// Zeile + int line; + + /// Spalte + int column; +} position_t; + +typedef struct vterm_output { + /// Groesse des Puffers in Zeilen + int buffer_lines; + + /// Position im Puffer + struct position buffer_pos; + + /// Aktuelle Farbe + con_color_t current_color; + + /// Der eigentliche Puffer + videomem_cell_t* buffer; + + /// TRUE falls der Buffer gerade auf dem Bildschirm ist. + bool active; + + /// Groesse des Bildschirms + size_t screen_width; + size_t screen_height; + + /// Oberste Zeile auf dem Bildschirm + int screen_topline; + + /// Wird auf TRUE gesetzt falls der Bildschirm neu gezeichnet werden soll + bool screen_redraw; + + /// Scroll-Lock + bool scroll_lock; + + + /// TRUE falls vt100_pos_backup und vt100_color_backup gueltig sind + bool vt100_backup_valid; + + /// Backupposition fuer vt100-Emulation + position_t vt100_pos_backup; + + /// Kopie der Farbe fuer vt100 + con_color_t vt100_color_backup; +} vterm_output_t; + + /// Typ fuer ein Terminal typedef struct { /// Name des Terminals char* name; /// Shortcut mit dem das Terminal aktiviert werden kann - char* shortcut; + char shortcut; - /// Groesse des Ausgabenpuffers - size_t out_buffer_size; - - /// Pointer auf den Ausgabenpuffer - char* out_buffer; + /// Struktur fuer den ganzen Ausgabekram + vterm_output_t output; /// LostIO-Node fuer out-Datei vfstree_node_t* out_node; @@ -74,17 +142,65 @@ /// LostIO-Node fuer in-Datei vfstree_node_t* in_node; + + /// Eingegebene Ziffern sofort ausgeben + bool input_echo; + + /// vt100-Puffer + char vt100_buffer[VT100_BUFFER_LEN]; + + /// Anzahl der Zeichen im vt100-Puffer + size_t vt100_buffer_offset; } vterminal_t; + extern vterminal_t* current_vterm; /// Virtuelle terminals einrichten void init_vterminals(unsigned int count); +/// Ausgabe fuer ein virtuelles Terminal initialisieren +bool vterm_output_init(vterminal_t* vterm, size_t buffer_lines); + +/// Wird beim Wechsel zu einem neuen virtuellen Terminal aufgerufen +void vterm_output_change(vterminal_t* old, vterminal_t* new); + /// Ausgaben in ein virtuelles Terminal verwalten void vterm_process_output(vterminal_t* vterm, char* data, size_t length); /// Eingaben verarbeiten void vterm_process_input(char* data, size_t length); +/// Text ohne vt100-Emulation ausgeben +void vterm_output_text(vterminal_t* vterm, char* data, size_t length); + +/// Ausgabeposition aebdern +void output_set_position(vterm_output_t* out, size_t row, + size_t column); + + +/// Alle Zeichen loeschen die bis zu count Zeichen von der aktuellen Position +/// entfernt sind. +void output_clear(vterm_output_t* out, size_t count); + +/// Bildschirmfenster verschieben +void screen_scroll(vterm_output_t* out, int lines); + +/// Pufferposition in Bildischmposition umrechnen +bool screen_position(vterm_output_t* out, position_t buffer_pos, + position_t* position); + +/// Das Gegenstueck zu screen_position +extern inline void buffer_position(vterm_output_t* out, position_t screen_pos, + position_t* dest_pos) +{ + dest_pos->line = out->screen_topline + screen_pos.line; + dest_pos->line %= out->buffer_lines; + dest_pos->column = screen_pos.column; +} + + +/// Ausgabe in vt100-Emulation verarbeiten +void vt100_process_output(vterminal_t* vterm, char* data, size_t length); + Index: src/modules/vterm/term.c =================================================================== --- src/modules/vterm/term.c (Revision 675) +++ src/modules/vterm/term.c (Arbeitskopie) @@ -51,7 +51,7 @@ static list_t* vterm_list; /// Virtuelles Terminal erstellen -vterminal_t* vterm_create(const char* shortcut); +vterminal_t* vterm_create(char shortcut); /// Virtuelles Terminal wechseln void vterm_change(vterminal_t* vterm); @@ -59,8 +59,8 @@ void init_vterminals(unsigned int count) { - const char* shortcuts[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", - "0", "'", "^"}; + char shortcuts[] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '\'', + '^'}; // Liste fuer alle vterms erstellen vterm_list = list_create(); @@ -81,7 +81,7 @@ * * @return Pointer auf die vterm-Struktur */ -vterminal_t* vterm_create(const char* shortcut) +vterminal_t* vterm_create(char shortcut) { // vterm-Struktur vorbereiten vterminal_t* vterm = malloc(sizeof(vterminal_t)); @@ -111,14 +111,19 @@ memcpy(path + name_len + 1, "/out", 5); vfstree_create_node(path, LOSTIO_TYPES_OUT, 0, vterm, 0); vterm->out_node = vfstree_get_node_by_path(path); + // Shortcut zuweisen - vterm->shortcut = malloc(strlen(shortcut) + 1); - memcpy(vterm->shortcut, shortcut, strlen(shortcut) + 1); + vterm->shortcut = shortcut; + + // Standardmaessig nichts ausgeben + vterm->input_echo = FALSE; // vterm an Liste Anhaengen vterm_list = list_push(vterm_list, vterm); - + if (vterm_output_init(vterm, 100) == FALSE) { + // TODO + } return vterm; } @@ -130,131 +135,112 @@ void vterm_change(vterminal_t* vterm) { if (current_vterm != vterm) { + vterm_output_change(current_vterm, vterm); current_vterm = vterm; - - // ANSI-Sequenz zum leeren des Bildschirms - fwrite("\033[2J", 1, 4, output); - - // Ausgabenkanal-Buffer anzeigen - fwrite(vterm->out_buffer, 1, vterm->out_buffer_size, output); } } + /** - * Ausgaben eines Prozesses fuer ein Virtuelles Terminal verarbeiten - * - * @param data Pointer auf die auszugebenden Daten - * @param length Laenge der auszugebenden Daten + * Dem Eingabepuffer ein Zeichen anhaengen */ -void vterm_process_output(vterminal_t* vterm, char* data, size_t length) +static void input_buffer_append(vterminal_t* vterm, char c) { - // Wenn es sich um das aktuelle Terminal handelt, werden die Daten gleich - // ausgegeben - if (vterm == current_vterm) { - fwrite(data, 1, length, output); - } - - // Die Daten auch Puffer kopieren, dazu muss der zuerst vergroessert werden - // FIXME: potentielles memleak - vterm->out_buffer_size += length; - vterm->out_buffer = realloc(vterm->out_buffer, vterm->out_buffer_size); - + // FIXME; Ineffizienter konnte ich das nicht loesen. ;-) + vterm->in_buffer_size += 1; + vterm->in_node->size = current_vterm->in_buffer_size; + vterm->in_buffer = realloc(vterm->in_buffer, vterm->in_buffer_size); // Daten in den Puffer kopieren - memcpy(vterm->out_buffer + vterm->out_buffer_size - length, data, length); + vterm->in_buffer[vterm->in_buffer_size - 1] = c; } /** - * Eingaben verarbeiten - * - * @param data Pointer auf die eingegebenen Daten - * @param length Laenge der eingebenen Daten + * Ein zeichen der Eingabe verarbeiten */ -void vterm_process_input(char* data, size_t length) +static void input_process_char(vterminal_t* vterm, char c) { - static bool wait_switch = FALSE; - static bool last_switch = FALSE; - - // Falls die Taste zum Terminalwechsel gedrueckt wurde, wird versucht zu - // wechseln - if (wait_switch == TRUE) { - wait_switch = FALSE; + static bool wait_command = FALSE; - // Verhindert Probleme, wenn Escape gedrueckt wurde, und dann nicht - // gewechselt wurde - last_switch = TRUE; - - vterminal_t* vterm = NULL; - int i = 0; - // Pruefe ob ein Passendes Terminal vorhanden ist - while ((vterm = list_get_element_at(vterm_list, i++))) { - if (length >= strlen(vterm->shortcut) && (strncmp(data, vterm-> - shortcut, strlen(vterm->shortcut)) == 0)) - { + if (wait_command == TRUE) { + wait_command = FALSE; + switch (c) { + // ESC wird momentan zum einleiten von Befehlen Benutzt + case '\033': + // Wenn schon einmal ESC gedrueckt wurde, wird ein ESC + // weitergeleitet. + input_buffer_append(vterm, c); break; - } - } - // Wenn nein wird abgebrochen und ganz normal ausgegeben - if (vterm == NULL) { - vterm_process_input(data, length); - return; - } + // ESC + s => Scroll lock + case 's': + vterm->output.scroll_lock = !vterm->output.scroll_lock; + break; - // Falls doch etwas gefunden wurde, wird gewechselt. - vterm_change(vterm); - - // Es wurde doch erfolgreich gewechselt, also darf das nächste Escape - // wieder benutzt werden - last_switch = FALSE; + // ESC + u => Scroll up + case 'u': + screen_scroll(&(vterm->output), -10); + break; - // Wenn noch mehr Daten da sind werden die ausgegeben - size_t shortcut_len = strlen(vterm->shortcut); - if (length - shortcut_len != 0) { - vterm_process_input(data + shortcut_len, length - shortcut_len); - } - } else { - // Nach aufforderungen zum Terminal-Wechseln suchen - char* chg = memchr(data, 27, length); - - // Wenn escape gedrueckt wurde, und nicht gewechselt wurde, darf ein - // weiteres escape nicht benutzt werden - if ((last_switch == TRUE) && (chg == data)) { - chg = NULL; - } - last_switch = FALSE; + // ESC + d => Scroll down + case 'd': + screen_scroll(&(vterm->output), 10); + break; - // Falls eine vorhanden ist, wird bis davor ausgegeben - if (chg != NULL) { - // Wenn noch Daten davor da sind, werden diese verarbeitet - if (chg != data) { - vterm_process_input(data, chg - data); - length -= chg - data; - data += chg - data; - } - - wait_switch = TRUE; - - // Wechselaufforderung ueberspringen - data++; - length--; + // Alles andere => Terminalwechsel + default: { + vterminal_t* vterm_switch = NULL; + int i = 0; - // Wenn danach auch noch Daten vorhanden sind, werden diese auch - // noch verarbeitet - if (length != 0) { - vterm_process_input(data, length); + // Passendes Terminal suchen + while ((vterm_switch = list_get_element_at(vterm_list, i++))) { + if (vterm_switch->shortcut == c) { + break; + } + } + + // Wenn kein passendes Terminal gefunden werden konnte, wird + // das Zeichen normal ausgegeben + if (vterm_switch == NULL) { + input_buffer_append(vterm, c); + break; + } + + // Ansonsten wird jetzt gewechselt + vterm_change(vterm_switch); + break; } - } else { - // Die Daten auch Puffer kopieren, dazu muss der zuerst - // vergroessert werden - // FIXME: potentielles memleak - current_vterm->in_buffer_size += length; - current_vterm->in_node->size = current_vterm->in_buffer_size; - current_vterm->in_buffer = realloc(current_vterm->in_buffer, - current_vterm->in_buffer_size); - // Daten in den Puffer kopieren - memcpy(current_vterm->in_buffer + current_vterm->in_buffer_size - - length, data, length); } + } else { + switch (c) { + // ESC wird momentan zum einleiten von Befehlen Benutzt + case '\033': + // Das naechste Zeichen wird zum identifizieren des neuen + // Terminals benutzt. + wait_command = TRUE; + + break; + + // Alles andere + default: + input_buffer_append(vterm, c); + break; + } } } +/** + * Eingaben verarbeiten + * + * @param data Pointer auf die eingegebenen Daten + * @param length Laenge der eingebenen Daten + */ +void vterm_process_input(char* data, size_t length) +{ + size_t i; + + // Eingabe wird zeichenweise verarbeitet + for (i = 0; i < length; i++) { + input_process_char(current_vterm, data[i]); + } +} + Index: src/modules/vterm/vt100.c =================================================================== --- src/modules/vterm/vt100.c (Revision 0) +++ src/modules/vterm/vt100.c (Revision 0) @@ -0,0 +1,635 @@ +/* + * Copyright (c) 2007 The LOST Project. All rights reserved. + * + * This code is derived from software contributed to the LOST Project + * by Antoine Kaufmann. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the LOST Project + * and its contributors. + * 4. Neither the name of the LOST Project nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include "vterm.h" +#include + +struct vt100_sequence_handler { + const char* sequence; + void (*handler)(vterminal_t* vterm, bool have_n1, bool have_n2, int n1, + int n2); +}; + +static void vt100_buffer_flush(vterminal_t* vterm); +static bool vt100_buffer_validate(vterminal_t* vterm); + +static void vt100_cursor_up(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); +static void vt100_cursor_down(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); +static void vt100_cursor_left(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); +static void vt100_cursor_right(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); +static void vt100_cursor_bol_down(vterminal_t* vterm, bool have_n1, + bool have_n2, int n1, int n2); +static void vt100_cursor_bol_up(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); +static void vt100_cursor_direct(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); +static void vt100_cursor_save(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); +static void vt100_cursor_restore(vterminal_t* vterm, bool have_n1, + bool have_n2, int n1, int n2); + +static void vt100_clear_screen(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); +static void vt100_clear_line(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); +static void vt100_text_attr(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2); + + +static struct vt100_sequence_handler handler_list[] = { + // ANSI + {"\033[\1A", vt100_cursor_up}, + {"\033[\1B", vt100_cursor_down}, + {"\033[\1C", vt100_cursor_right}, + {"\033[\1D", vt100_cursor_left}, + {"\033[\1E", vt100_cursor_bol_down}, + {"\033[\1F", vt100_cursor_bol_up}, + {"\033[\1;\1f", vt100_cursor_direct}, + {"\033[\1;\1H", vt100_cursor_direct}, + {"\033[s", vt100_cursor_save}, + {"\033[u", vt100_cursor_restore}, + + {"\033[2J", vt100_clear_screen}, + {"\033[K", vt100_clear_line}, + {"\033[\1;\1m", vt100_text_attr} + + // VT100 + // ... +}; + +/** + * Ausgaben durch vt100-Emulation verarbeiten + */ +void vt100_process_output(vterminal_t* vterm, char* data, size_t length) +{ + char c; + int i; + char* last_flush = data; + size_t text_len = 0; + + // Der String wird jetzt Zeichenweise durchsucht. Nach einem Escape-Zeichen + // werden die Zeichen so lange gepuffert, bis die Sequenz fertig ist, oder + // feststeht, dass sie ungueltig ist. In diesem Fall, werden alle Zeichen + // ausser dem Escape-Zeichen ausgegeben. + for (i = 0; i < length; i++) { + c = data[i]; + + // Die vorherigen Zeichen waren alle normaler Text, imd auch das + // Aktuelle ist kein Beginn einer Sequenz. Die Zeichen werden also + // aufbewahrt, bis wir am Ende sind, oder eine Escape-Sequenz anfaengt. + if ((vterm->vt100_buffer_offset == 0) && (c != '\033')) { + text_len++; + } else if (c == '\033') { + if (vterm->vt100_buffer_offset == 0) { + // Der Beginn einer Sequenz. Jetzt wird ausgegeben, was bis + // jetzt gekommen ist. + if (text_len != 0) { + vterm_output_text(vterm, last_flush, text_len); + } + } else { + // Wir haben noch eine Sequenz im Puffer, die allerdings nich + // gueltig ist. + vt100_buffer_flush(vterm); + } + last_flush = data + i + 1; + text_len = 0; + + // Jetzt wird das Escape-Zeichen in den Puffer gelegt. + vterm->vt100_buffer[0] = '\033'; + vterm->vt100_buffer_offset = 1; + } else { + // Ein Zeichen in einer Escape-Sequenz + + // Wenn der Puffer voll ist, dann stimmt sowieso was nicht. + if (vterm->vt100_buffer_offset == VT100_BUFFER_LEN) { + vt100_buffer_flush(vterm); + + // Das aktuelle Zeichen ist dann reiner Text + last_flush = data + i; + text_len = 1; + } else { + // Sonst wird das Zeichen an den Buffer angehaengt, und + // geprueft, ob die Sequenz schon abgeschlossen, oder noch + // gueltig ist. + vterm->vt100_buffer[vterm->vt100_buffer_offset] = c; + vterm->vt100_buffer_offset++; + + if (vt100_buffer_validate(vterm) == FALSE) { + // Wenn die Sequenz nicht mehr gueltig ist, wird sie + // ausgegeben. + vt100_buffer_flush(vterm); + } + + // Fruehstens das naechste Zeichen ist dann vernuenftiger Text + last_flush = data + i + 1; + text_len = 0; + } + } + } + + // Falls noch etwas uebrig blieb, wird das jetzt ausgegeben + if (text_len != 0) { + vterm_output_text(vterm, last_flush, text_len); + } +} + +/** + * VT100-Puffer leeren. + */ +static void vt100_buffer_flush(vterminal_t* vterm) +{ + // Alles ausser dem Escape-Zeichen ausgeben + if (vterm->vt100_buffer_offset > 1) { + vterm_output_text(vterm, vterm->vt100_buffer + 1, vterm-> + vt100_buffer_offset - 1); + } + vterm->vt100_buffer_offset = 0; +} + +/** + * Pfuefen der VT100-Escapesequenz. Falls sie vollstaendig ist, wird sie + * ausgefuehrt. + * + * @return TRUE falls die Sequenz gueltig ist/war, FALSE sonst + */ +static bool vt100_buffer_validate(vterminal_t* vterm) +{ + // Laufvariable fuer Sequenz + int i; + + // Laufvariable fuer Zeichen im Sequenzmuste + int j; + + // TRUE wenn der ensprechende Parameter schon gefunden wurde + bool have_n1; + bool have_n2; + + // TRUE wenn ein Semikolon, das zum trennen von Parametern benutzt wird, + // gefunden wurde + bool have_sep = FALSE; + + // Die Werte der Parameter; Nur korrekt falls have_nX = TRUE + int n1; + int n2; + + bool matches; + + // Pointer auf das Zeichen im vt100-Puffer, das gerade verarbeitet wird. + char* cur_pos= vterm->vt100_buffer; + // Offset im v100-Puffer + size_t offset = 0; + + // Anzahl der Seqenzen im Array. + size_t sequences = sizeof(handler_list) / sizeof(struct + vt100_sequence_handler); + + // Alle Sequenzen in der Liste durchgehen und schauen ob eine passt. + for (i = 0; i < sequences; i++) { + // Initialwerte fuer jeden Durchlauf + matches = TRUE; + have_n1 = FALSE; + have_n2 = FALSE; + have_sep = FALSE; + cur_pos= vterm->vt100_buffer; + offset = 0; + + // Sequenzmuster vergleichen + for (j = 0; (j <= strlen(handler_list[i].sequence)) && matches; j++) { + char c = handler_list[i].sequence[j]; + + // Wenn wir am Bufferende angekommen sind, und das Muster noch + // nicht zu Ende ist, wird abgebrochen, denn dann ist die Sequenz + // noch gueltig. + if ((offset >= vterm->vt100_buffer_offset) && (c != '\0')) { + break; + } + switch (c) { + case '\1': { + int count; + int* n; + bool* have; + + // Entscheiden ob wir jetzt an n1 oder n2 rumspielen. Das + // haengt allein davon ab, ob der Seperator schon gekommen + // ist oder nicht. + if (have_sep == FALSE) { + n = &n1; + have = &have_n1; + } else { + n = &n2; + have = &have_n2; + } + + // Initialwerte, falls keine Ziffern gefunden werden + *n = 0; + *have = FALSE; + count = 0; + + // Ein numerisches Argument darf mehrere Ziffern haben + while ((*cur_pos >= '0') && (*cur_pos <= '9') && (offset < + vterm->vt100_buffer_offset)) + { + *n = *n * 10 + (*cur_pos - '0'); + + cur_pos++; + offset++; + count++; + } + + if (count != 0) { + *have = TRUE; + } + break; + } + + case ';': + // Der Seperator _muss_ auch in der Sequenz im Puffer + if (*cur_pos != ';') { + matches = FALSE; + break; + } + + // Mehrere Seperatoren dürfen nicht vorkommen + if (have_sep == TRUE) { + matches = FALSE; + } else { + have_sep = TRUE; + } + cur_pos++; + offset++; + break; + + case '\0': + // Ende der Sequenz erreicht, sie ist vollstaendig im + // Puffer und kann verarbeitet werden. + handler_list[i].handler(vterm, have_n1, have_n2, n1, n2); + // Puffer leeren + vterm->vt100_buffer_offset = 0; + return TRUE; + break; + + default: + // Alle anderen Zeichen muessen 1:1 stimmen + if (c != *cur_pos) { + matches = FALSE; + } + + cur_pos++; + offset++; + break; + } + } + + // Diese Seqeuenz ist zwar noch nicht vollstaendig, passt aber bis + // jetzt. + if (matches == TRUE) { + return TRUE; + } + } + + // Wenn bis hier nichts gefunden wurde, ist die Sequenz ungueltig + return FALSE; +} + +/** + * ESC[nA + * Cursor um n1 Zeilen nach oben bewegen. Wenn n1 nicht angegeben wird, wird + * n1 = 1 angenommen. + */ +static void vt100_cursor_up(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + position_t pos; + vterm_output_t* out = &(vterm->output); + + // Standardwert fuer n1 setzen + if (!have_n1) { + n1 = 1; + } + + // Versuchen die Position auf dem Bildschirm zu ermitteln + if (screen_position(out, out->buffer_pos, &pos)) { + if (pos.line >= n1) { + // Neue Position setzen + output_set_position(out, out->buffer_pos.line - n1, + out->buffer_pos.column); + } + } +} + +/** + * ESC[nB + * Cursor um n1 Zeilen nach unten bewegen. Wenn n1 nicht angegeben wird, wird + * n1 = 1 angenommen. + */ +static void vt100_cursor_down(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + position_t pos; + vterm_output_t* out = &(vterm->output); + + // Standardwert fuer n1 setzen + if (!have_n1) { + n1 = 1; + } + + // Versuchen die Position auf dem Bildschirm zu ermitteln + if (screen_position(out, out->buffer_pos, &pos)) { + if (pos.line < out->screen_height - n1) { + // Neue Position setzen + output_set_position(out, out->buffer_pos.line + n1, + out->buffer_pos.column); + } + } +} + +/** + * ESC[nC + * Cursor um n1 Spalten nach links bewegen. Wenn n1 nicht angegeben wird, wird + * n1 = 1 angenommen. + */ +static void vt100_cursor_left(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + position_t pos; + vterm_output_t* out = &(vterm->output); + + // Standardwert fuer n1 setzen + if (!have_n1) { + n1 = 1; + } + + // Versuchen die Position auf dem Bildschirm zu ermitteln + if (screen_position(out, out->buffer_pos, &pos)) { + if (pos.column >= n1) { + // Neue Position setzen + output_set_position(out, out->buffer_pos.line, + out->buffer_pos.column - n1); + } + } +} + +/** + * ESC[nD + * Cursor um n1 Spalten nach rechts bewegen. Wenn n1 nicht angegeben wird, wird + * n1 = 1 angenommen. + */ +static void vt100_cursor_right(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + position_t pos; + vterm_output_t* out = &(vterm->output); + + // Standardwert fuer n1 setzen + if (!have_n1) { + n1 = 1; + } + + // Versuchen die Position auf dem Bildschirm zu ermitteln + if (screen_position(out, out->buffer_pos, &pos)) { + if (pos.column < out->screen_width - n1) { + // Neue Position setzen + output_set_position(out, out->buffer_pos.line, + out->buffer_pos.column + n1); + } + } +} + +/** + * ESC[nE + * Den Cursor an den Anfang der Zeile, die n1 Zeilen unterhalb der Aktuellen + * ist, setzen. Wenn n1 nicht angegeben wird, wird n1 = 1 angenommen. + */ +static void vt100_cursor_bol_down(vterminal_t* vterm, bool have_n1, + bool have_n2, int n1, int n2) +{ + vterm_output_t* out = &(vterm->output); + + // Standardwert fuer n1 setzen + if (!have_n1) { + n1 = 1; + } + + // Neue Position setzen + output_set_position(out, out->buffer_pos.line + n1, 0); +} + +/** + * ESC[nF + * Den Cursor an den Anfang der Zeile, die n1 Zeilen oberhalb der Aktuellen + * ist, setzen. Wenn n1 nicht angegebern wird, wird n1 = 1 angenommen. + */ +static void vt100_cursor_bol_up(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + vterm_output_t* out = &(vterm->output); + + // Standardwert fuer n1 setzen + if (!have_n1) { + n1 = 1; + } + + // Neue Position setzen + output_set_position(out, out->buffer_pos.line - n1, 0); +} + +/** + * ESC[n;nf + * ESC[n;nH + * Cursorposition direkt setzen. n1 = Zeile, n2 = Spalte + * + * Wenn keiner der Parameter angegeben wird, wird der Cursor in die obere linke + * Ecke positioniert. + */ +static void vt100_cursor_direct(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + position_t buffer_pos; + position_t screen_pos; + vterm_output_t* out = &(vterm->output); + + // Standardwerte hernehmen, wenn nichts angegben wurde + if (!have_n1) { + n1 = 0; + } + if (!have_n2) { + n2 = 0; + } + + // In positionstruktur einfuellen + screen_pos.line = n1; + screen_pos.column = n2; + + buffer_position(out, screen_pos, &buffer_pos); + output_set_position(out, buffer_pos.line, buffer_pos.column); +} + +/** + * ESC[s + * Cursorposition abspeichern, um sie spaeter mit ESC[u wiederherstellen zu + * koennen. + */ +static void vt100_cursor_save(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + position_t pos; + vterm_output_t* out = &(vterm->output); + + // Versuchen die Position auf dem Bildschirm zu ermitteln + if (screen_position(out, out->buffer_pos, &pos)) { + out->vt100_pos_backup = pos; + out->vt100_color_backup = out->current_color; + out->vt100_backup_valid = TRUE; + } +} + +/** + * ESC[u + * Cursorposition wiederherstellen + */ +static void vt100_cursor_restore(vterminal_t* vterm, bool have_n1, + bool have_n2, int n1, int n2) +{ + vterm_output_t* out = &(vterm->output); + + // Wenn die Positionen wirklich gespeichert wurden, werden sie jetzt + // wiederhergestellt. + if (out->vt100_backup_valid) { + buffer_position(out, out->vt100_pos_backup, &(out->buffer_pos)); + out->current_color = out->vt100_color_backup; + out->vt100_backup_valid = FALSE; + } +} + +/** + * ESC[2J + * Bildschirm von der Cursorposition an leeren. + */ +static void vt100_clear_screen(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + vterm_output_t* out = &(vterm->output); + + // Anzahl der uebrigen Zeichen + size_t count = (out->screen_height - out->buffer_pos.line) * out-> + screen_width - out->buffer_pos.column; + + // Zeichen loeschen + if (count != 0) { + output_clear(out, count); + } + +} + +/** + * ESC[K + * Zeile von der Cursorposition an leeren. + */ +static void vt100_clear_line(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + vterm_output_t* out = &(vterm->output); + + // Anzahl der uebrigen Zeichen + size_t count = out->screen_width - out->buffer_pos.column; + + // Zeichen loeschen + if (count != 0) { + output_clear(out, count); + } +} + +/** + * Parameter fuer Textattribute verarbeiten + */ +static void vt100_text_attr_param(vterminal_t* vterm, int n) +{ + vterm_output_t* out = &(vterm->output); + // Zum Umrechnen der ANSI Farbcodes in die VGA Palette. + static char colors[8] = { 0, 4, 2, 6, 1, 5, 3, 7 }; + + switch(n) + { + case 0: // Normal + out->current_color.bold = 0; + out->current_color.blink = 0; + break; + + case 1: // Fett + out->current_color.bold = 1; + break; + + case 5: // Blinken + out->current_color.blink = 1; + break; + + case 30 ... 37: // Vordergrundfarbe + out->current_color.foreground = colors[n - 30]; + break; + + case 40 ... 47: // Hintergrundfarbe + out->current_color.background = colors[n - 40]; + break; + } + +} + +/** + * ESC[n;nm + * Textattribute einstellen + */ +static void vt100_text_attr(vterminal_t* vterm, bool have_n1, bool have_n2, + int n1, int n2) +{ + // Die Parameter muessen natuerlich jeweils nur verarbeitet werden, wenn + // sie beide angegeben wurden. + if (have_n1) { + vt100_text_attr_param(vterm, n1); + } + if (have_n2) { + vt100_text_attr_param(vterm, n2); + } +} + Index: src/modules/vterm/vterm.c =================================================================== --- src/modules/vterm/vterm.c (Revision 675) +++ src/modules/vterm/vterm.c (Arbeitskopie) @@ -46,19 +46,17 @@ #include "init.h" -/// Oeffnet Eingabe- und Ausgabedatei +/// Oeffnet Eingabdatei static bool init_io_files(); /// Hier kommen die Eingaben fuer all die virtuellen Terminals her FILE* input = NULL; -/// Und hier gehen die Ausgaben hin -FILE* output = NULL; /// Eingaben einlesen static void get_input(); int main(int argc, char* argv[]) { - // Filehandles fuer Ein- und Ausgabe oeffnen + // Eingabedatei oeffnen if (init_io_files() == FALSE) { // Falls das nicht klappt, ist alles sinnlos. ;-) return -1; @@ -67,6 +65,8 @@ // Schnittstelle fuer die anderen Prozesse einrichten init_lostio_interface(); + init_output(); + init_vterminals(10); init_service_register("vterm"); @@ -80,7 +80,7 @@ } /** - * File-Handle fuer die Eingaben und Ausgaben aller Terminals oeffnen + * File-Handle fuer die Eingaben aller Terminals oeffnen * * @return TRUE bei Erfolg, FALSE im Fehlerfall */ @@ -88,41 +88,22 @@ { int i; - // FIXME: Diese Pfade sollten aus einer Konfigurationsdatei oder aus den - // Parametern kommen! - // Falls das öffnen nicht beim ersten Anlauf klappt, wird weiter Probiert // 5 Mal im Abstand von einer Sekunde - for (i = 0; i < 5; i++) { + for (i = 0; (i < 10) && (input == NULL); i++) { if (input == NULL) { input = fopen("kbc:/keyboard/ascii", "r"); } - if (output == NULL) { - output = fopen("textterm:/echo", "w"); - } - // Pruefen ob schon beide erfolgreich geoeffnet wurden - if ((input == NULL) || (output == NULL)) { - msleep(1000); - } else { - break; + if ((input == NULL)) { + msleep(500); } } - // Wenn nicht beide geoeffnet werden konnten, muss abgebrochen werden - if ((input == NULL) || (output == NULL)) { - if (input == NULL) { - puts("Input konnte nicht geoeffnet werden!"); - } else { - fclose(input); - } - - if (output == NULL) { - puts("Output konnte nicht geoeffnet werden!"); - } else { - fclose(output); - } + // Wenn input nicht geoeffnet werden konnten, muss abgebrochen werden + if (input == NULL) { + puts("Input konnte nicht geoeffnet werden!"); return FALSE; }