izackp/mosh
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First stab at modularizing (broken build)

Browse Source
This commit is contained in:
Keith Winstein
2011-01-27 01:17:26 -05:00
parent db5808fa1f
commit 82a18ce978
9 changed files with 295 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Makefile
+2 -2
View File
@@ -1,5 +1,5 @@
source = parse.cpp parserstate.cpp parser.cpp templates.cpp terminal.cpp termemu.cpp parseraction.cpp terminalcsi.cpp swrite.cpp
objects = parserstate.o parser.o templates.o terminal.o parseraction.o terminalcsi.o swrite.o
source = parse.cpp parserstate.cpp parser.cpp templates.cpp terminal.cpp termemu.cpp parseraction.cpp terminalcsi.cpp swrite.cpp terminalframebuffer.cpp terminalactionstate.cpp
objects = parserstate.o parser.o templates.o terminal.o parseraction.o terminalcsi.o swrite.o terminalframebuffer.o terminalactionstate.o
repos = templates.rpo
executables = parse termemu
parseraction.cpp
+13
View File
@@ -1,8 +1,21 @@
#include <stdio.h>
#include <ctype.h>
#include "parseraction.hpp"
#include "terminal.hpp"
using namespace Parser;
std::string Parser::str( void )
{
char thechar[ 10 ] = { 0 };
if ( char_present ) {
snprintf( thechar, 10, isprint( ch ) ? "(%lc)" : "(0x%x)", act->ch );
}
return name() + std::string( thechar );
}
void Print::act_on_terminal( Terminal::Emulator *emu )
{
emu->print( this );
parseraction.hpp
+2
View File
@@ -15,6 +15,8 @@ namespace Parser {
wchar_t ch;
bool handled;
std::string str( void );
virtual std::string name( void ) = 0;
virtual void act_on_terminal( Terminal::Emulator * ) {};
terminal.cpp
+6 -179
View File
@@ -9,50 +9,9 @@
using namespace Terminal;
Cell::Cell()
: overlapping_cell( NULL ),
contents(),
overlapped_cells(),
fallback( false )
{}
Cell::Cell( const Cell &x )
: overlapping_cell( x.overlapping_cell ),
contents( x.contents ),
overlapped_cells( x.overlapped_cells ),
fallback( x.fallback )
{}
Cell & Cell::operator=( const Cell &x )
{
overlapping_cell = x.overlapping_cell;
contents = x.contents;
overlapped_cells = x.overlapped_cells;
fallback = x.fallback;
return *this;
}
Row::Row( size_t s_width )
: cells( s_width )
{}
Emulator::Emulator( size_t s_width, size_t s_height )
: parser(),
width( s_width ), height( s_height ),
cursor_col( 0 ), cursor_row( 0 ),
combining_char_col( 0 ), combining_char_row( 0 ),
rows( height, Row( width ) ),
params(), dispatch_chars(), terminal_to_host(),
errors(), parsed_params()
{
}
Emulator::~Emulator()
{
}
: parser(), fb( s_height, s_width ), as(), terminal_to_host()
{}
std::string Emulator::input( char c, int actfd )
{
@@ -67,56 +26,19 @@ std::string Emulator::input( char c, int actfd )
act->act_on_terminal( this );
/* print out debugging information */
if ( (actfd > 0) && ( !act->handled ) ) {
char actsum[ 64 ];
char thechar[ 10 ] = { 0 };
if ( act->char_present ) {
if ( isprint( act->ch ) ) {
snprintf( thechar, 10, "(%lc)", act->ch );
} else {
snprintf( thechar, 10, "(0x%x)", act->ch );
}
}
snprintf( actsum, 64, "%s%s[disp=%s,param=%s] ",
act->name().c_str(),
thechar,
dispatch_chars.c_str(),
params.c_str() );
snprintf( actsum, 64, "%s%s ", act->str().c_str(), as.str().c_str() );
swrite( actfd, actsum );
}
delete act;
}
/* the user is supposed to send this string to the host, as if typed */
return terminal_to_host;
}
void Emulator::scroll( int N )
{
assert( N >= 0 );
for ( int i = 0; i < N; i++ ) {
rows.pop_front();
rows.push_back( Row( width ) );
cursor_row--;
combining_char_row--;
}
}
void Emulator::newgrapheme( void )
{
combining_char_col = cursor_col;
combining_char_row = cursor_row;
}
void Emulator::autoscroll( void )
{
if ( cursor_row >= height ) { /* scroll */
scroll( cursor_row - height + 1 );
}
}
void Emulator::execute( Parser::Execute *act )
{
assert( act->char_present );
@@ -171,13 +93,12 @@ void Emulator::print( Parser::Print *act )
}
autoscroll();
newgrapheme();
this_cell = &rows[ cursor_row ].cells[ cursor_col ];
this_cell->reset();
this_cell->contents.push_back( act->ch );
newgrapheme();
if ( (cursor_col < width - 1) && (chwidth == 2) ) {
Cell *next_cell = &rows[ cursor_row ].cells[ cursor_col + 1 ];
this_cell->overlapped_cells.push_back( next_cell );
@@ -246,34 +167,6 @@ void Emulator::debug_printout( int fd )
swrite( fd, screen.c_str() );
}
void Emulator::param( Parser::Param *act )
{
assert( act->char_present );
assert( (act->ch == ';') || ( (act->ch >= '0') && (act->ch <= '9') ) );
if ( params.length() < 100 ) {
/* enough for 16 five-char params plus 15 semicolons */
params.push_back( act->ch );
act->handled = true;
}
}
void Emulator::collect( Parser::Collect *act )
{
assert( act->char_present );
if ( ( dispatch_chars.length() < 8 ) /* never should need more than 2 */
&& ( act->ch <= 255 ) ) { /* ignore non-8-bit */
dispatch_chars.push_back( act->ch );
act->handled = true;
}
}
void Emulator::clear( Parser::Clear *act )
{
params.clear();
dispatch_chars.clear();
act->handled = true;
}
void Emulator::CSI_dispatch( Parser::CSI_Dispatch *act )
{
/* add final char to dispatch key */
@@ -317,69 +210,3 @@ void Emulator::Esc_dispatch( Parser::Esc_Dispatch *act )
act->handled = true;
}
}
void Emulator::parse_params( void )
{
parsed_params.clear();
const char *str = params.c_str();
const char *segment_begin = str;
while ( 1 ) {
const char *segment_end = strchr( segment_begin, ';' );
if ( segment_end == NULL ) {
break;
}
errno = 0;
char *endptr;
int val = strtol( segment_begin, &endptr, 10 );
if ( endptr == segment_begin ) {
val = -1;
}
if ( errno == 0 ) {
parsed_params.push_back( val );
}
segment_begin = segment_end + 1;
}
/* get last param */
errno = 0;
char *endptr;
int val = strtol( segment_begin, &endptr, 10 );
if ( endptr == segment_begin ) {
val = -1;
}
if ( errno == 0 ) {
parsed_params.push_back( val );
}
}
int Emulator::getparam( size_t N, int defaultval )
{
int ret = defaultval;
if ( parsed_params.size() > N ) {
ret = parsed_params[ N ];
}
if ( ret < 1 ) ret = defaultval;
return ret;
}
void Cell::reset( void )
{
contents.clear();
fallback = false;
if ( overlapping_cell ) {
assert( overlapped_cells.size() == 0 );
} else {
for ( std::vector<Cell *>::iterator i = overlapped_cells.begin();
i != overlapped_cells.end();
i++ ) {
(*i)->overlapping_cell = NULL;
(*i)->reset();
}
overlapped_cells.clear();
}
}
terminal.hpp
+4 -45
View File
@@ -7,30 +7,10 @@
#include <deque>
#include "parser.hpp"
#include "terminalframebuffer.hpp"
#include "terminalactionstate.hpp"
namespace Terminal {
class Cell {
public:
Cell *overlapping_cell;
std::vector<wchar_t> contents;
std::vector<Cell *> overlapped_cells;
char fallback; /* first character is combining character */
Cell();
Cell( const Cell & );
Cell & operator=( const Cell & );
void reset( void );
};
class Row {
public:
std::vector<Cell> cells;
Row( size_t s_width );
};
class Emulator {
friend void Parser::Print::act_on_terminal( Emulator * );
friend void Parser::Execute::act_on_terminal( Emulator * );
@@ -42,17 +22,10 @@ namespace Terminal {
private:
Parser::UTF8Parser parser;
int width, height;
int cursor_col, cursor_row;
int combining_char_col, combining_char_row;
std::deque<Row> rows;
std::string params;
std::string dispatch_chars;
Framebuffer fb;
ActionState as;
std::string terminal_to_host;
std::string errors;
/* action methods */
void print( Parser::Print *act );
@@ -63,14 +36,6 @@ namespace Terminal {
void CSI_dispatch( Parser::CSI_Dispatch *act );
void Esc_dispatch( Parser::Esc_Dispatch *act );
void scroll( int N );
void autoscroll( void );
void newgrapheme( void );
void parse_params( void );
std::vector<int> parsed_params;
int getparam( size_t N, int defaultval );
/* CSI and Escape methods */
void CSI_EL( void );
void CSI_ED( void );
@@ -80,15 +45,9 @@ namespace Terminal {
public:
Emulator( size_t s_width, size_t s_height );
~Emulator();
std::string input( char c, int debug_fd );
void resize( size_t s_width, size_t s_height );
size_t get_width( void ) { return width; }
size_t get_height( void ) { return height; }
void debug_printout( int fd );
};
}
terminalactionstate.cpp
+106
View File
@@ -0,0 +1,106 @@
#include <stdio.h>
#include "terminalactionstate.hpp"
#include "parseraction.hpp"
using namespace Terminal;
ActionState::ActionState()
: params(), parsed_params(), parsed( false ), dispatch_chars()
{}
void newparamchar( Parser::Param *act )
{
assert( act->char_present );
assert( (act->ch == ';') || ( (act->ch >= '0') && (act->ch <= '9') ) );
if ( params.length() < 100 ) {
/* enough for 16 five-char params plus 15 semicolons */
params.push_back( act->ch );
act->handled = true;
}
parsed = false;
}
void ActionState::collect( Parser::Collect *act )
{
assert( act->char_present );
if ( ( dispatch_chars.length() < 8 ) /* never should need more than 2 */
&& ( act->ch <= 255 ) ) { /* ignore non-8-bit */
dispatch_chars.push_back( act->ch );
act->handled = true;
}
}
void ActionState::clear( Parser::Clear *act )
{
params.clear();
dispatch_chars.clear();
parsed = false;
act->handled = true;
}
void ActionState::parse_params( void )
{
if ( parsed ) {
return;
}
parsed_params.clear();
const char *str = params.c_str();
const char *segment_begin = str;
while ( 1 ) {
const char *segment_end = strchr( segment_begin, ';' );
if ( segment_end == NULL ) {
break;
}
errno = 0;
char *endptr;
int val = strtol( segment_begin, &endptr, 10 );
if ( endptr == segment_begin ) {
val = -1;
}
if ( errno == 0 ) {
parsed_params.push_back( val );
}
segment_begin = segment_end + 1;
}
/* get last param */
errno = 0;
char *endptr;
int val = strtol( segment_begin, &endptr, 10 );
if ( endptr == segment_begin ) {
val = -1;
}
if ( errno == 0 ) {
parsed_params.push_back( val );
}
parsed = true;
}
int ActionState::getparam( size_t N, int defaultval )
{
int ret = defaultval;
if ( !parsed ) {
parse_params();
}
if ( parsed_params.size() > N ) {
ret = parsed_params[ N ];
}
if ( ret < 1 ) ret = defaultval;
return ret;
}
std::string ActionState::str( void )
{
char assum[ 64 ];
snprintf( assum, 64, "[dispatch=%s params=%s]",
dispatch_chars.c_str(), params.c_str() );
return std::string( assum );
}
terminalactionstate.hpp
+35
View File
@@ -0,0 +1,35 @@
#ifndef TERMINALACTIONSTATE_HPP
#define TERMINALACTIONSTATE_HPP
#include <vector>
namespace Parser {
class Param;
class Collect;
class Clear;
}
namespace Terminal {
class ActionState {
private:
std::string params;
std::vector<int> parsed_params;
bool parsed;
std::string dispatch_chars;
void parse_params( void );
public:
ActionState();
int getparam( size_t N, int defaultval );
void newparamchar( Parser::Param *act );
void collect( Parser::Collect *act );
void clear( Parser::Clear *act );
std::string str( void );
};
}
#endif
terminalframebuffer.cpp
+82
View File
@@ -0,0 +1,82 @@
#include "terminalframebuffer.hpp"
using namespace Terminal;
Cell::Cell()
: overlapping_cell( NULL ),
contents(),
overlapped_cells(),
fallback( false )
{}
Cell::Cell( const Cell &x )
: overlapping_cell( x.overlapping_cell ),
contents( x.contents ),
overlapped_cells( x.overlapped_cells ),
fallback( x.fallback )
{}
Cell & Cell::operator=( const Cell &x )
{
overlapping_cell = x.overlapping_cell;
contents = x.contents;
overlapped_cells = x.overlapped_cells;
fallback = x.fallback;
return *this;
}
Row::Row( size_t s_width )
: cells( s_width )
{}
void Cell::reset( void )
{
contents.clear();
fallback = false;
if ( overlapping_cell ) {
assert( overlapped_cells.size() == 0 );
} else {
for ( std::vector<Cell *>::iterator i = overlapped_cells.begin();
i != overlapped_cells.end();
i++ ) {
(*i)->overlapping_cell = NULL;
(*i)->reset();
}
overlapped_cells.clear();
}
}
Framebuffer::Framebuffer( int s_width, int s_height )
: width( s_width ), height( s_height ),
cursor_col( 0 ), cursor_row( 0 ),
combining_char_col( 0 ), combining_char_row( 0 ),
rows( height, Row( width ) )
{}
void Framebuffer::scroll( int N )
{
assert( N >= 0 );
for ( int i = 0; i < N; i++ ) {
rows.pop_front();
rows.push_back( Row( width ) );
cursor_row--;
combining_char_row--;
}
}
void Framebuffer::newgrapheme( void )
{
combining_char_col = cursor_col;
combining_char_row = cursor_row;
}
void Framebuffer::autoscroll( void )
{
if ( cursor_row >= height ) { /* scroll */
scroll( cursor_row - height + 1 );
}
}
terminalframebuffer.hpp
+45
View File
@@ -0,0 +1,45 @@
#ifndef TERMINALFB_HPP
#define TERMINALFB_HPP
/* Terminal framebuffer */
namespace Terminal {
class Cell {
public:
Cell *overlapping_cell;
std::vector<wchar_t> contents;
std::vector<Cell *> overlapped_cells;
char fallback; /* first character is combining character */
Cell();
Cell( const Cell & );
Cell & operator=( const Cell & );
void reset( void );
};
class Row {
public:
std::vector<Cell> cells;
Row( size_t s_width );
};
class Framebuffer {
public:
int width, height;
int cursor_col, cursor_row;
int combining_char_col, combining_char_row;
std::deque<Row> rows;
void scroll( int N );
void autoscroll( void );
void newgrapheme( void );
Framebuffer( int s_width, int s_height );
};
}
#endif