nyje/medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed macros: used G_STMT_*, replaced function-like macros without arguments, made them upper-case

Browse Source
This commit is contained in:
Yevgen Muntyan 2005-07-15 15:11:08 +00:00
parent 99c7d42589
commit d785c3b7f0
10 changed files with 337 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
moo/mooterm/mooterm-draw.c
View File

@ -986,7 +986,7 @@ void moo_term_force_update (MooTerm *term)
void moo_term_invert_colors (MooTerm *term, void moo_term_invert_colors (MooTerm *term,
gboolean invert) gboolean invert)
{ {
term_implement_me (); TERM_IMPLEMENT_ME;
} }

54
moo/mooterm/mooterm-input.c
View File

@ -310,19 +310,12 @@ gboolean moo_term_key_release (GtkWidget *widget,
static void start_press_tracking (MooTerm *term); static void start_press_tracking (MooTerm *term);
static void start_button_tracking (MooTerm *term); static void start_button_tracking (MooTerm *term);
static void start_hilite_tracking (MooTerm *term);
static void stop_mouse_tracking (MooTerm *term); static void stop_mouse_tracking (MooTerm *term);
static gboolean button_press (MooTerm *term, static gboolean button_press (MooTerm *term,
GdkEventButton *event); GdkEventButton *event);
static gboolean button_press_or_release (MooTerm *term, static gboolean button_press_or_release (MooTerm *term,
GdkEventButton *event); GdkEventButton *event);
static gboolean hilite_button_press (MooTerm *term,
GdkEventButton *event);
static gboolean hilite_button_release (MooTerm *term,
GdkEventButton *event);
static gboolean hilite_motion_notify (MooTerm *term,
GdkEventMotion *event);
void moo_term_set_mouse_tracking (MooTerm *term, void moo_term_set_mouse_tracking (MooTerm *term,
@ -346,11 +339,6 @@ void moo_term_set_mouse_tracking (MooTerm *term,
start_button_tracking (term); start_button_tracking (term);
break; break;
case MODE_HILITE_MOUSE_TRACKING:
term->priv->tracking_mouse = TRUE;
start_hilite_tracking (term);
break;
default: default:
term->priv->tracking_mouse = FALSE; term->priv->tracking_mouse = FALSE;
stop_mouse_tracking (term); stop_mouse_tracking (term);
@ -366,12 +354,9 @@ static void stop_mouse_tracking (MooTerm *term)
g_signal_handler_disconnect (term, term->priv->track_press_id); g_signal_handler_disconnect (term, term->priv->track_press_id);
if (term->priv->track_release_id) if (term->priv->track_release_id)
g_signal_handler_disconnect (term, term->priv->track_release_id); g_signal_handler_disconnect (term, term->priv->track_release_id);
if (term->priv->track_motion_id)
g_signal_handler_disconnect (term, term->priv->track_motion_id);
term->priv->track_press_id = 0; term->priv->track_press_id = 0;
term->priv->track_release_id = 0; term->priv->track_release_id = 0;
term->priv->track_motion_id = 0;
} }
@ -394,21 +379,6 @@ static void start_button_tracking (MooTerm *term)
} }
static void start_hilite_tracking (MooTerm *term)
{
term->priv->track_press_id =
g_signal_connect (term, "button-press-event",
G_CALLBACK (hilite_button_press), NULL);
term->priv->track_release_id =
g_signal_connect (term, "button-release-event",
G_CALLBACK (hilite_button_release), NULL);
term->priv->track_motion_id =
g_signal_connect (term, "motion-notify-event",
G_CALLBACK (hilite_motion_notify), NULL);
}
static void get_mouse_coordinates (MooTerm *term, static void get_mouse_coordinates (MooTerm *term,
GdkEventButton *event, GdkEventButton *event,
int *x, int *x,
@ -485,27 +455,3 @@ static gboolean button_press_or_release (MooTerm *term,
g_free (string); g_free (string);
return TRUE; return TRUE;
} }
static gboolean hilite_button_press (MooTerm *term,
GdkEventButton *event)
{
term_implement_me ();
return TRUE;
}
static gboolean hilite_button_release (MooTerm *term,
GdkEventButton *event)
{
term_implement_me ();
return TRUE;
}
static gboolean hilite_motion_notify (MooTerm *term,
GdkEventMotion *event)
{
term_implement_me ();
return TRUE;
}

15
moo/mooterm/mooterm-private.h
View File

@ -20,12 +20,12 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#if 0 #if 0
#define term_implement_me_warning g_warning #define TERM_IMPLEMENT_ME_WARNING g_warning
#else #else
#define term_implement_me_warning g_message #define TERM_IMPLEMENT_ME_WARNING g_message
#endif #endif
#define term_implement_me() term_implement_me_warning ("%s: implement me", G_STRFUNC) #define TERM_IMPLEMENT_ME TERM_IMPLEMENT_ME_WARNING ("%s: implement me", G_STRFUNC)
#define ADJUSTMENT_PRIORITY G_PRIORITY_HIGH_IDLE #define ADJUSTMENT_PRIORITY G_PRIORITY_HIGH_IDLE
@ -111,7 +111,6 @@ struct _MooTermPrivate {
int tracking_mouse; int tracking_mouse;
gulong track_press_id; gulong track_press_id;
gulong track_release_id; gulong track_release_id;
gulong track_motion_id;
GtkIMContext *im; GtkIMContext *im;
gboolean im_preedit_active; gboolean im_preedit_active;
@ -291,10 +290,10 @@ enum {
struct _TermSelection { struct _TermSelection {
guint screen_width; guint screen_width;
// absolute coordinates in the buffer /* absolute coordinates in the buffer
// selected range is [(l_row, l_col), (r_row, r_col)) selected range is [(l_row, l_col), (r_row, r_col))
// l_row, l_col and r_row are valid l_row, l_col and r_row are valid
// r_col may be equal to _width r_col may be equal to _width */
guint l_row; guint l_row;
guint l_col; guint l_col;
guint r_row; guint r_row;

138
moo/mooterm/mooterm-vtctls.h
View File

@ -18,108 +18,108 @@
#if 1 #if 1
#define vt_not_implemented() \ #define VT_NOT_IMPLEMENTED \
{ \ G_STMT_START { \
char *s = _moo_term_current_ctl (parser); \ char *s = _moo_term_current_ctl (parser); \
term_implement_me_warning ("'%s': implement me", s); \ TERM_IMPLEMENT_ME_WARNING ("'%s': implement me", s); \
g_free (s); \ g_free (s); \
} } G_STMT_END
#define vt_ignored() \ #define VT_IGNORED \
{ \ G_STMT_START { \
char *s = _moo_term_current_ctl (parser); \ char *s = _moo_term_current_ctl (parser); \
g_warning ("'%s' ignored", s); \ g_warning ("'%s' ignored", s); \
g_free (s); \ g_free (s); \
} } G_STMT_END
#else #else
#define vt_not_implemented() #define VT_NOT_IMPLEMENTED G_STMT_START {} G_STMT_END
#define vt_ignored() #define VT_IGNORED G_STMT_START {} G_STMT_END
#endif #endif
#define vt_print_char(ch) moo_term_buffer_print_unichar (parser->term->priv->buffer, ch) #define VT_PRINT_CHAR(ch) moo_term_buffer_print_unichar (parser->term->priv->buffer, ch)
#define vt_XON() g_warning ("%s: got XON", G_STRLOC) #define VT_XON g_warning ("%s: got XON", G_STRLOC)
#define vt_XOFF() g_warning ("%s: got XOFF", G_STRLOC) #define VT_XOFF g_warning ("%s: got XOFF", G_STRLOC)
#define vt_SET_ICON_NAME(s) moo_term_set_icon_name (parser->term, s) #define vt_SET_ICON_NAME(s) moo_term_set_icon_name (parser->term, s)
#define vt_SET_WINDOW_TITLE(s) moo_term_set_window_title (parser->term, s) #define vt_SET_WINDOW_TITLE(s) moo_term_set_window_title (parser->term, s)
#define vt_BEL() moo_term_bell (parser->term) #define VT_BEL moo_term_bell (parser->term)
#define vt_BS() moo_term_buffer_backspace (parser->term->priv->buffer) #define VT_BS moo_term_buffer_backspace (parser->term->priv->buffer)
#define vt_TAB() moo_term_buffer_tab (parser->term->priv->buffer, 1) #define VT_TAB moo_term_buffer_tab (parser->term->priv->buffer, 1)
#define vt_LF() moo_term_buffer_linefeed (parser->term->priv->buffer) #define VT_LF moo_term_buffer_linefeed (parser->term->priv->buffer)
#define vt_CR() moo_term_buffer_carriage_return (parser->term->priv->buffer) #define VT_CR moo_term_buffer_carriage_return (parser->term->priv->buffer)
#define vt_SO() moo_term_buffer_shift (parser->term->priv->buffer, 1) #define VT_SO moo_term_buffer_shift (parser->term->priv->buffer, 1)
#define vt_SI() moo_term_buffer_shift (parser->term->priv->buffer, 0) #define VT_SI moo_term_buffer_shift (parser->term->priv->buffer, 0)
#define vt_IND() moo_term_buffer_index (parser->term->priv->buffer) #define VT_IND moo_term_buffer_index (parser->term->priv->buffer)
#define vt_NEL() moo_term_buffer_new_line (parser->term->priv->buffer) #define VT_NEL moo_term_buffer_new_line (parser->term->priv->buffer)
#define vt_HTS() moo_term_buffer_set_tab_stop (parser->term->priv->buffer) #define VT_HTS moo_term_buffer_set_tab_stop (parser->term->priv->buffer)
#define vt_TBC(w) moo_term_buffer_clear_tab_stop (parser->term->priv->buffer, w) #define VT_TBC(w) moo_term_buffer_clear_tab_stop (parser->term->priv->buffer, w)
#define vt_RI() moo_term_buffer_reverse_index (parser->term->priv->buffer) #define VT_RI moo_term_buffer_reverse_index (parser->term->priv->buffer)
#define vt_SS2() moo_term_buffer_single_shift (parser->term->priv->buffer, 2) #define VT_SS2 moo_term_buffer_single_shift (parser->term->priv->buffer, 2)
#define vt_SS3() moo_term_buffer_single_shift (parser->term->priv->buffer, 3) #define VT_SS3 moo_term_buffer_single_shift (parser->term->priv->buffer, 3)
#define vt_DECID() moo_term_decid (parser->term) #define VT_DECID moo_term_decid (parser->term)
#define vt_SGR() moo_term_buffer_sgr (parser->term->priv->buffer, \ #define VT_SGR moo_term_buffer_sgr (parser->term->priv->buffer, \
(int*) parser->numbers->data, \ (int*) parser->numbers->data, \
parser->numbers->len) parser->numbers->len)
#define vt_CUU(n) moo_term_buffer_cuu (parser->term->priv->buffer, n) #define VT_CUU(n) moo_term_buffer_cuu (parser->term->priv->buffer, n)
#define vt_CUD(n) moo_term_buffer_cud (parser->term->priv->buffer, n) #define VT_CUD(n) moo_term_buffer_cud (parser->term->priv->buffer, n)
#define vt_CUF(n) moo_term_buffer_cursor_move (parser->term->priv->buffer, 0, n) #define VT_CUF(n) moo_term_buffer_cursor_move (parser->term->priv->buffer, 0, n)
#define vt_CUB(n) moo_term_buffer_cursor_move (parser->term->priv->buffer, 0, -n) #define VT_CUB(n) moo_term_buffer_cursor_move (parser->term->priv->buffer, 0, -n)
#define vt_DCH(n) moo_term_buffer_delete_char (parser->term->priv->buffer, n) #define VT_DCH(n) moo_term_buffer_delete_char (parser->term->priv->buffer, n)
#define vt_DL(n) moo_term_buffer_delete_line (parser->term->priv->buffer, n) #define VT_DL(n) moo_term_buffer_delete_line (parser->term->priv->buffer, n)
#define vt_ECH(n) moo_term_buffer_erase_char (parser->term->priv->buffer, n) #define VT_ECH(n) moo_term_buffer_erase_char (parser->term->priv->buffer, n)
#define vt_ED(n) moo_term_buffer_erase_in_display (parser->term->priv->buffer, n) #define VT_ED(n) moo_term_buffer_erase_in_display (parser->term->priv->buffer, n)
#define vt_EL(n) moo_term_buffer_erase_in_line (parser->term->priv->buffer, n) #define VT_EL(n) moo_term_buffer_erase_in_line (parser->term->priv->buffer, n)
#define vt_ICH(n) moo_term_buffer_insert_char (parser->term->priv->buffer, n) #define VT_ICH(n) moo_term_buffer_insert_char (parser->term->priv->buffer, n)
#define vt_IL(n) moo_term_buffer_insert_line (parser->term->priv->buffer, n) #define VT_IL(n) moo_term_buffer_insert_line (parser->term->priv->buffer, n)
#define vt_CUP(r,c) moo_term_buffer_cup (parser->term->priv->buffer, (r)-1, (c)-1) #define VT_CUP(r,c) moo_term_buffer_cup (parser->term->priv->buffer, (r)-1, (c)-1)
#define vt_DECSTBM(t,b) moo_term_buffer_set_scrolling_region (parser->term->priv->buffer, (t)-1, (b)-1); #define VT_DECSTBM(t,b) moo_term_buffer_set_scrolling_region (parser->term->priv->buffer, (t)-1, (b)-1);
#define vt_DECSC() moo_term_buffer_decsc (parser->term->priv->buffer) #define VT_DECSC moo_term_buffer_decsc (parser->term->priv->buffer)
#define vt_DECRC() moo_term_buffer_decrc (parser->term->priv->buffer) #define VT_DECRC moo_term_buffer_decrc (parser->term->priv->buffer)
#define vt_DECSET() moo_term_set_dec_modes (parser->term, \ #define VT_DECSET moo_term_set_dec_modes (parser->term, \
(int*) parser->numbers->data, \ (int*) parser->numbers->data, \
parser->numbers->len, \ parser->numbers->len, \
TRUE) TRUE)
#define vt_DECRST() moo_term_set_dec_modes (parser->term, \ #define VT_DECRST moo_term_set_dec_modes (parser->term, \
(int*) parser->numbers->data, \ (int*) parser->numbers->data, \
parser->numbers->len, \ parser->numbers->len, \
FALSE) FALSE)
#define vt_SM() moo_term_set_ansi_modes (parser->term, \ #define VT_SM moo_term_set_ansi_modes (parser->term, \
(int*) parser->numbers->data, \ (int*) parser->numbers->data, \
parser->numbers->len, \ parser->numbers->len, \
TRUE) TRUE)
#define vt_RM() moo_term_set_ansi_modes (parser->term, \ #define VT_RM moo_term_set_ansi_modes (parser->term, \
(int*) parser->numbers->data, \ (int*) parser->numbers->data, \
parser->numbers->len, \ parser->numbers->len, \
FALSE) FALSE)
#define vt_SCS(n,s) moo_term_buffer_select_charset (parser->term->priv->buffer, n, s) #define VT_SCS(n,s) moo_term_buffer_select_charset (parser->term->priv->buffer, n, s)
#define vt_DECKPAM() moo_term_set_mode (parser->term, MODE_DECNKM, TRUE) #define VT_DECKPAM moo_term_set_mode (parser->term, MODE_DECNKM, TRUE)
#define vt_DECKPNM() moo_term_set_mode (parser->term, MODE_DECNKM, FALSE) #define VT_DECKPNM moo_term_set_mode (parser->term, MODE_DECNKM, FALSE)
#define vt_DECSAVE() moo_term_save_dec_modes (parser->term, \ #define VT_DECSAVE moo_term_save_dec_modes (parser->term, \
(int*) parser->numbers->data, \ (int*) parser->numbers->data, \
parser->numbers->len) parser->numbers->len)
#define vt_DECRESTORE() moo_term_restore_dec_modes (parser->term, \ #define VT_DECRESTORE moo_term_restore_dec_modes (parser->term, \
(int*) parser->numbers->data, \ (int*) parser->numbers->data, \
parser->numbers->len) parser->numbers->len)
#define vt_DA1() moo_term_da1 (parser->term) #define VT_DA1 moo_term_da1 (parser->term)
#define vt_DA2() moo_term_da2 (parser->term) #define VT_DA2 moo_term_da2 (parser->term)
#define vt_DA3() moo_term_da3 (parser->term) #define VT_DA3 moo_term_da3 (parser->term)
#define vt_DECRQSS(s) moo_term_setting_request (parser->term, s) #define VT_DECRQSS(s) moo_term_setting_request (parser->term, s)
#define vt_DSR(t,a,e) moo_term_dsr (parser->term, t, a, e) #define VT_DSR(t,a,e) moo_term_dsr (parser->term, t, a, e)
#define vt_DECSTR() moo_term_soft_reset (parser->term) #define VT_DECSTR moo_term_soft_reset (parser->term)
#define vt_RIS() moo_term_reset (parser->term) #define VT_RIS moo_term_reset (parser->term)
#define vt_CBT(n) moo_term_buffer_back_tab (parser->term->priv->buffer, n) #define VT_CBT(n) moo_term_buffer_back_tab (parser->term->priv->buffer, n)
#define vt_CHA(n) moo_term_buffer_cursor_move_to (parser->term->priv->buffer, -1, n) #define VT_CHA(n) moo_term_buffer_cursor_move_to (parser->term->priv->buffer, -1, n)
#define vt_CHT(n) moo_term_buffer_tab (parser->term->priv->buffer, n) #define VT_CHT(n) moo_term_buffer_tab (parser->term->priv->buffer, n)
#define vt_CNL(n) moo_term_buffer_cursor_next_line (parser->term->priv->buffer, n) #define VT_CNL(n) moo_term_buffer_cursor_next_line (parser->term->priv->buffer, n)
#define vt_CPL(n) moo_term_buffer_cursor_prev_line (parser->term->priv->buffer, n) #define VT_CPL(n) moo_term_buffer_cursor_prev_line (parser->term->priv->buffer, n)
#define vt_HPA(n) moo_term_buffer_cursor_move_to (parser->term->priv->buffer, -1, n) #define VT_HPA(n) moo_term_buffer_cursor_move_to (parser->term->priv->buffer, -1, n)
#define vt_HPR(n) moo_term_buffer_cursor_move (parser->term->priv->buffer, 0, n) #define VT_HPR(n) moo_term_buffer_cursor_move (parser->term->priv->buffer, 0, n)
#define vt_VPA(n) moo_term_buffer_cursor_move_to (parser->term->priv->buffer, n, -1) #define VT_VPA(n) moo_term_buffer_cursor_move_to (parser->term->priv->buffer, n, -1)
#define vt_VPR(n) moo_term_buffer_cursor_move (parser->term->priv->buffer, n, 0) #define VT_VPR(n) moo_term_buffer_cursor_move (parser->term->priv->buffer, n, 0)
#define vt_DECALN() moo_term_buffer_decaln (parser->term->priv->buffer) #define VT_DECALN moo_term_buffer_decaln (parser->term->priv->buffer)
#endif /* MOOTERM_MOOTERM_CTLFUNCS_H */ #endif /* MOOTERM_MOOTERM_CTLFUNCS_H */

4
moo/mooterm/mooterm.c
View File

@ -1073,14 +1073,14 @@ void moo_term_set_mode (MooTerm *term,
void moo_term_set_ca_mode (MooTerm *term, void moo_term_set_ca_mode (MooTerm *term,
gboolean set) gboolean set)
{ {
term_implement_me (); TERM_IMPLEMENT_ME;
} }
void moo_term_set_alternate_buffer (MooTerm *term, void moo_term_set_alternate_buffer (MooTerm *term,
gboolean alternate) gboolean alternate)
{ {
term_implement_me (); TERM_IMPLEMENT_ME;
} }

22
moo/mooterm/mootermbuffer-private.h
View File

@ -181,7 +181,7 @@ inline static GdkRegion *buf_get_changed(MooTermBuffer *buf)
#define buf_changed_add_rect(buf,rect) \ #define buf_changed_add_rect(buf,rect) \
{ \ G_STMT_START { \
if (!buf->priv->changed_all) \ if (!buf->priv->changed_all) \
{ \ { \
if (buf->priv->changed) \ if (buf->priv->changed) \
@ -189,19 +189,19 @@ inline static GdkRegion *buf_get_changed(MooTermBuffer *buf)
else \ else \
buf->priv->changed = gdk_region_rectangle (&rect); \ buf->priv->changed = gdk_region_rectangle (&rect); \
} \ } \
} } G_STMT_END
#define buf_changed_add_range(buf, row, start, len) \ #define buf_changed_add_range(buf, row, start, len) \
{ \ G_STMT_START { \
if (!buf->priv->changed_all) \ if (!buf->priv->changed_all) \
{ \ { \
GdkRectangle rec = {start, row, len, 1}; \ GdkRectangle rec = {start, row, len, 1}; \
buf_changed_add_rect (buf, rec); \ buf_changed_add_rect (buf, rec); \
} \ } \
} } G_STMT_END
#define buf_changed_set_all(buf) \ #define buf_changed_set_all(buf) \
{ \ G_STMT_START { \
if (!buf->priv->changed_all) \ if (!buf->priv->changed_all) \
{ \ { \
GdkRectangle rec = { \ GdkRectangle rec = { \
@ -210,7 +210,7 @@ inline static GdkRegion *buf_get_changed(MooTermBuffer *buf)
buf_changed_add_rect (buf, rec); \ buf_changed_add_rect (buf, rec); \
buf->priv->changed_all = TRUE; \ buf->priv->changed_all = TRUE; \
} \ } \
} } G_STMT_END
#define buf_set_attrs_mask(mask_) buf->priv->current_attr.mask = (mask_) #define buf_set_attrs_mask(mask_) buf->priv->current_attr.mask = (mask_)
@ -218,6 +218,7 @@ inline static GdkRegion *buf_get_changed(MooTermBuffer *buf)
#define buf_remove_attrs_mask(mask_) buf->priv->current_attr.mask &= ~(mask_) #define buf_remove_attrs_mask(mask_) buf->priv->current_attr.mask &= ~(mask_)
#define buf_set_ansi_foreground(color) \ #define buf_set_ansi_foreground(color) \
G_STMT_START { \
if ((color) < MOO_TERM_COLOR_MAX) \ if ((color) < MOO_TERM_COLOR_MAX) \
{ \ { \
buf->priv->current_attr.mask |= MOO_TERM_TEXT_FOREGROUND; \ buf->priv->current_attr.mask |= MOO_TERM_TEXT_FOREGROUND; \
@ -226,9 +227,11 @@ inline static GdkRegion *buf_get_changed(MooTermBuffer *buf)
else \ else \
{ \ { \
buf->priv->current_attr.mask &= ~MOO_TERM_TEXT_FOREGROUND; \ buf->priv->current_attr.mask &= ~MOO_TERM_TEXT_FOREGROUND; \
} } \
} G_STMT_END
#define buf_set_ansi_background(color) \ #define buf_set_ansi_background(color) \
G_STMT_START { \
if ((color) < MOO_TERM_COLOR_MAX) \ if ((color) < MOO_TERM_COLOR_MAX) \
{ \ { \
buf->priv->current_attr.mask |= MOO_TERM_TEXT_BACKGROUND; \ buf->priv->current_attr.mask |= MOO_TERM_TEXT_BACKGROUND; \
@ -237,7 +240,8 @@ inline static GdkRegion *buf_get_changed(MooTermBuffer *buf)
else \ else \
{ \ { \
buf->priv->current_attr.mask &= ~MOO_TERM_TEXT_BACKGROUND; \ buf->priv->current_attr.mask &= ~MOO_TERM_TEXT_BACKGROUND; \
} } \
} G_STMT_END
inline static MooTermLine *buf_line (MooTermBuffer *buf, inline static MooTermLine *buf_line (MooTermBuffer *buf,

64
moo/mooterm/mootermbuffer.c
View File

@ -852,38 +852,38 @@ void moo_term_buffer_thaw_cursor_notify (MooTermBuffer *buf)
} }
#define freeze_notify() \ #define FREEZE_NOTIFY \
{ \ G_STMT_START { \
moo_term_buffer_freeze_changed_notify (buf); \ moo_term_buffer_freeze_changed_notify (buf); \
moo_term_buffer_freeze_cursor_notify (buf); \ moo_term_buffer_freeze_cursor_notify (buf); \
} } G_STMT_END
#define notify() \ #define NOTIFY \
{ \ G_STMT_START { \
moo_term_buffer_changed (buf); \ moo_term_buffer_changed (buf); \
moo_term_buffer_cursor_moved (buf); \ moo_term_buffer_cursor_moved (buf); \
} } G_STMT_END
#define thaw_notify() \ #define THAW_NOTIFY \
{ \ G_STMT_START { \
moo_term_buffer_thaw_changed_notify (buf); \ moo_term_buffer_thaw_changed_notify (buf); \
moo_term_buffer_thaw_cursor_notify (buf); \ moo_term_buffer_thaw_cursor_notify (buf); \
} } G_STMT_END
#define thaw_and_notify() \ #define THAW_AND_NOTIFY \
{ \ G_STMT_START { \
thaw_notify (); \ THAW_NOTIFY; \
notify(); \ NOTIFY; \
} } G_STMT_END
#define notify_changed() moo_term_buffer_changed (buf) #define NOTIFY_CHANGED moo_term_buffer_changed (buf)
#define freeze_changed() moo_term_buffer_freeze_changed_notify (buf); #define FREEZE_CHANGED moo_term_buffer_freeze_changed_notify (buf)
#define thaw_and_notify_changed() \ #define THAW_AND_NOTIFY_CHANGED \
{ \ G_STMT_START { \
moo_term_buffer_thaw_changed_notify (buf); \ moo_term_buffer_thaw_changed_notify (buf); \
moo_term_buffer_changed (buf); \ moo_term_buffer_changed (buf); \
} } G_STMT_END
/*****************************************************************************/ /*****************************************************************************/
@ -930,10 +930,10 @@ void moo_term_buffer_cud (MooTermBuffer *buf,
void moo_term_buffer_new_line (MooTermBuffer *buf) void moo_term_buffer_new_line (MooTermBuffer *buf)
{ {
freeze_notify (); FREEZE_NOTIFY;
moo_term_buffer_index (buf); moo_term_buffer_index (buf);
moo_term_buffer_cursor_move_to (buf, -1, 0); moo_term_buffer_cursor_move_to (buf, -1, 0);
thaw_and_notify (); THAW_AND_NOTIFY;
} }
@ -1001,7 +1001,7 @@ void moo_term_buffer_index (MooTermBuffer *buf)
} }
} }
notify (); NOTIFY;
} }
@ -1036,7 +1036,7 @@ void moo_term_buffer_reverse_index (MooTermBuffer *buf)
buf->priv->cursor_row -= 1; buf->priv->cursor_row -= 1;
} }
notify (); NOTIFY;
} }
@ -1190,7 +1190,7 @@ void moo_term_buffer_delete_char (MooTermBuffer *buf,
cursor_col, n); cursor_col, n);
buf_changed_add_range(buf, cursor_row, cursor_col, buf_changed_add_range(buf, cursor_row, cursor_col,
buf_screen_width (buf) - cursor_col); buf_screen_width (buf) - cursor_col);
notify_changed (); NOTIFY_CHANGED;
} }
@ -1209,7 +1209,7 @@ void moo_term_buffer_erase_range (MooTermBuffer *buf,
term_line_erase_range (buf_screen_line (buf, row), term_line_erase_range (buf_screen_line (buf, row),
col, len); col, len);
buf_changed_add_range (buf, row, col, len); buf_changed_add_range (buf, row, col, len);
notify_changed (); NOTIFY_CHANGED;
} }
@ -1237,7 +1237,7 @@ void moo_term_buffer_erase_in_display (MooTermBuffer *buf,
g_return_if_fail (what == 0 || what == 1 || what == 2); g_return_if_fail (what == 0 || what == 1 || what == 2);
freeze_changed (); FREEZE_CHANGED;
switch (what) switch (what)
{ {
@ -1261,7 +1261,7 @@ void moo_term_buffer_erase_in_display (MooTermBuffer *buf,
break; break;
} }
thaw_and_notify_changed (); THAW_AND_NOTIFY_CHANGED;
} }
@ -1313,7 +1313,7 @@ void moo_term_buffer_insert_char (MooTermBuffer *buf,
&ZERO_ATTR, buf_screen_width (buf)); &ZERO_ATTR, buf_screen_width (buf));
buf_changed_add_range (buf, cursor_row, cursor_col, buf_changed_add_range (buf, cursor_row, cursor_col,
buf_screen_width (buf) - cursor_col); buf_screen_width (buf) - cursor_col);
notify_changed (); NOTIFY_CHANGED;
} }
@ -1536,7 +1536,7 @@ void moo_term_buffer_reset (MooTermBuffer *buf)
{ {
guint i; guint i;
freeze_notify (); FREEZE_NOTIFY;
for (i = 0; i < buf->priv->lines->len; ++i) for (i = 0; i < buf->priv->lines->len; ++i)
term_line_free (g_ptr_array_index (buf->priv->lines, i)); term_line_free (g_ptr_array_index (buf->priv->lines, i));
@ -1551,7 +1551,7 @@ void moo_term_buffer_reset (MooTermBuffer *buf)
set_defaults (buf); set_defaults (buf);
buf_changed_set_all (buf); buf_changed_set_all (buf);
thaw_and_notify (); THAW_AND_NOTIFY;
moo_term_buffer_scrollback_changed (buf); moo_term_buffer_scrollback_changed (buf);
} }
@ -1621,7 +1621,7 @@ void moo_term_buffer_decaln (MooTermBuffer *buf)
guint width = buf_screen_width (buf); guint width = buf_screen_width (buf);
guint height = buf_screen_height (buf); guint height = buf_screen_height (buf);
freeze_changed (); FREEZE_CHANGED;
for (i = 0; i < height; ++i) for (i = 0; i < height; ++i)
term_line_set_unichar (buf_screen_line (buf, i), term_line_set_unichar (buf_screen_line (buf, i),
@ -1631,5 +1631,5 @@ void moo_term_buffer_decaln (MooTermBuffer *buf)
buf_changed_set_all (buf); buf_changed_set_all (buf);
thaw_and_notify_changed (); THAW_AND_NOTIFY_CHANGED;
} }

368
moo/mooterm/mootermparser-yacc.y
View File

@ -3,8 +3,8 @@
#include "mooterm/mootermparser.h" #include "mooterm/mootermparser.h"
#include "mooterm/mooterm-vtctls.h" #include "mooterm/mooterm-vtctls.h"
#define add_number(n) \ #define ADD_NUMBER(n) \
{ \ G_STMT_START { \
if (parser->numbers->len >= MAX_PARAMS_NUM) \ if (parser->numbers->len >= MAX_PARAMS_NUM) \
{ \ { \
g_warning ("%s: too many parameters passed", \ g_warning ("%s: too many parameters passed", \
@ -16,17 +16,17 @@
int val = n; \ int val = n; \
g_array_append_val (parser->numbers, val); \ g_array_append_val (parser->numbers, val); \
} \ } \
} } G_STMT_END
#define nums_len() (parser->numbers->len) #define NUMS_LEN (parser->numbers->len)
#define check_nums_len(n) \ #define CHECK_NUMS_LEN(n) \
{ \ G_STMT_START { \
if (parser->numbers->len != n) \ if (parser->numbers->len != n) \
YYABORT; \ YYABORT; \
} } G_STMT_END
#define get_num(n) (((int*)parser->numbers->data)[n]) #define GET_NUM(n) (((int*)parser->numbers->data)[n])
#define TERMINAL_HEIGHT (buf_screen_height (parser->term->priv->buffer)) #define TERMINAL_HEIGHT (buf_screen_height (parser->term->priv->buffer))
#define TERMINAL_WIDTH (buf_screen_width (parser->term->priv->buffer)) #define TERMINAL_WIDTH (buf_screen_width (parser->term->priv->buffer))
@ -80,44 +80,44 @@ escape_sequence: NEL
; ;
NEL: '\033' 'E' { vt_NEL (); }; NEL: '\033' 'E' { VT_NEL; };
DECRC: '\033' '8' { vt_DECRC (); }; DECRC: '\033' '8' { VT_DECRC; };
DECSC: '\033' '7' { vt_DECSC (); }; DECSC: '\033' '7' { VT_DECSC; };
HTS: '\033' 'H' { vt_HTS (); }; HTS: '\033' 'H' { VT_HTS; };
DECBI: '\033' '6' { vt_not_implemented(); }; DECBI: '\033' '6' { VT_NOT_IMPLEMENTED; };
DECFI: '\033' '9' { vt_not_implemented(); }; DECFI: '\033' '9' { VT_NOT_IMPLEMENTED; };
IND: '\033' 'D' { vt_IND (); }; IND: '\033' 'D' { VT_IND; };
RI: '\033' 'M' { vt_RI (); }; RI: '\033' 'M' { VT_RI; };
SS2: '\033' 'N' { vt_not_implemented(); }; SS2: '\033' 'N' { VT_NOT_IMPLEMENTED; };
SS3: '\033' 'O' { vt_not_implemented(); }; SS3: '\033' 'O' { VT_NOT_IMPLEMENTED; };
DECID: '\033' 'Z' { vt_not_implemented(); }; DECID: '\033' 'Z' { VT_NOT_IMPLEMENTED; };
RIS: '\033' 'c' { vt_RIS (); }; RIS: '\033' 'c' { VT_RIS; };
DECANM: '\033' '<' { vt_not_implemented(); }; DECANM: '\033' '<' { VT_NOT_IMPLEMENTED; };
DECKPAM: '\033' '=' { vt_DECKPAM (); }; DECKPAM: '\033' '=' { VT_DECKPAM; };
DECKPNM: '\033' '>' { vt_DECKPNM (); }; DECKPNM: '\033' '>' { VT_DECKPNM; };
LS1R: '\033' '~' { vt_not_implemented(); }; LS1R: '\033' '~' { VT_NOT_IMPLEMENTED; };
LS2: '\033' 'n' { vt_not_implemented(); }; LS2: '\033' 'n' { VT_NOT_IMPLEMENTED; };
LS2R: '\033' '}' { vt_not_implemented(); }; LS2R: '\033' '}' { VT_NOT_IMPLEMENTED; };
LS3: '\033' 'o' { vt_not_implemented(); }; LS3: '\033' 'o' { VT_NOT_IMPLEMENTED; };
LS3R: '\033' '|' { vt_not_implemented(); }; LS3R: '\033' '|' { VT_NOT_IMPLEMENTED; };
DECDHLT: '\033' '#' '3' { vt_not_implemented(); }; DECDHLT: '\033' '#' '3' { VT_NOT_IMPLEMENTED; };
DECDHLB: '\033' '#' '4' { vt_not_implemented(); }; DECDHLB: '\033' '#' '4' { VT_NOT_IMPLEMENTED; };
DECSWL: '\033' '#' '5' { vt_not_implemented(); }; DECSWL: '\033' '#' '5' { VT_NOT_IMPLEMENTED; };
DECDWL: '\033' '#' '6' { vt_not_implemented(); }; DECDWL: '\033' '#' '6' { VT_NOT_IMPLEMENTED; };
DECALN: '\033' '#' '8' { vt_DECALN (); }; DECALN: '\033' '#' '8' { VT_DECALN; };
S7C1T: '\033' ' ' 'F' { vt_ignored (); }; S7C1T: '\033' ' ' 'F' { VT_IGNORED; };
S8C1T: '\033' ' ' 'G' { vt_ignored (); }; S8C1T: '\033' ' ' 'G' { VT_IGNORED; };
SCS: '\033' SCS_set_num SCS_set { vt_SCS (get_num(0), get_num(1)); }; SCS: '\033' SCS_set_num SCS_set { VT_SCS (GET_NUM(0), GET_NUM(1)); };
SCS_set_num: '(' { add_number (0); } SCS_set_num: '(' { ADD_NUMBER (0); }
| ')' { add_number (1); } | ')' { ADD_NUMBER (1); }
| '*' { add_number (2); } | '*' { ADD_NUMBER (2); }
| '+' { add_number (3); }; | '+' { ADD_NUMBER (3); };
SCS_set: '0' { add_number (0); } SCS_set: '0' { ADD_NUMBER (0); }
| '1' { add_number (1); } | '1' { ADD_NUMBER (1); }
| '2' { add_number (2); } | '2' { ADD_NUMBER (2); }
| 'A' { add_number (3); } | 'A' { ADD_NUMBER (3); }
| 'B' { add_number (4); }; | 'B' { ADD_NUMBER (4); };
/****************************************************************************/ /****************************************************************************/
@ -195,171 +195,171 @@ control_sequence: DECSR
; ;
DECSR: '\233' number '+' 'p' { vt_not_implemented(); }; DECSR: '\233' number '+' 'p' { VT_NOT_IMPLEMENTED; };
/* default parameter - 1 */ /* default parameter - 1 */
CUU: '\233' number 'A' { vt_CUU ($2); } CUU: '\233' number 'A' { VT_CUU ($2); }
| '\233' 'A' { vt_CUU (1); }; | '\233' 'A' { VT_CUU (1); };
CUD: '\233' number 'B' { vt_CUD ($2); } CUD: '\233' number 'B' { VT_CUD ($2); }
| '\233' 'B' { vt_CUD (1); }; | '\233' 'B' { VT_CUD (1); };
CUF: '\233' number 'C' { vt_CUF ($2); } CUF: '\233' number 'C' { VT_CUF ($2); }
| '\233' 'C' { vt_CUF (1); }; | '\233' 'C' { VT_CUF (1); };
CUB: '\233' number 'D' { vt_CUB ($2); } CUB: '\233' number 'D' { VT_CUB ($2); }
| '\233' 'D' { vt_CUB (1); }; | '\233' 'D' { VT_CUB (1); };
CBT: '\233' number 'Z' { vt_CBT ($2 ? $2 : 1); } CBT: '\233' number 'Z' { VT_CBT ($2 ? $2 : 1); }
| '\233' 'Z' { vt_CBT (1); }; | '\233' 'Z' { VT_CBT (1); };
CHA: '\233' number 'G' { vt_CHA ($2 ? $2 : 1); } CHA: '\233' number 'G' { VT_CHA ($2 ? $2 : 1); }
| '\233' 'G' { vt_CHA (1); }; | '\233' 'G' { VT_CHA (1); };
CHT: '\233' number 'I' { vt_CHT ($2 ? $2 : 1); } CHT: '\233' number 'I' { VT_CHT ($2 ? $2 : 1); }
| '\233' 'I' { vt_CHT (1); }; | '\233' 'I' { VT_CHT (1); };
CNL: '\233' number 'E' { vt_CNL ($2 ? $2 : 1); } CNL: '\233' number 'E' { VT_CNL ($2 ? $2 : 1); }
| '\233' 'E' { vt_CNL (1); }; | '\233' 'E' { VT_CNL (1); };
CPL: '\233' number 'F' { vt_CPL ($2 ? $2 : 1); } CPL: '\233' number 'F' { VT_CPL ($2 ? $2 : 1); }
| '\233' 'F' { vt_CPL (1); }; | '\233' 'F' { VT_CPL (1); };
HPA: '\233' number '`' { vt_HPA ($2 ? $2 : 1); } HPA: '\233' number '`' { VT_HPA ($2 ? $2 : 1); }
| '\233' '`' { vt_HPA (1); }; | '\233' '`' { VT_HPA (1); };
HPR: '\233' number 'a' { vt_HPR ($2 ? $2 : 1); } HPR: '\233' number 'a' { VT_HPR ($2 ? $2 : 1); }
| '\233' 'a' { vt_HPR (1); }; | '\233' 'a' { VT_HPR (1); };
VPA: '\233' number 'd' { vt_VPA ($2 ? $2 : 1); } VPA: '\233' number 'd' { VT_VPA ($2 ? $2 : 1); }
| '\233' 'd' { vt_VPA (1); }; | '\233' 'd' { VT_VPA (1); };
VPR: '\233' number 'e' { vt_VPR ($2 ? $2 : 1); } VPR: '\233' number 'e' { VT_VPR ($2 ? $2 : 1); }
| '\233' 'e' { vt_VPR (1); }; | '\233' 'e' { VT_VPR (1); };
CUP: '\233' numbers 'H' { check_nums_len (2); CUP: '\233' numbers 'H' { CHECK_NUMS_LEN (2);
vt_CUP (get_num (0) ? get_num (0) : 1, VT_CUP (GET_NUM (0) ? GET_NUM (0) : 1,
get_num (1) ? get_num (1) : 1); } GET_NUM (1) ? GET_NUM (1) : 1); }
| '\233' 'H' { vt_CUP (1, 1); } | '\233' 'H' { VT_CUP (1, 1); }
| '\233' numbers 'f' { check_nums_len (2); | '\233' numbers 'f' { CHECK_NUMS_LEN (2);
vt_CUP (get_num (0) ? get_num (0) : 1, VT_CUP (GET_NUM (0) ? GET_NUM (0) : 1,
get_num (1) ? get_num (1) : 1); } /* HVP */ GET_NUM (1) ? GET_NUM (1) : 1); } /* HVP */
| '\233' 'f' { vt_CUP (1, 1); }; | '\233' 'f' { VT_CUP (1, 1); };
DECSCUSR: '\233' number ' ' 'q' { vt_not_implemented(); } DECSCUSR: '\233' number ' ' 'q' { VT_NOT_IMPLEMENTED; }
| '\233' ' ' 'q' { vt_not_implemented(); }; | '\233' ' ' 'q' { VT_NOT_IMPLEMENTED; };
DECST8C: '\233' '?' number 'W' { vt_not_implemented(); }; DECST8C: '\233' '?' number 'W' { VT_NOT_IMPLEMENTED; };
TBC: '\233' number 'g' { vt_TBC ($2); } TBC: '\233' number 'g' { VT_TBC ($2); }
| '\233' 'g' { vt_TBC (0); }; | '\233' 'g' { VT_TBC (0); };
DECSLRM: '\233' numbers 's' { vt_not_implemented(); } DECSLRM: '\233' numbers 's' { VT_NOT_IMPLEMENTED; }
| '\233' 's' { vt_not_implemented(); }; | '\233' 's' { VT_NOT_IMPLEMENTED; };
DECSSCLS: '\233' number ' ' 'p' { vt_not_implemented(); } DECSSCLS: '\233' number ' ' 'p' { VT_NOT_IMPLEMENTED; }
| '\233' ' ' 'p' { vt_not_implemented(); }; | '\233' ' ' 'p' { VT_NOT_IMPLEMENTED; };
DECSTBM: '\233' numbers 'r' { check_nums_len (2); DECSTBM: '\233' numbers 'r' { CHECK_NUMS_LEN (2);
vt_DECSTBM (get_num (0) ? get_num (0) : 1, VT_DECSTBM (GET_NUM (0) ? GET_NUM (0) : 1,
get_num (1) ? get_num (1) : 1); } GET_NUM (1) ? GET_NUM (1) : 1); }
| '\233' 'r' { vt_DECSTBM (1, TERMINAL_HEIGHT); }; | '\233' 'r' { VT_DECSTBM (1, TERMINAL_HEIGHT); };
DECSLPP: '\233' number 't' { vt_not_implemented(); } DECSLPP: '\233' number 't' { VT_NOT_IMPLEMENTED; }
| '\233' 't' { vt_not_implemented(); }; | '\233' 't' { VT_NOT_IMPLEMENTED; };
NP: '\233' number 'U' { vt_not_implemented(); } NP: '\233' number 'U' { VT_NOT_IMPLEMENTED; }
| '\233' 'U' { vt_not_implemented(); }; | '\233' 'U' { VT_NOT_IMPLEMENTED; };
PP: '\233' number 'V' { vt_not_implemented(); } PP: '\233' number 'V' { VT_NOT_IMPLEMENTED; }
| '\233' 'V' { vt_not_implemented(); }; | '\233' 'V' { VT_NOT_IMPLEMENTED; };
PPA: '\233' number ' ' 'P' { vt_not_implemented(); } PPA: '\233' number ' ' 'P' { VT_NOT_IMPLEMENTED; }
| '\233' ' ' 'P' { vt_not_implemented(); }; | '\233' ' ' 'P' { VT_NOT_IMPLEMENTED; };
PPB: '\233' number ' ' 'R' { vt_not_implemented(); } PPB: '\233' number ' ' 'R' { VT_NOT_IMPLEMENTED; }
| '\233' ' ' 'R' { vt_not_implemented(); }; | '\233' ' ' 'R' { VT_NOT_IMPLEMENTED; };
PPR: '\233' number ' ' 'Q' { vt_not_implemented(); } PPR: '\233' number ' ' 'Q' { VT_NOT_IMPLEMENTED; }
| '\233' ' ' 'Q' { vt_not_implemented(); }; | '\233' ' ' 'Q' { VT_NOT_IMPLEMENTED; };
DECRQDE: '\233' '"' 'v' { vt_not_implemented(); }; DECRQDE: '\233' '"' 'v' { VT_NOT_IMPLEMENTED; };
SD: '\233' number 'S' { vt_not_implemented(); }; SD: '\233' number 'S' { VT_NOT_IMPLEMENTED; };
SU: '\233' number 'T' { vt_not_implemented(); }; SU: '\233' number 'T' { VT_NOT_IMPLEMENTED; };
DECRQUPSS: '\233' '&' 'u' { vt_not_implemented(); }; DECRQUPSS: '\233' '&' 'u' { VT_NOT_IMPLEMENTED; };
DECDC: '\233' number '\'' '~' { vt_not_implemented(); } DECDC: '\233' number '\'' '~' { VT_NOT_IMPLEMENTED; }
| '\233' '\'' '~' { vt_not_implemented(); }; | '\233' '\'' '~' { VT_NOT_IMPLEMENTED; };
DECIC: '\233' number '\'' '}' { vt_not_implemented(); } DECIC: '\233' number '\'' '}' { VT_NOT_IMPLEMENTED; }
| '\233' '\'' '}' { vt_not_implemented(); }; | '\233' '\'' '}' { VT_NOT_IMPLEMENTED; };
DCH: '\233' number 'P' { vt_DCH ($2 ? $2 : 1); } DCH: '\233' number 'P' { VT_DCH ($2 ? $2 : 1); }
| '\233' 'P' { vt_DCH (1); }; | '\233' 'P' { VT_DCH (1); };
DL: '\233' number 'M' { vt_DL ($2 ? $2 : 1); } DL: '\233' number 'M' { VT_DL ($2 ? $2 : 1); }
| '\233' 'M' { vt_DL (1); }; | '\233' 'M' { VT_DL (1); };
ECH: '\233' number 'X' { vt_ECH ($2 ? $2 : 1); } ECH: '\233' number 'X' { VT_ECH ($2 ? $2 : 1); }
| '\233' 'X' { vt_ECH (1); }; | '\233' 'X' { VT_ECH (1); };
ED: '\233' number 'J' { vt_ED ($2); } ED: '\233' number 'J' { VT_ED ($2); }
| '\233' 'J' { vt_ED (0); }; | '\233' 'J' { VT_ED (0); };
EL: '\233' number 'K' { vt_EL ($2); } EL: '\233' number 'K' { VT_EL ($2); }
| '\233' 'K' { vt_EL (0); }; | '\233' 'K' { VT_EL (0); };
ICH: '\233' number '@' { vt_ICH ($2 ? $2 : 1); } ICH: '\233' number '@' { VT_ICH ($2 ? $2 : 1); }
| '\233' '@' { vt_ICH (1); }; | '\233' '@' { VT_ICH (1); };
IL: '\233' number 'L' { vt_IL ($2 ? $2 : 1); } IL: '\233' number 'L' { VT_IL ($2 ? $2 : 1); }
| '\233' 'L' { vt_IL (1); }; | '\233' 'L' { VT_IL (1); };
DECSCA: '\233' number '"' 'q' { vt_not_implemented(); }; DECSCA: '\233' number '"' 'q' { VT_NOT_IMPLEMENTED; };
DECSED: '\233' '?' number 'J' { vt_not_implemented(); } DECSED: '\233' '?' number 'J' { VT_NOT_IMPLEMENTED; }
| '\233' '?' 'J' { vt_not_implemented(); }; | '\233' '?' 'J' { VT_NOT_IMPLEMENTED; };
DECSEL: '\233' '?' number 'K' { vt_not_implemented(); } DECSEL: '\233' '?' number 'K' { VT_NOT_IMPLEMENTED; }
| '\233' '?' 'K' { vt_not_implemented(); }; | '\233' '?' 'K' { VT_NOT_IMPLEMENTED; };
DECSCPP: '\233' numbers '$' '|' { vt_not_implemented(); } DECSCPP: '\233' numbers '$' '|' { VT_NOT_IMPLEMENTED; }
| '\233' '$' '|' { vt_not_implemented(); }; | '\233' '$' '|' { VT_NOT_IMPLEMENTED; };
DECCARA: '\233' numbers '$' 'r' { vt_not_implemented(); }; DECCARA: '\233' numbers '$' 'r' { VT_NOT_IMPLEMENTED; };
DECCRA: '\233' numbers '$' 'v' { vt_not_implemented(); }; DECCRA: '\233' numbers '$' 'v' { VT_NOT_IMPLEMENTED; };
DECERA: '\233' numbers '$' 'z' { vt_not_implemented(); }; DECERA: '\233' numbers '$' 'z' { VT_NOT_IMPLEMENTED; };
DECFRA: '\233' numbers '$' 'x' { vt_not_implemented(); }; DECFRA: '\233' numbers '$' 'x' { VT_NOT_IMPLEMENTED; };
DECRARA: '\233' numbers '$' 't' { vt_not_implemented(); }; DECRARA: '\233' numbers '$' 't' { VT_NOT_IMPLEMENTED; };
DECSERA: '\233' numbers '$' '{' { vt_not_implemented(); }; DECSERA: '\233' numbers '$' '{' { VT_NOT_IMPLEMENTED; };
DECSASD: '\233' numbers '$' '}' { vt_not_implemented(); }; DECSASD: '\233' numbers '$' '}' { VT_NOT_IMPLEMENTED; };
DECSSDT: '\233' numbers '$' '~' { vt_not_implemented(); }; DECSSDT: '\233' numbers '$' '~' { VT_NOT_IMPLEMENTED; };
DECSACE: '\233' numbers '*' 'x' { vt_not_implemented(); }; DECSACE: '\233' numbers '*' 'x' { VT_NOT_IMPLEMENTED; };
DECSNLS: '\233' numbers '*' '|' { vt_not_implemented(); }; DECSNLS: '\233' numbers '*' '|' { VT_NOT_IMPLEMENTED; };
DECRQCRA: '\233' numbers '*' 'y' { vt_not_implemented(); }; DECRQCRA: '\233' numbers '*' 'y' { VT_NOT_IMPLEMENTED; };
DSR: '\233' '?' numbers 'n' { if (nums_len() == 2) DSR: '\233' '?' numbers 'n' { if (NUMS_LEN == 2)
{ {
vt_DSR (get_num (0), get_num (1), TRUE); VT_DSR (GET_NUM (0), GET_NUM (1), TRUE);
} }
else else
{ {
vt_DSR (get_num (0), -1, TRUE); VT_DSR (GET_NUM (0), -1, TRUE);
} }
} }
| '\233' numbers 'n' { if (nums_len() == 2) | '\233' numbers 'n' { if (NUMS_LEN == 2)
{ {
vt_DSR (get_num (0), get_num (1), FALSE); VT_DSR (GET_NUM (0), GET_NUM (1), FALSE);
} }
else else
{ {
vt_DSR (get_num (0), -1, FALSE); VT_DSR (GET_NUM (0), -1, FALSE);
} }
}; };
DA1: '\233' 'c' { vt_DA1 (); } DA1: '\233' 'c' { VT_DA1; }
| '\233' number 'c' { vt_DA1 (); }; | '\233' number 'c' { VT_DA1; };
DA2: '\233' '>' 'c' { vt_DA2 (); } DA2: '\233' '>' 'c' { VT_DA2; }
| '\233' '>' number 'c' { vt_DA2 (); }; | '\233' '>' number 'c' { VT_DA2; };
DA3: '\233' '=' 'c' { vt_DA3 (); } DA3: '\233' '=' 'c' { VT_DA3; }
| '\233' '=' number 'c' { vt_DA3 (); }; | '\233' '=' number 'c' { VT_DA3; };
DECTST: '\233' numbers 'y' { vt_ignored (); }; DECTST: '\233' numbers 'y' { VT_IGNORED; };
DECSTR: '\233' '!' 'p' { vt_DECSTR (); }; DECSTR: '\233' '!' 'p' { VT_DECSTR; };
SGR: '\233' numbers 'm' { vt_SGR (); } SGR: '\233' numbers 'm' { VT_SGR; }
| '\233' 'm' { vt_SGR (); }; | '\233' 'm' { VT_SGR; };
DECSET: '\233' '?' numbers 'h' { vt_DECSET (); } DECSET: '\233' '?' numbers 'h' { VT_DECSET; }
| '\233' '?' 'h' { vt_DECSET (); }; | '\233' '?' 'h' { VT_DECSET; };
DECRST: '\233' '?' numbers 'l' { vt_DECRST (); } DECRST: '\233' '?' numbers 'l' { VT_DECRST; }
| '\233' '?' 'l' { vt_DECRST (); }; | '\233' '?' 'l' { VT_DECRST; };
SM: '\233' numbers 'h' { vt_SM (); } SM: '\233' numbers 'h' { VT_SM; }
| '\233' 'h' { vt_SM (); }; | '\233' 'h' { VT_SM; };
RM: '\233' numbers 'l' { vt_RM (); } RM: '\233' numbers 'l' { VT_RM; }
| '\233' 'l' { vt_RM (); }; | '\233' 'l' { VT_RM; };
DECSAVE: '\233' '?' numbers 's' { vt_DECSAVE (); } DECSAVE: '\233' '?' numbers 's' { VT_DECSAVE; }
| '\233' '?' 's' { vt_DECSAVE (); }; | '\233' '?' 's' { VT_DECSAVE; };
DECRESTORE: '\233' '?' numbers 'r' { vt_DECRESTORE (); } DECRESTORE: '\233' '?' numbers 'r' { VT_DECRESTORE; }
| '\233' '?' 'r' { vt_DECRESTORE (); }; | '\233' '?' 'r' { VT_DECRESTORE; };
/****************************************************************************/ /****************************************************************************/
@ -369,14 +369,14 @@ DECRESTORE: '\233' '?' numbers 'r' { vt_DECRESTORE (); }
device_control_sequence: DECRQSS; device_control_sequence: DECRQSS;
DECRQSS: '\220' '$' 'q' DECRQSS_param '\234' { vt_DECRQSS (get_num (0)); } DECRQSS: '\220' '$' 'q' DECRQSS_param '\234' { VT_DECRQSS (GET_NUM (0)); }
DECRQSS_param: '$' 'g' { add_number (CODE_DECSASD); } DECRQSS_param: '$' 'g' { ADD_NUMBER (CODE_DECSASD); }
| '"' 'p' { add_number (CODE_DECSCL); } | '"' 'p' { ADD_NUMBER (CODE_DECSCL); }
| '$' '|' { add_number (CODE_DECSCPP); } | '$' '|' { ADD_NUMBER (CODE_DECSCPP); }
| 't' { add_number (CODE_DECSLPP); } | 't' { ADD_NUMBER (CODE_DECSLPP); }
| '*' '|' { add_number (CODE_DECSNLS); } | '*' '|' { ADD_NUMBER (CODE_DECSNLS); }
| 'r' { add_number (CODE_DECSTBM); } | 'r' { ADD_NUMBER (CODE_DECSTBM); }
; ;
@ -401,10 +401,10 @@ digit: '0' { $$ = 0; }
; ;
semicolons: ';' semicolons: ';'
| semicolons ';' { add_number (-1); } | semicolons ';' { ADD_NUMBER (-1); }
; ;
numbers: number { add_number ($1); } numbers: number { ADD_NUMBER ($1); }
| semicolons number { add_number (-1); add_number ($2); } | semicolons number { ADD_NUMBER (-1); ADD_NUMBER ($2); }
| numbers semicolons number { add_number ($3); } | numbers semicolons number { ADD_NUMBER ($3); }
; ;

50
moo/mooterm/mootermparser.c
View File

@ -195,7 +195,7 @@
/* SUB - cancel sequence in progress and \ /* SUB - cancel sequence in progress and \
print error */ \ print error */ \
case 0x1A: \ case 0x1A: \
vt_print_char (ERROR_CHAR); \ VT_PRINT_CHAR (ERROR_CHAR); \
goto_initial (); \ goto_initial (); \
\ \
case 0x05: \ case 0x05: \
@ -230,7 +230,7 @@
/* SUB - cancel sequence in progress and \ /* SUB - cancel sequence in progress and \
print error */ \ print error */ \
case 0x1A: \ case 0x1A: \
vt_print_char (ERROR_CHAR); \ VT_PRINT_CHAR (ERROR_CHAR); \
goto_initial (); \ goto_initial (); \
\ \
case 0x05: \ case 0x05: \
@ -307,7 +307,7 @@
{ \ { \
g_warning ("%s: invalid UTF8 '%s'", G_STRLOC, \ g_warning ("%s: invalid UTF8 '%s'", G_STRLOC, \
parser->character->str); \ parser->character->str); \
vt_print_char (ERROR_CHAR); \ VT_PRINT_CHAR (ERROR_CHAR); \
g_string_truncate (parser->character, 0); \ g_string_truncate (parser->character, 0); \
} \ } \
} }
@ -330,12 +330,12 @@
case -1: \ case -1: \
g_warning ("%s: invalid UTF8 '%s'", G_STRLOC, \ g_warning ("%s: invalid UTF8 '%s'", G_STRLOC, \
parser->character->str); \ parser->character->str); \
vt_print_char (ERROR_CHAR); \ VT_PRINT_CHAR (ERROR_CHAR); \
g_string_truncate (parser->character, 0); \ g_string_truncate (parser->character, 0); \
break; \ break; \
\ \
default: \ default: \
vt_print_char (uc); \ VT_PRINT_CHAR (uc); \
g_string_truncate (parser->character, 0); \ g_string_truncate (parser->character, 0); \
break; \ break; \
} \ } \
@ -352,7 +352,7 @@
{ \ { \
if (c < 128) \ if (c < 128) \
{ \ { \
vt_print_char (c); \ VT_PRINT_CHAR (c); \
} \ } \
else \ else \
{ \ { \
@ -575,7 +575,7 @@ STATE_APC_:
/* SUB - cancel sequence in progress and /* SUB - cancel sequence in progress and
print error */ print error */
case 0x1A: case 0x1A:
vt_print_char (ERROR_CHAR); VT_PRINT_CHAR (ERROR_CHAR);
goto_initial (); goto_initial ();
case 0x1B: case 0x1B:
@ -616,7 +616,7 @@ STATE_PM_:
/* SUB - cancel sequence in progress and /* SUB - cancel sequence in progress and
print error */ print error */
case 0x1A: case 0x1A:
vt_print_char (ERROR_CHAR); VT_PRINT_CHAR (ERROR_CHAR);
goto_initial (); goto_initial ();
case 0x1B: case 0x1B:
@ -657,7 +657,7 @@ STATE_OSC_:
/* SUB - cancel sequence in progress and /* SUB - cancel sequence in progress and
print error */ print error */
case 0x1A: case 0x1A:
vt_print_char (ERROR_CHAR); VT_PRINT_CHAR (ERROR_CHAR);
goto_initial (); goto_initial ();
case 0x1B: case 0x1B:
@ -847,55 +847,55 @@ static void exec_cmd (MooTermParser *parser,
switch (cmd) switch (cmd)
{ {
case 0x07: case 0x07:
vt_BEL (); VT_BEL;
break; break;
case 0x08: case 0x08:
vt_BS (); VT_BS;
break; break;
case 0x09: case 0x09:
vt_TAB (); VT_TAB;
break; break;
case 0x0A: case 0x0A:
case 0x0B: case 0x0B:
case 0x0C: case 0x0C:
vt_LF (); VT_LF;
break; break;
case 0x0D: case 0x0D:
vt_CR (); VT_CR;
break; break;
case 0x0E: case 0x0E:
vt_SO (); VT_SO;
break; break;
case 0x0F: case 0x0F:
vt_SI (); VT_SI;
break; break;
case 0x11: case 0x11:
vt_XON (); VT_XON;
break; break;
case 0x13: case 0x13:
vt_XOFF (); VT_XOFF;
break; break;
case 0x84: case 0x84:
vt_IND (); VT_IND;
break; break;
case 0x85: case 0x85:
vt_NEL (); VT_NEL;
break; break;
case 0x88: case 0x88:
vt_HTS (); VT_HTS;
break; break;
case 0x8D: case 0x8D:
vt_RI (); VT_RI;
break; break;
case 0x8E: case 0x8E:
vt_SS2 (); VT_SS2;
break; break;
case 0x8F: case 0x8F:
vt_SS3 (); VT_SS3;
break; break;
case 0x9A: case 0x9A:
vt_DECID (); VT_DECID;
break; break;
case 0x05: case 0x05:

8
mooterm.kdevelop
View File

@ -217,16 +217,16 @@
</kdevdoctreeview> </kdevdoctreeview>
<kdevfilecreate> <kdevfilecreate>
<filetypes> <filetypes>
<type icon="source" ext="g" create="template" name="GAP source" > <type icon="source" ext="g" name="GAP source" create="template" >
<descr>A new empty GAP source file</descr> <descr>A new empty GAP source file</descr>
</type> </type>
<type icon="source_cpp" ext="cpp" create="template" name="C++ Source" > <type icon="source_cpp" ext="cpp" name="C++ Source" create="template" >
<descr>A new empty C++ file.</descr> <descr>A new empty C++ file.</descr>
</type> </type>
<type icon="source_h" ext="h" create="template" name="C/C++ Header" > <type icon="source_h" ext="h" name="C/C++ Header" create="template" >
<descr>A new empty header file for C/C++.</descr> <descr>A new empty header file for C/C++.</descr>
</type> </type>
<type icon="source_c" ext="c" create="template" name="C Source" > <type icon="source_c" ext="c" name="C Source" create="template" >
<descr>A new empty C file.</descr> <descr>A new empty C file.</descr>
</type> </type>
</filetypes> </filetypes>