Removed huge cleanup

9 files changed, 575 insertions, 680 deletions

diff --git a/README b/README
index cac5079..c56234d 100644
--- a/README
+++ b/README
@@ -4,8 +4,7 @@ st - simple terminal
 Introduction
 ------------
 This is my personnal build of st, a simple terminal emulator for X
-which sucks less. I've applied some patches, added some compilation
-flags and fixed the code accordingly.
+which sucks less. I've applied some patches.
 
 Depedencies
 -----------
diff --git a/README.org b/README.org
index 67a1764..87fbeb3 100644
--- a/README.org
+++ b/README.org
@@ -3,7 +3,7 @@
 * Introduction
 This is my personnal build of *[[https://st.suckless.org/][st]]*,
 a simple terminal emulator for X which sucks less. I've applied some
-patches, added some compilation flags and fixed the code accordingly.
+patches.
 
 * Depedencies
 - A C compiler
diff --git a/config.h b/config.h
index fa87abb..280e0ad 100644
--- a/config.h
+++ b/config.h
@@ -1,25 +1,13 @@
 /* See LICENSE file for copyright and license details. */
 
-#ifndef __CONFIG_H__
-#define __CONFIG_H__
-
-#include <X11/X.h>
-#include <X11/cursorfont.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "x.h"
-
 /*
  * appearance
  *
  * font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html
- * Remember to remove cwscale if you change font
  */
-char *font = "DejaVuSansMono Nerd Font:pixelsize=14:antialias=true:autohint=true:";
-/* char *font = "mononoki Nerd Font:pixelsize=16:antialias=true:autohint=true:"; */
-/* char *font = "UbuntuMono Nerd Font:pixelsize=17:antialias=true:autohint=true:"; */
-int borderpx = 0;
+/* static char *font = "Liberation Mono:pixelsize=12:antialias=true:autohint=true"; */
+static char *font = "DejaVuSansMono Nerd Font:pixelsize=14:antialias=true:autohint=true:";
+static int borderpx = 0;
 
 /*
  * What program is execed by st depends of these precedence rules:
@@ -29,7 +17,7 @@ int borderpx = 0;
  * 4: value of shell in /etc/passwd
  * 5: value of shell in config.h
  */
-char *shell = "/bin/sh";
+static char *shell = "/bin/sh";
 char *utmp = NULL;
 /* scroll program: to enable use a string like "scroll" */
 char *scroll = NULL;
@@ -39,8 +27,8 @@ char *stty_args = "stty raw pass8 nl -echo -iexten -cstopb 38400";
 char *vtiden = "\033[?6c";
 
 /* Kerning / character bounding-box multipliers */
-float cwscale = 1.0;
-float chscale = 1.0;
+static float cwscale = 1.0;
+static float chscale = 1.0;
 
 /*
  * word delimiter string
@@ -50,16 +38,14 @@ float chscale = 1.0;
 wchar_t *worddelimiters = L" ";
 
 /* selection timeouts (in milliseconds) */
-unsigned int doubleclicktimeout = 300;
-unsigned int tripleclicktimeout = 600;
+static unsigned int doubleclicktimeout = 300;
+static unsigned int tripleclicktimeout = 600;
 
 /* alt screens */
 int allowaltscreen = 1;
 
-/*
- * allow certain non-interactive (insecure) window operations such as:
- * setting the clipboard text
- */
+/* allow certain non-interactive (insecure) window operations such as:
+   setting the clipboard text */
 int allowwindowops = 0;
 
 /*
@@ -68,25 +54,25 @@ int allowwindowops = 0;
  * near minlatency, but it waits longer for slow updates to avoid partial draw.
  * low minlatency will tear/flicker more, as it can "detect" idle too early.
  */
-double minlatency = 8;
-double maxlatency = 33;
+static double minlatency = 8;
+static double maxlatency = 33;
 
 /*
  * blinking timeout (set to 0 to disable blinking) for the terminal blinking
  * attribute.
  */
-unsigned int blinktimeout = 800;
+static unsigned int blinktimeout = 800;
 
 /*
  * thickness of underline and bar cursors
  */
-unsigned int cursorthickness = 2;
+static unsigned int cursorthickness = 2;
 
 /*
  * bell volume. It must be a value between -100 and 100. Use 0 for disabling
  * it
  */
-int bellvolume = 0;
+static int bellvolume = 0;
 
 /* default TERM value */
 char *termname = "st-256color";
@@ -109,7 +95,7 @@ char *termname = "st-256color";
 unsigned int tabspaces = 8;
 
 /* Terminal colors (16 first used in escape sequence) */
-const char *colorname[] = {
+static const char *colorname[] = {
 	/* 8 normal colors */
 	"#32302f",
 	"#cc241d",
@@ -140,26 +126,13 @@ const char *colorname[] = {
 
 
 /*
- * Whether to use pixel geometry or cell geometry
- */
-
-static Geometry geometry = CellGeometry;
-
-/*
  * Default colors (colorname index)
  * foreground, background, cursor, reverse cursor
  */
 unsigned int defaultfg = 256;
 unsigned int defaultbg = 257;
-unsigned int defaultcs = 258;
-unsigned int defaultrcs = 257;
-
-/*
- * Default width and height (including borders!)
- */
-
-static unsigned int width = 564;
-static unsigned int height = 364;
+static unsigned int defaultcs = 258;
+static unsigned int defaultrcs = 257;
 
 /*
  * Default shape of cursor
@@ -168,73 +141,84 @@ static unsigned int height = 364;
  * 6: Bar ("|")
  * 7: Snowman ("☃")
  */
-unsigned int cursorshape = 2;
+static unsigned int cursorshape = 2;
+
+/*
+ * Whether to use pixel geometry or cell geometry
+ */
+
+static Geometry geometry = CellGeometry;
 
 /*
  * Default columns and rows numbers
  */
 
-unsigned int cols = 80;
-unsigned int rows = 24;
+static unsigned int cols = 80;
+static unsigned int rows = 24;
+
+/*
+ * Default width and height (including borders!)
+ */
+
+static unsigned int width = 564;
+static unsigned int height = 364;
 
 /*
  * Default colour and shape of the mouse cursor
  */
-unsigned int mouseshape = XC_xterm;
-unsigned int mousefg = 7;
-unsigned int mousebg = 0;
+static unsigned int mouseshape = XC_xterm;
+static unsigned int mousefg = 7;
+static unsigned int mousebg = 0;
 
 /*
  * Color used to display font attributes when fontconfig selected a font which
  * doesn't match the ones requested.
  */
-unsigned int defaultattr = 11;
+static unsigned int defaultattr = 11;
 
 /*
  * Force mouse select/shortcuts while mask is active (when MODE_MOUSE is set).
  * Note that if you want to use ShiftMask with selmasks, set this to an other
  * modifier, set to 0 to not use it.
  */
-uint forcemousemod = ShiftMask;
+static uint forcemousemod = ShiftMask;
 
 /*
  * Internal mouse shortcuts.
  * Beware that overloading Button1 will disable the selection.
  */
-const unsigned int mousescrollincrement = 3;
-MouseShortcut mshortcuts[] = {
-	/* mask				button		function		argument						release		(for scrollback)*/
-	{ XK_ANY_MOD,		Button4,	kscrollup,		{.i =  mousescrollincrement},	0,			0},
-	{ XK_ANY_MOD,		Button5,	kscrolldown,	{.i =  mousescrollincrement},	0,			0},
-	{ XK_ANY_MOD,		Button2,	selpaste,		{.i = 0},						1,			0 },
-	{ ShiftMask,		Button4,	ttysend,		{.s = "\033[5;2~"},				0,			0 },
-	{ XK_ANY_MOD,		Button4,	ttysend,		{.s = "\031"},					0,			0 },
-	{ ShiftMask,		Button5,	ttysend,		{.s = "\033[6;2~"},				0,			0 },
-	{ XK_ANY_MOD,		Button5,	ttysend,		{.s = "\005"},					0,			0 },
+static MouseShortcut mshortcuts[] = {
+	/* mask                 button   function        argument       release */
+	{ XK_ANY_MOD,           Button4, kscrollup,      {.i = 3},      0, /* !alt */ -1 },
+	{ XK_ANY_MOD,           Button5, kscrolldown,    {.i = 3},      0, /* !alt */ -1 },
+	{ XK_ANY_MOD,           Button2, selpaste,       {.i = 0},      1 },
+	{ ShiftMask,            Button4, ttysend,        {.s = "\033[5;2~"} },
+	{ XK_ANY_MOD,           Button4, ttysend,        {.s = "\031"} },
+	{ ShiftMask,            Button5, ttysend,        {.s = "\033[6;2~"} },
+	{ XK_ANY_MOD,           Button5, ttysend,        {.s = "\005"} },
 };
 
 /* Internal keyboard shortcuts. */
 #define MODKEY Mod1Mask
 #define TERMMOD (ControlMask|ShiftMask)
-#define NEWMOD  (ControlMask|Mod1Mask)
-
-Shortcut shortcuts[] = {
-	/* mask				keysym			function			argument */
-	{ XK_ANY_MOD,		XK_Break,		sendbreak,			{.i =  0} },
-	{ ControlMask,		XK_Print,		toggleprinter,		{.i =  0} },
-	{ ShiftMask,		XK_Print,		printscreen,		{.i =  0} },
-	{ XK_ANY_MOD,		XK_Print,		printsel,			{.i =  0} },
-	{ ControlMask,		XK_equal,		zoom,				{.f = +1} },
-	{ ControlMask,		XK_minus,		zoom,				{.f = -1} },
-	{ ControlMask,		XK_0,			zoomreset,			{.f =  0} },
-	{ TERMMOD,			XK_C,			clipcopy,			{.i =  0} },
-	{ TERMMOD,			XK_V,			clippaste,			{.i =  0} },
-	{ TERMMOD,			XK_Y,			selpaste,			{.i =  0} },
-	{ ShiftMask,		XK_Insert,		selpaste,			{.i =  0} },
-	{ TERMMOD,			XK_Num_Lock,	numlock,			{.i =  0} },
-	{ ShiftMask,		XK_Page_Up,		kscrollup,			{.i = -1} },
-	{ ShiftMask,		XK_Page_Down,	kscrolldown,		{.i = -1} },
-	{ NEWMOD,			XK_c,			keyboard_select,	{.i =  0} },
+
+static Shortcut shortcuts[] = {
+	/* mask                 keysym          function        argument */
+	{ XK_ANY_MOD,           XK_Break,       sendbreak,      {.i =  0} },
+	{ ControlMask,          XK_Print,       toggleprinter,  {.i =  0} },
+	{ ShiftMask,            XK_Print,       printscreen,    {.i =  0} },
+	{ XK_ANY_MOD,           XK_Print,       printsel,       {.i =  0} },
+	{ TERMMOD,              XK_Prior,       zoom,           {.f = +1} },
+	{ TERMMOD,              XK_Next,        zoom,           {.f = -1} },
+	{ TERMMOD,              XK_Home,        zoomreset,      {.f =  0} },
+	{ TERMMOD,              XK_C,           clipcopy,       {.i =  0} },
+	{ TERMMOD,              XK_V,           clippaste,      {.i =  0} },
+	{ TERMMOD,              XK_Y,           selpaste,       {.i =  0} },
+	{ ShiftMask,            XK_Insert,      selpaste,       {.i =  0} },
+	{ TERMMOD,              XK_Num_Lock,    numlock,        {.i =  0} },
+	{ ControlMask|Mod1Mask, XK_c,           keyboard_select,{.i =  0} },
+	{ ShiftMask,            XK_Page_Up,     kscrollup,      {.i = -1} },
+	{ ShiftMask,            XK_Page_Down,   kscrolldown,    {.i = -1} },
 };
 
 /*
@@ -262,229 +246,229 @@ Shortcut shortcuts[] = {
  * If you want keys other than the X11 function keys (0xFD00 - 0xFFFF)
  * to be mapped below, add them to this array.
  */
-KeySym mappedkeys[] = { -1 };
+static KeySym mappedkeys[] = { -1 };
 
 /*
  * State bits to ignore when matching key or button events.  By default,
  * numlock (Mod2Mask) and keyboard layout (XK_SWITCH_MOD) are ignored.
  */
-uint ignoremod = Mod2Mask|XK_SWITCH_MOD;
+static uint ignoremod = Mod2Mask|XK_SWITCH_MOD;
 
 /*
  * This is the huge key array which defines all compatibility to the Linux
  * world. Please decide about changes wisely.
  */
-Key key[] = {
-	/* keysym				mask							string			appkey		appcursor */
-	{ XK_KP_Home,			ShiftMask,						"\033[2J",		 0,			-1 },
-	{ XK_KP_Home,			ShiftMask,						"\033[1;2H",	 0,			+1 },
-	{ XK_KP_Home,			XK_ANY_MOD,						"\033[H",		 0,			-1 },
-	{ XK_KP_Home,			XK_ANY_MOD,						"\033[1~",		 0,			+1 },
-	{ XK_KP_Up,				XK_ANY_MOD,						"\033Ox",		+1,			 0 },
-	{ XK_KP_Up,				XK_ANY_MOD,						"\033[A",		 0,			-1 },
-	{ XK_KP_Up,				XK_ANY_MOD,						"\033OA",		 0,			+1 },
-	{ XK_KP_Down,			XK_ANY_MOD,						"\033Or",		+1,			 0 },
-	{ XK_KP_Down,			XK_ANY_MOD,						"\033[B",		 0,			-1 },
-	{ XK_KP_Down,			XK_ANY_MOD,						"\033OB",		 0,			+1 },
-	{ XK_KP_Left,			XK_ANY_MOD,						"\033Ot",		+1,			 0 },
-	{ XK_KP_Left,			XK_ANY_MOD,						"\033[D",		 0,			-1 },
-	{ XK_KP_Left,			XK_ANY_MOD,						"\033OD",		 0,			+1 },
-	{ XK_KP_Right,			XK_ANY_MOD,						"\033Ov",		+1,			 0 },
-	{ XK_KP_Right,			XK_ANY_MOD,						"\033[C",		 0,			-1 },
-	{ XK_KP_Right,			XK_ANY_MOD,						"\033OC",		 0,			+1 },
-	{ XK_KP_Prior,			ShiftMask,						"\033[5;2~",	 0,			 0 },
-	{ XK_KP_Prior,			XK_ANY_MOD,						"\033[5~",		 0,			 0 },
-	{ XK_KP_Begin,			XK_ANY_MOD,						"\033[E",		 0,			 0 },
-	{ XK_KP_End,			ControlMask,					"\033[J",		-1,			 0 },
-	{ XK_KP_End,			ControlMask,					"\033[1;5F",	+1,			 0 },
-	{ XK_KP_End,			ShiftMask,						"\033[K",		-1,			 0 },
-	{ XK_KP_End,			ShiftMask,						"\033[1;2F",	+1,			 0 },
-	{ XK_KP_End,			XK_ANY_MOD,						"\033[4~",		 0,			 0 },
-	{ XK_KP_Next,			ShiftMask,						"\033[6;2~",	 0,			 0 },
-	{ XK_KP_Next,			XK_ANY_MOD,						"\033[6~",		 0,			 0 },
-	{ XK_KP_Insert,			ShiftMask,						"\033[2;2~",	+1,			 0 },
-	{ XK_KP_Insert,			ShiftMask,						"\033[4l",		-1,			 0 },
-	{ XK_KP_Insert,			ControlMask,					"\033[L",		-1,			 0 },
-	{ XK_KP_Insert,			ControlMask,					"\033[2;5~",	+1,			 0 },
-	{ XK_KP_Insert,			XK_ANY_MOD,						"\033[4h",		-1,			 0 },
-	{ XK_KP_Insert,			XK_ANY_MOD,						"\033[2~",		+1,			 0 },
-	{ XK_KP_Delete,			ControlMask,					"\033[M",		-1,			 0 },
-	{ XK_KP_Delete,			ControlMask,					"\033[3;5~",	+1,			 0 },
-	{ XK_KP_Delete,			ShiftMask,						"\033[2K",		-1,			 0 },
-	{ XK_KP_Delete,			ShiftMask,						"\033[3;2~",	+1,			 0 },
-	{ XK_KP_Delete,			XK_ANY_MOD,						"\033[P",		-1,			 0 },
-	{ XK_KP_Delete,			XK_ANY_MOD,						"\033[3~",		+1,			 0 },
-	{ XK_KP_Multiply,		XK_ANY_MOD,						"\033Oj",		+2,			 0 },
-	{ XK_KP_Add,			XK_ANY_MOD,						"\033Ok",		+2,			 0 },
-	{ XK_KP_Enter,			XK_ANY_MOD,						"\033OM",		+2,			 0 },
-	{ XK_KP_Enter,			XK_ANY_MOD,						"\r",			-1,			 0 },
-	{ XK_KP_Subtract,		XK_ANY_MOD,						"\033Om",		+2,			 0 },
-	{ XK_KP_Decimal,		XK_ANY_MOD,						"\033On",		+2,			 0 },
-	{ XK_KP_Divide,			XK_ANY_MOD,						"\033Oo",		+2,			 0 },
-	{ XK_KP_0,				XK_ANY_MOD,						"\033Op",		+2,			 0 },
-	{ XK_KP_1,				XK_ANY_MOD,						"\033Oq",		+2,			 0 },
-	{ XK_KP_2,				XK_ANY_MOD,						"\033Or",		+2,			 0 },
-	{ XK_KP_3,				XK_ANY_MOD,						"\033Os",		+2,			 0 },
-	{ XK_KP_4,				XK_ANY_MOD,						"\033Ot",		+2,			 0 },
-	{ XK_KP_5,				XK_ANY_MOD,						"\033Ou",		+2,			 0 },
-	{ XK_KP_6,				XK_ANY_MOD,						"\033Ov",		+2,			 0 },
-	{ XK_KP_7,				XK_ANY_MOD,						"\033Ow",		+2,			 0 },
-	{ XK_KP_8,				XK_ANY_MOD,						"\033Ox",		+2,			 0 },
-	{ XK_KP_9,				XK_ANY_MOD,						"\033Oy",		+2,			 0 },
-	{ XK_Up,				ShiftMask,						"\033[1;2A",	 0,			 0 },
-	{ XK_Up,				Mod1Mask,						"\033[1;3A",	 0,			 0 },
-	{ XK_Up,				ShiftMask|Mod1Mask,				"\033[1;4A",	 0,			 0 },
-	{ XK_Up,				ControlMask,					"\033[1;5A",	 0,			 0 },
-	{ XK_Up,				ShiftMask|ControlMask,			"\033[1;6A",	 0,			 0 },
-	{ XK_Up,				ControlMask|Mod1Mask,			"\033[1;7A",	 0,			 0 },
-	{ XK_Up,				ShiftMask|ControlMask|Mod1Mask,	"\033[1;8A",	 0,			 0 },
-	{ XK_Up,				XK_ANY_MOD,						"\033[A",		 0,			-1 },
-	{ XK_Up,				XK_ANY_MOD,						"\033OA",		 0,			+1 },
-	{ XK_Down,				ShiftMask,						"\033[1;2B",	 0,			 0 },
-	{ XK_Down,				Mod1Mask,						"\033[1;3B",	 0,			 0 },
-	{ XK_Down,				ShiftMask|Mod1Mask,				"\033[1;4B",	 0,			 0 },
-	{ XK_Down,				ControlMask,					"\033[1;5B",	 0,			 0 },
-	{ XK_Down,				ShiftMask|ControlMask,			"\033[1;6B",	 0,			 0 },
-	{ XK_Down,				ControlMask|Mod1Mask,			"\033[1;7B",	 0,			 0 },
-	{ XK_Down,				ShiftMask|ControlMask|Mod1Mask,	"\033[1;8B",	 0,			 0 },
-	{ XK_Down,				XK_ANY_MOD,						"\033[B",		 0,			-1 },
-	{ XK_Down,				XK_ANY_MOD,						"\033OB",		 0,			+1 },
-	{ XK_Left,				ShiftMask,						"\033[1;2D",	 0,			 0 },
-	{ XK_Left,				Mod1Mask,						"\033[1;3D",	 0,			 0 },
-	{ XK_Left,				ShiftMask|Mod1Mask,				"\033[1;4D",	 0,			 0 },
-	{ XK_Left,				ControlMask,					"\033[1;5D",	 0,			 0 },
-	{ XK_Left,				ShiftMask|ControlMask,			"\033[1;6D",	 0,			 0 },
-	{ XK_Left,				ControlMask|Mod1Mask,			"\033[1;7D",	 0,			 0 },
-	{ XK_Left,				ShiftMask|ControlMask|Mod1Mask,	"\033[1;8D",	 0,			 0 },
-	{ XK_Left,				XK_ANY_MOD,						"\033[D",		 0,			-1 },
-	{ XK_Left,				XK_ANY_MOD,						"\033OD",		 0,			+1 },
-	{ XK_Right,				ShiftMask,						"\033[1;2C",	 0,			 0 },
-	{ XK_Right,				Mod1Mask,						"\033[1;3C",	 0,			 0 },
-	{ XK_Right,				ShiftMask|Mod1Mask,				"\033[1;4C",	 0,			 0 },
-	{ XK_Right,				ControlMask,					"\033[1;5C",	 0,			 0 },
-	{ XK_Right,				ShiftMask|ControlMask,			"\033[1;6C",	 0,			 0 },
-	{ XK_Right,				ControlMask|Mod1Mask,			"\033[1;7C",	 0,			 0 },
-	{ XK_Right,				ShiftMask|ControlMask|Mod1Mask,	"\033[1;8C",	 0,			 0 },
-	{ XK_Right,				XK_ANY_MOD,						"\033[C",		 0,			-1 },
-	{ XK_Right,				XK_ANY_MOD,						"\033OC",		 0,			+1 },
-	{ XK_ISO_Left_Tab,		ShiftMask,						"\033[Z",		 0,			 0 },
-	{ XK_Return,			Mod1Mask,						"\033\r",		 0,			 0 },
-	{ XK_Return,			XK_ANY_MOD,						"\r",			 0,			 0 },
-	{ XK_Insert,			ShiftMask,						"\033[4l",		-1,			 0 },
-	{ XK_Insert,			ShiftMask,						"\033[2;2~",	+1,			 0 },
-	{ XK_Insert,			ControlMask,					"\033[L",		-1,			 0 },
-	{ XK_Insert,			ControlMask,					"\033[2;5~",	+1,			 0 },
-	{ XK_Insert,			XK_ANY_MOD,						"\033[4h",		-1,			 0 },
-	{ XK_Insert,			XK_ANY_MOD,						"\033[2~",		+1,			 0 },
-	{ XK_Delete,			ControlMask,					"\033[M",		-1,			 0 },
-	{ XK_Delete,			ControlMask,					"\033[3;5~",	+1,			 0 },
-	{ XK_Delete,			ShiftMask,						"\033[2K",		-1,			 0 },
-	{ XK_Delete,			ShiftMask,						"\033[3;2~",	+1,			 0 },
-	{ XK_Delete,			XK_ANY_MOD,						"\033[P",		-1,			 0 },
-	{ XK_Delete,			XK_ANY_MOD,						"\033[3~",		+1,			 0 },
-	{ XK_BackSpace,			XK_NO_MOD,						"\177",			 0,			 0 },
-	{ XK_BackSpace,			Mod1Mask,						"\033\177",		 0,			 0 },
-	{ XK_Home,				ShiftMask,						"\033[2J",		 0,			-1 },
-	{ XK_Home,				ShiftMask,						"\033[1;2H",	 0,			+1 },
-	{ XK_Home,				XK_ANY_MOD,						"\033[H",		 0,			-1 },
-	{ XK_Home,				XK_ANY_MOD,						"\033[1~",		 0,			+1 },
-	{ XK_End,				ControlMask,					"\033[J",		-1,			 0 },
-	{ XK_End,				ControlMask,					"\033[1;5F",	+1,			 0 },
-	{ XK_End,				ShiftMask,						"\033[K",		-1,			 0 },
-	{ XK_End,				ShiftMask,						"\033[1;2F",	+1,			 0 },
-	{ XK_End,				XK_ANY_MOD,						"\033[4~",		 0,			 0 },
-	{ XK_Prior,				ControlMask,					"\033[5;5~",	 0,			 0 },
-	{ XK_Prior,				ShiftMask,						"\033[5;2~",	 0,			 0 },
-	{ XK_Prior,				XK_ANY_MOD,						"\033[5~",		 0,			 0 },
-	{ XK_Next,				ControlMask,					"\033[6;5~",	 0,			 0 },
-	{ XK_Next,				ShiftMask,						"\033[6;2~",	 0,			 0 },
-	{ XK_Next,				XK_ANY_MOD,						"\033[6~",		 0,			 0 },
-	{ XK_F1,				XK_NO_MOD,						"\033OP"	,	 0,			 0 },
-	{ XK_F1,	/* F13 */	ShiftMask,						"\033[1;2P",	 0,			 0 },
-	{ XK_F1,	/* F25 */	ControlMask,					"\033[1;5P",	 0,			 0 },
-	{ XK_F1,	/* F37 */	Mod4Mask,						"\033[1;6P",	 0,			 0 },
-	{ XK_F1,	/* F49 */	Mod1Mask,						"\033[1;3P",	 0,			 0 },
-	{ XK_F1,	/* F61 */	Mod3Mask,						"\033[1;4P",	 0,			 0 },
-	{ XK_F2,				XK_NO_MOD,						"\033OQ"	,	 0,			 0 },
-	{ XK_F2,	/* F14 */	ShiftMask,						"\033[1;2Q",	 0,			 0 },
-	{ XK_F2,	/* F26 */	ControlMask,					"\033[1;5Q",	 0,			 0 },
-	{ XK_F2,	/* F38 */	Mod4Mask,						"\033[1;6Q",	 0,			 0 },
-	{ XK_F2,	/* F50 */	Mod1Mask,						"\033[1;3Q",	 0,			 0 },
-	{ XK_F2,	/* F62 */	Mod3Mask,						"\033[1;4Q",	 0,			 0 },
-	{ XK_F3,				XK_NO_MOD,						"\033OR"	,	 0,			 0 },
-	{ XK_F3,	/* F15 */	ShiftMask,						"\033[1;2R",	 0,			 0 },
-	{ XK_F3,	/* F27 */	ControlMask,					"\033[1;5R",	 0,			 0 },
-	{ XK_F3,	/* F39 */	Mod4Mask,						"\033[1;6R",	 0,			 0 },
-	{ XK_F3,	/* F51 */	Mod1Mask,						"\033[1;3R",	 0,			 0 },
-	{ XK_F3,	/* F63 */	Mod3Mask,						"\033[1;4R",	 0,			 0 },
-	{ XK_F4,				XK_NO_MOD,						"\033OS"	,	 0,			 0 },
-	{ XK_F4,	/* F16 */	ShiftMask,						"\033[1;2S",	 0,			 0 },
-	{ XK_F4,	/* F28 */	ControlMask,					"\033[1;5S",	 0,			 0 },
-	{ XK_F4,	/* F40 */	Mod4Mask,						"\033[1;6S",	 0,			 0 },
-	{ XK_F4,	/* F52 */	Mod1Mask,						"\033[1;3S",	 0,			 0 },
-	{ XK_F5,				XK_NO_MOD,						"\033[15~",		 0,			 0 },
-	{ XK_F5,	/* F17 */	ShiftMask,						"\033[15;2~",	 0,			 0 },
-	{ XK_F5,	/* F29 */	ControlMask,					"\033[15;5~",	 0,			 0 },
-	{ XK_F5,	/* F41 */	Mod4Mask,						"\033[15;6~",	 0,			 0 },
-	{ XK_F5,	/* F53 */	Mod1Mask,						"\033[15;3~",	 0,			 0 },
-	{ XK_F6,				XK_NO_MOD,						"\033[17~",		 0,			 0 },
-	{ XK_F6,	/* F18 */	ShiftMask,						"\033[17;2~",	 0,			 0 },
-	{ XK_F6,	/* F30 */	ControlMask,					"\033[17;5~",	 0,			 0 },
-	{ XK_F6,	/* F42 */	Mod4Mask,						"\033[17;6~",	 0,			 0 },
-	{ XK_F6,	/* F54 */	Mod1Mask,						"\033[17;3~",	 0,			 0 },
-	{ XK_F7,				XK_NO_MOD,						"\033[18~",		 0,			 0 },
-	{ XK_F7,	/* F19 */	ShiftMask,						"\033[18;2~",	 0,			 0 },
-	{ XK_F7,	/* F31 */	ControlMask,					"\033[18;5~",	 0,			 0 },
-	{ XK_F7,	/* F43 */	Mod4Mask,						"\033[18;6~",	 0,			 0 },
-	{ XK_F7,	/* F55 */	Mod1Mask,						"\033[18;3~",	 0,			 0 },
-	{ XK_F8,				XK_NO_MOD,						"\033[19~",		 0,			 0 },
-	{ XK_F8,	/* F20 */	ShiftMask,						"\033[19;2~",	 0,			 0 },
-	{ XK_F8,	/* F32 */	ControlMask,					"\033[19;5~",	 0,			 0 },
-	{ XK_F8,	/* F44 */	Mod4Mask,						"\033[19;6~",	 0,			 0 },
-	{ XK_F8,	/* F56 */	Mod1Mask,						"\033[19;3~",	 0,			 0 },
-	{ XK_F9,				XK_NO_MOD,						"\033[20~",		 0,			 0 },
-	{ XK_F9,	/* F21 */	ShiftMask,						"\033[20;2~",	 0,			 0 },
-	{ XK_F9,	/* F33 */	ControlMask,					"\033[20;5~",	 0,			 0 },
-	{ XK_F9,	/* F45 */	Mod4Mask,						"\033[20;6~",	 0,			 0 },
-	{ XK_F9,	/* F57 */	Mod1Mask,						"\033[20;3~",	 0,			 0 },
-	{ XK_F10,				XK_NO_MOD,						"\033[21~",		 0,			 0 },
-	{ XK_F10,	/* F22 */	ShiftMask,						"\033[21;2~",	 0,			 0 },
-	{ XK_F10,	/* F34 */	ControlMask,					"\033[21;5~",	 0,			 0 },
-	{ XK_F10,	/* F46 */	Mod4Mask,						"\033[21;6~",	 0,			 0 },
-	{ XK_F10,	/* F58 */	Mod1Mask,						"\033[21;3~",	 0,			 0 },
-	{ XK_F11,				XK_NO_MOD,						"\033[23~",		 0,			 0 },
-	{ XK_F11,	/* F23 */	ShiftMask,						"\033[23;2~",	 0,			 0 },
-	{ XK_F11,	/* F35 */	ControlMask,					"\033[23;5~",	 0,			 0 },
-	{ XK_F11,	/* F47 */	Mod4Mask,						"\033[23;6~",	 0,			 0 },
-	{ XK_F11,	/* F59 */	Mod1Mask,						"\033[23;3~",	 0,			 0 },
-	{ XK_F12,				XK_NO_MOD,						"\033[24~",		 0,			 0 },
-	{ XK_F12,	/* F24 */	ShiftMask,						"\033[24;2~",	 0,			 0 },
-	{ XK_F12,	/* F36 */	ControlMask,					"\033[24;5~",	 0,			 0 },
-	{ XK_F12,	/* F48 */	Mod4Mask,						"\033[24;6~",	 0,			 0 },
-	{ XK_F12,	/* F60 */	Mod1Mask,						"\033[24;3~",	 0,			 0 },
-	{ XK_F13,				XK_NO_MOD,						"\033[1;2P",	 0,			 0 },
-	{ XK_F14,				XK_NO_MOD,						"\033[1;2Q",	 0,			 0 },
-	{ XK_F15,				XK_NO_MOD,						"\033[1;2R",	 0,			 0 },
-	{ XK_F16,				XK_NO_MOD,						"\033[1;2S",	 0,			 0 },
-	{ XK_F17,				XK_NO_MOD,						"\033[15;2~",	 0,			 0 },
-	{ XK_F18,				XK_NO_MOD,						"\033[17;2~",	 0,			 0 },
-	{ XK_F19,				XK_NO_MOD,						"\033[18;2~",	 0,			 0 },
-	{ XK_F20,				XK_NO_MOD,						"\033[19;2~",	 0,			 0 },
-	{ XK_F21,				XK_NO_MOD,						"\033[20;2~",	 0,			 0 },
-	{ XK_F22,				XK_NO_MOD,						"\033[21;2~",	 0,			 0 },
-	{ XK_F23,				XK_NO_MOD,						"\033[23;2~",	 0,			 0 },
-	{ XK_F24,				XK_NO_MOD,						"\033[24;2~",	 0,			 0 },
-	{ XK_F25,				XK_NO_MOD,						"\033[1;5P",	 0,			 0 },
-	{ XK_F26,				XK_NO_MOD,						"\033[1;5Q",	 0,			 0 },
-	{ XK_F27,				XK_NO_MOD,						"\033[1;5R",	 0,			 0 },
-	{ XK_F28,				XK_NO_MOD,						"\033[1;5S",	 0,			 0 },
-	{ XK_F29,				XK_NO_MOD,						"\033[15;5~",	 0,			 0 },
-	{ XK_F30,				XK_NO_MOD,						"\033[17;5~",	 0,			 0 },
-	{ XK_F31,				XK_NO_MOD,						"\033[18;5~",	 0,			 0 },
-	{ XK_F32,				XK_NO_MOD,						"\033[19;5~",	 0,			 0 },
-	{ XK_F33,				XK_NO_MOD,						"\033[20;5~",	 0,			 0 },
-	{ XK_F34,				XK_NO_MOD,						"\033[21;5~",	 0,			 0 },
-	{ XK_F35,				XK_NO_MOD,						"\033[23;5~",	 0,			 0 },
+static Key key[] = {
+	/* keysym           mask            string      appkey appcursor */
+	{ XK_KP_Home,       ShiftMask,      "\033[2J",       0,   -1},
+	{ XK_KP_Home,       ShiftMask,      "\033[1;2H",     0,   +1},
+	{ XK_KP_Home,       XK_ANY_MOD,     "\033[H",        0,   -1},
+	{ XK_KP_Home,       XK_ANY_MOD,     "\033[1~",       0,   +1},
+	{ XK_KP_Up,         XK_ANY_MOD,     "\033Ox",       +1,    0},
+	{ XK_KP_Up,         XK_ANY_MOD,     "\033[A",        0,   -1},
+	{ XK_KP_Up,         XK_ANY_MOD,     "\033OA",        0,   +1},
+	{ XK_KP_Down,       XK_ANY_MOD,     "\033Or",       +1,    0},
+	{ XK_KP_Down,       XK_ANY_MOD,     "\033[B",        0,   -1},
+	{ XK_KP_Down,       XK_ANY_MOD,     "\033OB",        0,   +1},
+	{ XK_KP_Left,       XK_ANY_MOD,     "\033Ot",       +1,    0},
+	{ XK_KP_Left,       XK_ANY_MOD,     "\033[D",        0,   -1},
+	{ XK_KP_Left,       XK_ANY_MOD,     "\033OD",        0,   +1},
+	{ XK_KP_Right,      XK_ANY_MOD,     "\033Ov",       +1,    0},
+	{ XK_KP_Right,      XK_ANY_MOD,     "\033[C",        0,   -1},
+	{ XK_KP_Right,      XK_ANY_MOD,     "\033OC",        0,   +1},
+	{ XK_KP_Prior,      ShiftMask,      "\033[5;2~",     0,    0},
+	{ XK_KP_Prior,      XK_ANY_MOD,     "\033[5~",       0,    0},
+	{ XK_KP_Begin,      XK_ANY_MOD,     "\033[E",        0,    0},
+	{ XK_KP_End,        ControlMask,    "\033[J",       -1,    0},
+	{ XK_KP_End,        ControlMask,    "\033[1;5F",    +1,    0},
+	{ XK_KP_End,        ShiftMask,      "\033[K",       -1,    0},
+	{ XK_KP_End,        ShiftMask,      "\033[1;2F",    +1,    0},
+	{ XK_KP_End,        XK_ANY_MOD,     "\033[4~",       0,    0},
+	{ XK_KP_Next,       ShiftMask,      "\033[6;2~",     0,    0},
+	{ XK_KP_Next,       XK_ANY_MOD,     "\033[6~",       0,    0},
+	{ XK_KP_Insert,     ShiftMask,      "\033[2;2~",    +1,    0},
+	{ XK_KP_Insert,     ShiftMask,      "\033[4l",      -1,    0},
+	{ XK_KP_Insert,     ControlMask,    "\033[L",       -1,    0},
+	{ XK_KP_Insert,     ControlMask,    "\033[2;5~",    +1,    0},
+	{ XK_KP_Insert,     XK_ANY_MOD,     "\033[4h",      -1,    0},
+	{ XK_KP_Insert,     XK_ANY_MOD,     "\033[2~",      +1,    0},
+	{ XK_KP_Delete,     ControlMask,    "\033[M",       -1,    0},
+	{ XK_KP_Delete,     ControlMask,    "\033[3;5~",    +1,    0},
+	{ XK_KP_Delete,     ShiftMask,      "\033[2K",      -1,    0},
+	{ XK_KP_Delete,     ShiftMask,      "\033[3;2~",    +1,    0},
+	{ XK_KP_Delete,     XK_ANY_MOD,     "\033[P",       -1,    0},
+	{ XK_KP_Delete,     XK_ANY_MOD,     "\033[3~",      +1,    0},
+	{ XK_KP_Multiply,   XK_ANY_MOD,     "\033Oj",       +2,    0},
+	{ XK_KP_Add,        XK_ANY_MOD,     "\033Ok",       +2,    0},
+	{ XK_KP_Enter,      XK_ANY_MOD,     "\033OM",       +2,    0},
+	{ XK_KP_Enter,      XK_ANY_MOD,     "\r",           -1,    0},
+	{ XK_KP_Subtract,   XK_ANY_MOD,     "\033Om",       +2,    0},
+	{ XK_KP_Decimal,    XK_ANY_MOD,     "\033On",       +2,    0},
+	{ XK_KP_Divide,     XK_ANY_MOD,     "\033Oo",       +2,    0},
+	{ XK_KP_0,          XK_ANY_MOD,     "\033Op",       +2,    0},
+	{ XK_KP_1,          XK_ANY_MOD,     "\033Oq",       +2,    0},
+	{ XK_KP_2,          XK_ANY_MOD,     "\033Or",       +2,    0},
+	{ XK_KP_3,          XK_ANY_MOD,     "\033Os",       +2,    0},
+	{ XK_KP_4,          XK_ANY_MOD,     "\033Ot",       +2,    0},
+	{ XK_KP_5,          XK_ANY_MOD,     "\033Ou",       +2,    0},
+	{ XK_KP_6,          XK_ANY_MOD,     "\033Ov",       +2,    0},
+	{ XK_KP_7,          XK_ANY_MOD,     "\033Ow",       +2,    0},
+	{ XK_KP_8,          XK_ANY_MOD,     "\033Ox",       +2,    0},
+	{ XK_KP_9,          XK_ANY_MOD,     "\033Oy",       +2,    0},
+	{ XK_Up,            ShiftMask,      "\033[1;2A",     0,    0},
+	{ XK_Up,            Mod1Mask,       "\033[1;3A",     0,    0},
+	{ XK_Up,         ShiftMask|Mod1Mask,"\033[1;4A",     0,    0},
+	{ XK_Up,            ControlMask,    "\033[1;5A",     0,    0},
+	{ XK_Up,      ShiftMask|ControlMask,"\033[1;6A",     0,    0},
+	{ XK_Up,       ControlMask|Mod1Mask,"\033[1;7A",     0,    0},
+	{ XK_Up,ShiftMask|ControlMask|Mod1Mask,"\033[1;8A",  0,    0},
+	{ XK_Up,            XK_ANY_MOD,     "\033[A",        0,   -1},
+	{ XK_Up,            XK_ANY_MOD,     "\033OA",        0,   +1},
+	{ XK_Down,          ShiftMask,      "\033[1;2B",     0,    0},
+	{ XK_Down,          Mod1Mask,       "\033[1;3B",     0,    0},
+	{ XK_Down,       ShiftMask|Mod1Mask,"\033[1;4B",     0,    0},
+	{ XK_Down,          ControlMask,    "\033[1;5B",     0,    0},
+	{ XK_Down,    ShiftMask|ControlMask,"\033[1;6B",     0,    0},
+	{ XK_Down,     ControlMask|Mod1Mask,"\033[1;7B",     0,    0},
+	{ XK_Down,ShiftMask|ControlMask|Mod1Mask,"\033[1;8B",0,    0},
+	{ XK_Down,          XK_ANY_MOD,     "\033[B",        0,   -1},
+	{ XK_Down,          XK_ANY_MOD,     "\033OB",        0,   +1},
+	{ XK_Left,          ShiftMask,      "\033[1;2D",     0,    0},
+	{ XK_Left,          Mod1Mask,       "\033[1;3D",     0,    0},
+	{ XK_Left,       ShiftMask|Mod1Mask,"\033[1;4D",     0,    0},
+	{ XK_Left,          ControlMask,    "\033[1;5D",     0,    0},
+	{ XK_Left,    ShiftMask|ControlMask,"\033[1;6D",     0,    0},
+	{ XK_Left,     ControlMask|Mod1Mask,"\033[1;7D",     0,    0},
+	{ XK_Left,ShiftMask|ControlMask|Mod1Mask,"\033[1;8D",0,    0},
+	{ XK_Left,          XK_ANY_MOD,     "\033[D",        0,   -1},
+	{ XK_Left,          XK_ANY_MOD,     "\033OD",        0,   +1},
+	{ XK_Right,         ShiftMask,      "\033[1;2C",     0,    0},
+	{ XK_Right,         Mod1Mask,       "\033[1;3C",     0,    0},
+	{ XK_Right,      ShiftMask|Mod1Mask,"\033[1;4C",     0,    0},
+	{ XK_Right,         ControlMask,    "\033[1;5C",     0,    0},
+	{ XK_Right,   ShiftMask|ControlMask,"\033[1;6C",     0,    0},
+	{ XK_Right,    ControlMask|Mod1Mask,"\033[1;7C",     0,    0},
+	{ XK_Right,ShiftMask|ControlMask|Mod1Mask,"\033[1;8C",0,   0},
+	{ XK_Right,         XK_ANY_MOD,     "\033[C",        0,   -1},
+	{ XK_Right,         XK_ANY_MOD,     "\033OC",        0,   +1},
+	{ XK_ISO_Left_Tab,  ShiftMask,      "\033[Z",        0,    0},
+	{ XK_Return,        Mod1Mask,       "\033\r",        0,    0},
+	{ XK_Return,        XK_ANY_MOD,     "\r",            0,    0},
+	{ XK_Insert,        ShiftMask,      "\033[4l",      -1,    0},
+	{ XK_Insert,        ShiftMask,      "\033[2;2~",    +1,    0},
+	{ XK_Insert,        ControlMask,    "\033[L",       -1,    0},
+	{ XK_Insert,        ControlMask,    "\033[2;5~",    +1,    0},
+	{ XK_Insert,        XK_ANY_MOD,     "\033[4h",      -1,    0},
+	{ XK_Insert,        XK_ANY_MOD,     "\033[2~",      +1,    0},
+	{ XK_Delete,        ControlMask,    "\033[M",       -1,    0},
+	{ XK_Delete,        ControlMask,    "\033[3;5~",    +1,    0},
+	{ XK_Delete,        ShiftMask,      "\033[2K",      -1,    0},
+	{ XK_Delete,        ShiftMask,      "\033[3;2~",    +1,    0},
+	{ XK_Delete,        XK_ANY_MOD,     "\033[P",       -1,    0},
+	{ XK_Delete,        XK_ANY_MOD,     "\033[3~",      +1,    0},
+	{ XK_BackSpace,     XK_NO_MOD,      "\177",          0,    0},
+	{ XK_BackSpace,     Mod1Mask,       "\033\177",      0,    0},
+	{ XK_Home,          ShiftMask,      "\033[2J",       0,   -1},
+	{ XK_Home,          ShiftMask,      "\033[1;2H",     0,   +1},
+	{ XK_Home,          XK_ANY_MOD,     "\033[H",        0,   -1},
+	{ XK_Home,          XK_ANY_MOD,     "\033[1~",       0,   +1},
+	{ XK_End,           ControlMask,    "\033[J",       -1,    0},
+	{ XK_End,           ControlMask,    "\033[1;5F",    +1,    0},
+	{ XK_End,           ShiftMask,      "\033[K",       -1,    0},
+	{ XK_End,           ShiftMask,      "\033[1;2F",    +1,    0},
+	{ XK_End,           XK_ANY_MOD,     "\033[4~",       0,    0},
+	{ XK_Prior,         ControlMask,    "\033[5;5~",     0,    0},
+	{ XK_Prior,         ShiftMask,      "\033[5;2~",     0,    0},
+	{ XK_Prior,         XK_ANY_MOD,     "\033[5~",       0,    0},
+	{ XK_Next,          ControlMask,    "\033[6;5~",     0,    0},
+	{ XK_Next,          ShiftMask,      "\033[6;2~",     0,    0},
+	{ XK_Next,          XK_ANY_MOD,     "\033[6~",       0,    0},
+	{ XK_F1,            XK_NO_MOD,      "\033OP" ,       0,    0},
+	{ XK_F1, /* F13 */  ShiftMask,      "\033[1;2P",     0,    0},
+	{ XK_F1, /* F25 */  ControlMask,    "\033[1;5P",     0,    0},
+	{ XK_F1, /* F37 */  Mod4Mask,       "\033[1;6P",     0,    0},
+	{ XK_F1, /* F49 */  Mod1Mask,       "\033[1;3P",     0,    0},
+	{ XK_F1, /* F61 */  Mod3Mask,       "\033[1;4P",     0,    0},
+	{ XK_F2,            XK_NO_MOD,      "\033OQ" ,       0,    0},
+	{ XK_F2, /* F14 */  ShiftMask,      "\033[1;2Q",     0,    0},
+	{ XK_F2, /* F26 */  ControlMask,    "\033[1;5Q",     0,    0},
+	{ XK_F2, /* F38 */  Mod4Mask,       "\033[1;6Q",     0,    0},
+	{ XK_F2, /* F50 */  Mod1Mask,       "\033[1;3Q",     0,    0},
+	{ XK_F2, /* F62 */  Mod3Mask,       "\033[1;4Q",     0,    0},
+	{ XK_F3,            XK_NO_MOD,      "\033OR" ,       0,    0},
+	{ XK_F3, /* F15 */  ShiftMask,      "\033[1;2R",     0,    0},
+	{ XK_F3, /* F27 */  ControlMask,    "\033[1;5R",     0,    0},
+	{ XK_F3, /* F39 */  Mod4Mask,       "\033[1;6R",     0,    0},
+	{ XK_F3, /* F51 */  Mod1Mask,       "\033[1;3R",     0,    0},
+	{ XK_F3, /* F63 */  Mod3Mask,       "\033[1;4R",     0,    0},
+	{ XK_F4,            XK_NO_MOD,      "\033OS" ,       0,    0},
+	{ XK_F4, /* F16 */  ShiftMask,      "\033[1;2S",     0,    0},
+	{ XK_F4, /* F28 */  ControlMask,    "\033[1;5S",     0,    0},
+	{ XK_F4, /* F40 */  Mod4Mask,       "\033[1;6S",     0,    0},
+	{ XK_F4, /* F52 */  Mod1Mask,       "\033[1;3S",     0,    0},
+	{ XK_F5,            XK_NO_MOD,      "\033[15~",      0,    0},
+	{ XK_F5, /* F17 */  ShiftMask,      "\033[15;2~",    0,    0},
+	{ XK_F5, /* F29 */  ControlMask,    "\033[15;5~",    0,    0},
+	{ XK_F5, /* F41 */  Mod4Mask,       "\033[15;6~",    0,    0},
+	{ XK_F5, /* F53 */  Mod1Mask,       "\033[15;3~",    0,    0},
+	{ XK_F6,            XK_NO_MOD,      "\033[17~",      0,    0},
+	{ XK_F6, /* F18 */  ShiftMask,      "\033[17;2~",    0,    0},
+	{ XK_F6, /* F30 */  ControlMask,    "\033[17;5~",    0,    0},
+	{ XK_F6, /* F42 */  Mod4Mask,       "\033[17;6~",    0,    0},
+	{ XK_F6, /* F54 */  Mod1Mask,       "\033[17;3~",    0,    0},
+	{ XK_F7,            XK_NO_MOD,      "\033[18~",      0,    0},
+	{ XK_F7, /* F19 */  ShiftMask,      "\033[18;2~",    0,    0},
+	{ XK_F7, /* F31 */  ControlMask,    "\033[18;5~",    0,    0},
+	{ XK_F7, /* F43 */  Mod4Mask,       "\033[18;6~",    0,    0},
+	{ XK_F7, /* F55 */  Mod1Mask,       "\033[18;3~",    0,    0},
+	{ XK_F8,            XK_NO_MOD,      "\033[19~",      0,    0},
+	{ XK_F8, /* F20 */  ShiftMask,      "\033[19;2~",    0,    0},
+	{ XK_F8, /* F32 */  ControlMask,    "\033[19;5~",    0,    0},
+	{ XK_F8, /* F44 */  Mod4Mask,       "\033[19;6~",    0,    0},
+	{ XK_F8, /* F56 */  Mod1Mask,       "\033[19;3~",    0,    0},
+	{ XK_F9,            XK_NO_MOD,      "\033[20~",      0,    0},
+	{ XK_F9, /* F21 */  ShiftMask,      "\033[20;2~",    0,    0},
+	{ XK_F9, /* F33 */  ControlMask,    "\033[20;5~",    0,    0},
+	{ XK_F9, /* F45 */  Mod4Mask,       "\033[20;6~",    0,    0},
+	{ XK_F9, /* F57 */  Mod1Mask,       "\033[20;3~",    0,    0},
+	{ XK_F10,           XK_NO_MOD,      "\033[21~",      0,    0},
+	{ XK_F10, /* F22 */ ShiftMask,      "\033[21;2~",    0,    0},
+	{ XK_F10, /* F34 */ ControlMask,    "\033[21;5~",    0,    0},
+	{ XK_F10, /* F46 */ Mod4Mask,       "\033[21;6~",    0,    0},
+	{ XK_F10, /* F58 */ Mod1Mask,       "\033[21;3~",    0,    0},
+	{ XK_F11,           XK_NO_MOD,      "\033[23~",      0,    0},
+	{ XK_F11, /* F23 */ ShiftMask,      "\033[23;2~",    0,    0},
+	{ XK_F11, /* F35 */ ControlMask,    "\033[23;5~",    0,    0},
+	{ XK_F11, /* F47 */ Mod4Mask,       "\033[23;6~",    0,    0},
+	{ XK_F11, /* F59 */ Mod1Mask,       "\033[23;3~",    0,    0},
+	{ XK_F12,           XK_NO_MOD,      "\033[24~",      0,    0},
+	{ XK_F12, /* F24 */ ShiftMask,      "\033[24;2~",    0,    0},
+	{ XK_F12, /* F36 */ ControlMask,    "\033[24;5~",    0,    0},
+	{ XK_F12, /* F48 */ Mod4Mask,       "\033[24;6~",    0,    0},
+	{ XK_F12, /* F60 */ Mod1Mask,       "\033[24;3~",    0,    0},
+	{ XK_F13,           XK_NO_MOD,      "\033[1;2P",     0,    0},
+	{ XK_F14,           XK_NO_MOD,      "\033[1;2Q",     0,    0},
+	{ XK_F15,           XK_NO_MOD,      "\033[1;2R",     0,    0},
+	{ XK_F16,           XK_NO_MOD,      "\033[1;2S",     0,    0},
+	{ XK_F17,           XK_NO_MOD,      "\033[15;2~",    0,    0},
+	{ XK_F18,           XK_NO_MOD,      "\033[17;2~",    0,    0},
+	{ XK_F19,           XK_NO_MOD,      "\033[18;2~",    0,    0},
+	{ XK_F20,           XK_NO_MOD,      "\033[19;2~",    0,    0},
+	{ XK_F21,           XK_NO_MOD,      "\033[20;2~",    0,    0},
+	{ XK_F22,           XK_NO_MOD,      "\033[21;2~",    0,    0},
+	{ XK_F23,           XK_NO_MOD,      "\033[23;2~",    0,    0},
+	{ XK_F24,           XK_NO_MOD,      "\033[24;2~",    0,    0},
+	{ XK_F25,           XK_NO_MOD,      "\033[1;5P",     0,    0},
+	{ XK_F26,           XK_NO_MOD,      "\033[1;5Q",     0,    0},
+	{ XK_F27,           XK_NO_MOD,      "\033[1;5R",     0,    0},
+	{ XK_F28,           XK_NO_MOD,      "\033[1;5S",     0,    0},
+	{ XK_F29,           XK_NO_MOD,      "\033[15;5~",    0,    0},
+	{ XK_F30,           XK_NO_MOD,      "\033[17;5~",    0,    0},
+	{ XK_F31,           XK_NO_MOD,      "\033[18;5~",    0,    0},
+	{ XK_F32,           XK_NO_MOD,      "\033[19;5~",    0,    0},
+	{ XK_F33,           XK_NO_MOD,      "\033[20;5~",    0,    0},
+	{ XK_F34,           XK_NO_MOD,      "\033[21;5~",    0,    0},
+	{ XK_F35,           XK_NO_MOD,      "\033[23;5~",    0,    0},
 };
 
 /*
@@ -494,7 +478,7 @@ Key key[] = {
  * ButtonRelease and MotionNotify.
  * If no match is found, regular selection is used.
  */
-uint selmasks[] = {
+static uint selmasks[] = {
 	[SEL_RECTANGULAR] = Mod1Mask,
 };
 
@@ -502,9 +486,7 @@ uint selmasks[] = {
  * Printable characters in ASCII, used to estimate the advance width
  * of single wide characters.
  */
-char ascii_printable[] =
-" !\"#$%&'()*+,-./0123456789:;<=>?"
-"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
-"`abcdefghijklmnopqrstuvwxyz{|}~";
-
-#endif /* end of include guard: __CONFIG_H__ */
+static char ascii_printable[] =
+	" !\"#$%&'()*+,-./0123456789:;<=>?"
+	"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
+	"`abcdefghijklmnopqrstuvwxyz{|}~";
diff --git a/config.mk b/config.mk
index 047582f..a0ca32f 100644
--- a/config.mk
+++ b/config.mk
@@ -21,7 +21,7 @@ LIBS = -L$(X11LIB) -lm -lrt -lX11 -lutil -lXft \
        `$(PKG_CONFIG) --libs freetype2`
 
 # flags
-CFLAGS	= -std=c99 -Wall -Wextra -Werror -Wno-type-limits -pedantic -march=ivybridge -Os -pipe
+CFLAGS	= -std=c99 -march=ivybridge -Os -pipe
 STCPPFLAGS = -DVERSION=\"$(VERSION)\" -D_XOPEN_SOURCE=600
 STCFLAGS = $(INCS) $(STCPPFLAGS) $(CPPFLAGS) $(CFLAGS)
 STLDFLAGS = $(LIBS) $(LDFLAGS)
diff --git a/st.c b/st.c
index a82bb8a..9e2081f 100644
--- a/st.c
+++ b/st.c
@@ -23,11 +23,11 @@
 #include "win.h"
 
 #if   defined(__linux)
-#include <pty.h>
+ #include <pty.h>
 #elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
-#include <util.h>
+ #include <util.h>
 #elif defined(__FreeBSD__) || defined(__DragonFly__)
-#include <libutil.h>
+ #include <libutil.h>
 #endif
 
 /* Arbitrary sizes */
@@ -40,12 +40,12 @@
 #define HISTSIZE      2000
 
 /* macros */
-#define IS_SET(flag)	((term.mode & (flag)) != 0)
-#define ISCONTROLC0(c)	(BETWEEN(c, 0, 0x1f) || (c) == 0x7f)
-#define ISCONTROLC1(c)	(BETWEEN(c, 0x80, 0x9f))
-#define ISCONTROL(c)	(ISCONTROLC0(c) || ISCONTROLC1(c))
+#define IS_SET(flag)		((term.mode & (flag)) != 0)
+#define ISCONTROLC0(c)		(BETWEEN(c, 0, 0x1f) || (c) == 0x7f)
+#define ISCONTROLC1(c)		(BETWEEN(c, 0x80, 0x9f))
+#define ISCONTROL(c)		(ISCONTROLC0(c) || ISCONTROLC1(c))
 #define ISDELIM(u)		(u && wcschr(worddelimiters, u))
-#define	TLINE(y)		((y) < term.scr ? term.hist[((y) + term.histi - \
+#define TLINE(y)		((y) < term.scr ? term.hist[((y) + term.histi - \
 				term.scr + HISTSIZE + 1) % HISTSIZE] : \
 				term.line[(y) - term.scr])
 
@@ -117,26 +117,26 @@ typedef struct {
 
 /* Internal representation of the screen */
 typedef struct {
-	int row;			 /* nb row */
-	int col;			 /* nb col */
-	Line *line;			 /* screen */
-	Line *alt;			 /* alternate screen */
+	int row;      /* nb row */
+	int col;      /* nb col */
+	Line *line;   /* screen */
+	Line *alt;    /* alternate screen */
 	Line hist[HISTSIZE]; /* history buffer */
-	int histi;			 /* history index */
-	int scr;			 /* scroll back */
-	int *dirty;			 /* dirtyness of lines */
-	TCursor c;			 /* cursor */
-	int ocx;			 /* old cursor col */
-	int ocy;			 /* old cursor row */
-	int top;			 /* top    scroll limit */
-	int bot;			 /* bottom scroll limit */
-	int mode;			 /* terminal mode flags */
-	int esc;			 /* escape state flags */
-	char trantbl[4];	 /* charset table translation */
-	int charset;		 /* current charset */
-	int icharset;		 /* selected charset for sequence */
+	int histi;    /* history index */
+	int scr;      /* scroll back */
+	int *dirty;   /* dirtyness of lines */
+	TCursor c;    /* cursor */
+	int ocx;      /* old cursor col */
+	int ocy;      /* old cursor row */
+	int top;      /* top    scroll limit */
+	int bot;      /* bottom scroll limit */
+	int mode;     /* terminal mode flags */
+	int esc;      /* escape state flags */
+	char trantbl[4]; /* charset table translation */
+	int charset;  /* current charset */
+	int icharset; /* selected charset for sequence */
 	int *tabs;
-	Rune lastc;			 /* last printed char outside of sequence, 0 if control */
+	Rune lastc;   /* last printed char outside of sequence, 0 if control */
 } Term;
 
 /* CSI Escape sequence structs */
@@ -585,7 +585,7 @@ selsnap(int *x, int *y, int direction)
 			}
 		} else if (direction > 0) {
 			for (; *y < term.row-1; *y += direction) {
-				if (!(term.line[*y][term.col-1].mode
+				if (!(TLINE(*y)[term.col-1].mode
 						& ATTR_WRAP)) {
 					break;
 				}
@@ -729,7 +729,6 @@ sigchld(int a)
 	int stat;
 	pid_t p;
 
-	(void)a;
 	if ((p = waitpid(pid, &stat, WNOHANG)) < 0)
 		die("waiting for pid %hd failed: %s\n", pid, strerror(errno));
 
@@ -841,10 +840,8 @@ ttyread(void)
 	switch (ret) {
 	case 0:
 		exit(0);
-		break;
 	case -1:
 		die("couldn't read from shell: %s\n", strerror(errno));
-		break;
 	default:
 		buflen += ret;
 		written = twrite(buf, buflen, 0);
@@ -853,9 +850,7 @@ ttyread(void)
 		if (buflen > 0)
 			memmove(buf, buf + written, buflen);
 		return ret;
-		break;
 	}
-	return ret;
 }
 
 void
@@ -922,7 +917,7 @@ ttywriteraw(const char *s, size_t n)
 			 */
 			if ((r = write(cmdfd, s, (n < lim)? n : lim)) < 0)
 				goto write_error;
-			if (r < (long)n) {
+			if (r < n) {
 				/*
 				 * We weren't able to write out everything.
 				 * This means the buffer is getting full
@@ -1040,7 +1035,7 @@ treset(void)
 	}, .x = 0, .y = 0, .state = CURSOR_DEFAULT};
 
 	memset(term.tabs, 0, term.col * sizeof(*term.tabs));
-	for (i = tabspaces; (int)i < term.col; i += tabspaces)
+	for (i = tabspaces; i < term.col; i += tabspaces)
 		term.tabs[i] = 1;
 	term.top = 0;
 	term.bot = term.row - 1;
@@ -2047,7 +2042,6 @@ strreset(void)
 void
 sendbreak(const Arg *arg)
 {
-	(void)arg;
 	if (tcsendbreak(cmdfd, 0))
 		perror("Error sending break");
 }
@@ -2065,21 +2059,18 @@ tprinter(char *s, size_t len)
 void
 toggleprinter(const Arg *arg)
 {
-	(void)arg;
 	term.mode ^= MODE_PRINT;
 }
 
 void
 printscreen(const Arg *arg)
 {
-	(void)arg;
 	tdump();
 }
 
 void
 printsel(const Arg *arg)
 {
-	(void)arg;
 	tdumpsel();
 }
 
@@ -2122,19 +2113,17 @@ void
 tputtab(int n)
 {
 	uint x = term.c.x;
-	int tmp;
 
 	if (n > 0) {
-		while ((int)x < term.col && n--)
-			for (++x; (int)x < term.col && !term.tabs[x]; ++x)
+		while (x < term.col && n--)
+			for (++x; x < term.col && !term.tabs[x]; ++x)
 				/* nothing */ ;
 	} else if (n < 0) {
 		while (x > 0 && n++)
 			for (--x; x > 0 && !term.tabs[x]; --x)
 				/* nothing */ ;
 	}
-	tmp = (int)x;
-	term.c.x = LIMIT(tmp, 0, term.col-1);
+	term.c.x = LIMIT(x, 0, term.col-1);
 }
 
 void
@@ -2384,7 +2373,7 @@ tputc(Rune u)
 {
 	char c[UTF_SIZ];
 	int control;
-	int width = 0, len;
+	int width, len;
 	Glyph *gp;
 
 	control = ISCONTROL(u);
@@ -2696,21 +2685,19 @@ redraw(void)
 	draw();
 }
 
-void
-set_notifmode(int type, KeySym ksym)
-{
+void set_notifmode(int type, KeySym ksym) {
 	static char *lib[] = { " MOVE ", " SEL  "};
 	static Glyph *g, *deb, *fin;
 	static int col, bot;
 
-	if ( (long)ksym == -1 ) {
+	if ( ksym == -1 ) {
 		free(g);
 		col = term.col, bot = term.bot;
 		g = xmalloc(col * sizeof(Glyph));
 		memcpy(g, term.line[bot], col * sizeof(Glyph));
 
 	}
-	else if ( (long)ksym == -2 )
+	else if ( ksym == -2 )
 		memcpy(term.line[bot], g, col * sizeof(Glyph));
 
 	if ( type < 2 ) {
@@ -2734,9 +2721,7 @@ set_notifmode(int type, KeySym ksym)
 	drawregion(0, bot, col, bot + 1);
 }
 
-void
-select_or_drawcursor(int selectsearch_mode, int type)
-{
+void select_or_drawcursor(int selectsearch_mode, int type) {
 	int done = 0;
 
 	if ( selectsearch_mode & 1 ) {
@@ -2745,12 +2730,10 @@ select_or_drawcursor(int selectsearch_mode, int type)
 	}
 	else
 		xdrawcursor(term.c.x, term.c.y, term.line[term.c.y][term.c.x],
-				term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
+			    term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
 }
 
-void
-search(int selectsearch_mode, Rune *target, int ptarget, int incr, int type, TCursor *cu)
-{
+void search(int selectsearch_mode, Rune *target, int ptarget, int incr, int type, TCursor *cu) {
 	Rune *r;
 	int i, bound = (term.col * cu->y + cu->x) * (incr > 0) + incr;
 
@@ -2772,9 +2755,7 @@ search(int selectsearch_mode, Rune *target, int ptarget, int incr, int type, TCu
 	}
 }
 
-int
-trt_kbdselect(KeySym ksym, char *buf, int len)
-{
+int trt_kbdselect(KeySym ksym, char *buf, int len) {
 	static TCursor cu;
 	static Rune target[64];
 	static int type = 1, ptarget, in_use;
@@ -2814,112 +2795,108 @@ trt_kbdselect(KeySym ksym, char *buf, int len)
 	}
 
 	switch ( ksym ) {
-		case -1 :
-			in_use = 1;
-			cu.x = term.c.x, cu.y = term.c.y;
-			set_notifmode(0, ksym);
-			return MODE_KBDSELECT;
-		case XK_s :
-			if ( selectsearch_mode & 1 )
-				selclear();
-			else
-				selstart(term.c.x, term.c.y, 0);
-			set_notifmode(selectsearch_mode ^= 1, ksym);
-			break;
-		case XK_t :
-			selextend(term.c.x, term.c.y, type ^= 3, i = 0);  /* 2 fois */
-			selextend(term.c.x, term.c.y, type, i = 0);
-			break;
-		case XK_slash :
-		case XK_KP_Divide :
-		case XK_question :
-			ksym &= XK_question;                /* Divide to slash */
-			sens = (ksym == XK_slash) ? -1 : 1;
-			ptarget = 0;
-			set_notifmode(15, ksym);
-			selectsearch_mode ^= 2;
-			break;
-		case XK_Escape :
-			if ( !in_use )  break;
+	case -1 :
+		in_use = 1;
+		cu.x = term.c.x, cu.y = term.c.y;
+		set_notifmode(0, ksym);
+		return MODE_KBDSELECT;
+	case XK_s :
+		if ( selectsearch_mode & 1 )
 			selclear();
+		else
+			selstart(term.c.x, term.c.y, 0);
+		set_notifmode(selectsearch_mode ^= 1, ksym);
+		break;
+	case XK_t :
+		selextend(term.c.x, term.c.y, type ^= 3, i = 0);  /* 2 fois */
+		selextend(term.c.x, term.c.y, type, i = 0);
+		break;
+	case XK_slash :
+	case XK_KP_Divide :
+	case XK_question :
+		ksym &= XK_question;                /* Divide to slash */
+		sens = (ksym == XK_slash) ? -1 : 1;
+		ptarget = 0;
+		set_notifmode(15, ksym);
+		selectsearch_mode ^= 2;
+		break;
+	case XK_Escape :
+		if ( !in_use )  break;
+		selclear();
+	case XK_Return :
+		set_notifmode(4, ksym);
+		term.c.x = cu.x, term.c.y = cu.y;
+		select_or_drawcursor(selectsearch_mode = 0, type);
+		in_use = quant = 0;
+		return MODE_KBDSELECT;
+	case XK_n :
+	case XK_N :
+		if ( ptarget )
+			search(selectsearch_mode, &target[0], ptarget, (ksym == XK_n) ? -1 : 1, type, &cu);
+		break;
+	case XK_BackSpace :
+		term.c.x = 0;
+		select_or_drawcursor(selectsearch_mode, type);
+		break;
+	case XK_dollar :
+		term.c.x = term.col - 1;
+		select_or_drawcursor(selectsearch_mode, type);
+		break;
+	case XK_Home :
+		term.c.x = 0, term.c.y = 0;
+		select_or_drawcursor(selectsearch_mode, type);
+		break;
+	case XK_End :
+		term.c.x = cu.x, term.c.y = cu.y;
+		select_or_drawcursor(selectsearch_mode, type);
+		break;
+	case XK_Page_Up :
+	case XK_Page_Down :
+		term.c.y = (ksym == XK_Prior ) ? 0 : cu.y;
+		select_or_drawcursor(selectsearch_mode, type);
+		break;
+	case XK_exclam :
+		term.c.x = term.col >> 1;
+		select_or_drawcursor(selectsearch_mode, type);
+		break;
+	case XK_asterisk :
+	case XK_KP_Multiply :
+		term.c.x = term.col >> 1;
+	case XK_underscore :
+		term.c.y = cu.y >> 1;
+		select_or_drawcursor(selectsearch_mode, type);
+		break;
+	default :
+		if ( ksym >= XK_0 && ksym <= XK_9 ) {               /* 0-9 keyboard */
+			quant = (quant * 10) + (ksym ^ XK_0);
+			return 0;
+		}
+		else if ( ksym >= XK_KP_0 && ksym <= XK_KP_9 ) {    /* 0-9 numpad */
+			quant = (quant * 10) + (ksym ^ XK_KP_0);
+			return 0;
+		}
+		else if ( ksym == XK_k || ksym == XK_h )
+			i = ksym & 1;
+		else if ( ksym == XK_l || ksym == XK_j )
+			i = ((ksym & 6) | 4) >> 1;
+		else if ( (XK_Home & ksym) != XK_Home || (i = (ksym ^ XK_Home) - 1) > 3 )
 			break;
-		case XK_Return :
-			set_notifmode(4, ksym);
-			term.c.x = cu.x, term.c.y = cu.y;
-			select_or_drawcursor(selectsearch_mode = 0, type);
-			in_use = quant = 0;
-			return MODE_KBDSELECT;
-			break;
-		case XK_n :
-			break;
-		case XK_N :
-			if ( ptarget )
-				search(selectsearch_mode, &target[0], ptarget, (ksym == XK_n) ? -1 : 1, type, &cu);
-			break;
-		case XK_BackSpace :
-			term.c.x = 0;
-			select_or_drawcursor(selectsearch_mode, type);
-			break;
-		case XK_dollar :
-			term.c.x = term.col - 1;
-			select_or_drawcursor(selectsearch_mode, type);
-			break;
-		case XK_Home :
-			term.c.x = 0, term.c.y = 0;
-			select_or_drawcursor(selectsearch_mode, type);
-			break;
-		case XK_End :
-			term.c.x = cu.x, term.c.y = cu.y;
-			select_or_drawcursor(selectsearch_mode, type);
-			break;
-		case XK_Page_Up :
-		case XK_Page_Down :
-			term.c.y = (ksym == XK_Prior ) ? 0 : cu.y;
-			select_or_drawcursor(selectsearch_mode, type);
-			break;
-		case XK_exclam :
-			term.c.x = term.col >> 1;
-			select_or_drawcursor(selectsearch_mode, type);
-			break;
-		case XK_asterisk :
-		case XK_KP_Multiply :
-			term.c.x = term.col >> 1;
-			break;
-		case XK_underscore :
-			term.c.y = cu.y >> 1;
-			select_or_drawcursor(selectsearch_mode, type);
-			break;
-		default :
-			if ( ksym >= XK_0 && ksym <= XK_9 ) {               /* 0-9 keyboard */
-				quant = (quant * 10) + (ksym ^ XK_0);
-				return 0;
-			}
-			else if ( ksym >= XK_KP_0 && ksym <= XK_KP_9 ) {    /* 0-9 numpad */
-				quant = (quant * 10) + (ksym ^ XK_KP_0);
-				return 0;
-			}
-			else if ( ksym == XK_k || ksym == XK_h )
-				i = ksym & 1;
-			else if ( ksym == XK_l || ksym == XK_j )
-				i = ((ksym & 6) | 4) >> 1;
-			else if ( (XK_Home & ksym) != XK_Home || (i = (ksym ^ XK_Home) - 1) > 3 )
-				break;
 
-			xy = (i & 1) ? &term.c.y : &term.c.x;
-			sens = (i & 2) ? 1 : -1;
-			bound = (i >> 1 ^ 1) ? 0 : (i ^ 3) ? term.col - 1 : term.bot;
+		xy = (i & 1) ? &term.c.y : &term.c.x;
+		sens = (i & 2) ? 1 : -1;
+		bound = (i >> 1 ^ 1) ? 0 : (i ^ 3) ? term.col - 1 : term.bot;
 
-			if ( quant == 0 )
-				quant++;
+		if ( quant == 0 )
+			quant++;
 
-			if ( *xy == bound && ((sens < 0 && bound == 0) || (sens > 0 && bound > 0)) )
-				break;
+		if ( *xy == bound && ((sens < 0 && bound == 0) || (sens > 0 && bound > 0)) )
+			break;
 
-			*xy += quant * sens;
-			if ( *xy < 0 || ( bound > 0 && *xy > bound) )
-				*xy = bound;
+		*xy += quant * sens;
+		if ( *xy < 0 || ( bound > 0 && *xy > bound) )
+			*xy = bound;
 
-			select_or_drawcursor(selectsearch_mode, type);
+		select_or_drawcursor(selectsearch_mode, type);
 	}
 	quant = 0;
 	return 0;
diff --git a/st.h b/st.h
index 9fe4e00..f480d6f 100644
--- a/st.h
+++ b/st.h
@@ -1,9 +1,5 @@
 /* See LICENSE for license details. */
 
-#ifndef __ST_H__
-#define __ST_H__
-
-#include <stddef.h>
 #include <stdint.h>
 #include <sys/types.h>
 
@@ -131,5 +127,3 @@ extern char *termname;
 extern unsigned int tabspaces;
 extern unsigned int defaultfg;
 extern unsigned int defaultbg;
-
-#endif /* end of include guard: __ST_H__ */
diff --git a/win.h b/win.h
index fad22d6..4916347 100644
--- a/win.h
+++ b/win.h
@@ -1,10 +1,5 @@
 /* See LICENSE for license details. */
 
-#ifndef __WIN_H__
-#define __WIN_H__
-
-#include "st.h"
-
 enum win_mode {
 	MODE_VISIBLE     = 1 << 0,
 	MODE_FOCUSED     = 1 << 1,
@@ -46,5 +41,3 @@ int xstartdraw(void);
 void toggle_winmode(int);
 void keyboard_select(const Arg *);
 void xximspot(int, int);
-
-#endif /* end of include guard: __WIN_H__ */
diff --git a/x.c b/x.c
index 1e6852f..b23ce4e 100644
--- a/x.c
+++ b/x.c
@@ -17,11 +17,140 @@
 
 char *argv0;
 #include "arg.h"
-#include "x.h"
+#include "st.h"
+#include "win.h"
+
+/* types used in config.h */
+typedef struct {
+	uint mod;
+	KeySym keysym;
+	void (*func)(const Arg *);
+	const Arg arg;
+} Shortcut;
+
+typedef struct {
+	uint mod;
+	uint button;
+	void (*func)(const Arg *);
+	const Arg arg;
+	uint  release;
+	int  altscrn;  /* 0: don't care, -1: not alt screen, 1: alt screen */
+} MouseShortcut;
+
+typedef struct {
+	KeySym k;
+	uint mask;
+	char *s;
+	/* three-valued logic variables: 0 indifferent, 1 on, -1 off */
+	signed char appkey;    /* application keypad */
+	signed char appcursor; /* application cursor */
+} Key;
+
+typedef enum {
+	PixelGeometry,
+	CellGeometry
+} Geometry;
+
+/* X modifiers */
+#define XK_ANY_MOD    UINT_MAX
+#define XK_NO_MOD     0
+#define XK_SWITCH_MOD (1<<13)
+
+/* function definitions used in config.h */
+static void clipcopy(const Arg *);
+static void clippaste(const Arg *);
+static void numlock(const Arg *);
+static void selpaste(const Arg *);
+static void zoom(const Arg *);
+static void zoomabs(const Arg *);
+static void zoomreset(const Arg *);
+static void ttysend(const Arg *);
 
 /* config.h for applying patches and the configuration. */
 #include "config.h"
 
+/* XEMBED messages */
+#define XEMBED_FOCUS_IN  4
+#define XEMBED_FOCUS_OUT 5
+
+/* macros */
+#define IS_SET(flag)		((win.mode & (flag)) != 0)
+#define TRUERED(x)		(((x) & 0xff0000) >> 8)
+#define TRUEGREEN(x)		(((x) & 0xff00))
+#define TRUEBLUE(x)		(((x) & 0xff) << 8)
+
+typedef XftDraw *Draw;
+typedef XftColor Color;
+typedef XftGlyphFontSpec GlyphFontSpec;
+
+/* Purely graphic info */
+typedef struct {
+	int tw, th; /* tty width and height */
+	int w, h; /* window width and height */
+	int ch; /* char height */
+	int cw; /* char width  */
+	int mode; /* window state/mode flags */
+	int cursor; /* cursor style */
+} TermWindow;
+
+typedef struct {
+	Display *dpy;
+	Colormap cmap;
+	Window win;
+	Drawable buf;
+	GlyphFontSpec *specbuf; /* font spec buffer used for rendering */
+	Atom xembed, wmdeletewin, netwmname, netwmiconname, netwmpid;
+	struct {
+		XIM xim;
+		XIC xic;
+		XPoint spot;
+		XVaNestedList spotlist;
+	} ime;
+	Draw draw;
+	Visual *vis;
+	XSetWindowAttributes attrs;
+	/* Here, we use the term *pointer* to differentiate the cursor
+	 * one sees when hovering the mouse over the terminal from, e.g.,
+	 * a green rectangle where text would be entered. */
+	Cursor vpointer, bpointer; /* visible and hidden pointers */
+	int pointerisvisible;
+	int scr;
+	int isfixed; /* is fixed geometry? */
+	int l, t; /* left and top offset */
+	int gm; /* geometry mask */
+} XWindow;
+
+typedef struct {
+	Atom xtarget;
+	char *primary, *clipboard;
+	struct timespec tclick1;
+	struct timespec tclick2;
+} XSelection;
+
+/* Font structure */
+#define Font Font_
+typedef struct {
+	int height;
+	int width;
+	int ascent;
+	int descent;
+	int badslant;
+	int badweight;
+	short lbearing;
+	short rbearing;
+	XftFont *match;
+	FcFontSet *set;
+	FcPattern *pattern;
+} Font;
+
+/* Drawing Context */
+typedef struct {
+	Color *col;
+	size_t collen;
+	Font font, bfont, ifont, ibfont;
+	GC gc;
+} DC;
+
 static inline ushort sixd_to_16bit(int);
 static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int);
 static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int);
@@ -60,7 +189,7 @@ static void bpress(XEvent *);
 static void bmotion(XEvent *);
 static void propnotify(XEvent *);
 static void selnotify(XEvent *);
-/* static void selclear_(XEvent *); */
+static void selclear_(XEvent *);
 static void selrequest(XEvent *);
 static void setsel(char *, Time);
 static void mousesel(XEvent *, int);
@@ -141,7 +270,6 @@ clipcopy(const Arg *dummy)
 {
 	Atom clipboard;
 
-	(void)dummy;
 	free(xsel.clipboard);
 	xsel.clipboard = NULL;
 
@@ -157,7 +285,6 @@ clippaste(const Arg *dummy)
 {
 	Atom clipboard;
 
-	(void)dummy;
 	clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
 	XConvertSelection(xw.dpy, clipboard, xsel.xtarget, clipboard,
 			xw.win, CurrentTime);
@@ -166,7 +293,6 @@ clippaste(const Arg *dummy)
 void
 selpaste(const Arg *dummy)
 {
-	(void)dummy;
 	XConvertSelection(xw.dpy, XA_PRIMARY, xsel.xtarget, XA_PRIMARY,
 			xw.win, CurrentTime);
 }
@@ -174,7 +300,6 @@ selpaste(const Arg *dummy)
 void
 numlock(const Arg *dummy)
 {
-	(void)dummy;
 	win.mode ^= MODE_NUMLOCK;
 }
 
@@ -202,7 +327,6 @@ zoomreset(const Arg *arg)
 {
 	Arg larg;
 
-	(void)arg;
 	if (defaultfontsize > 0) {
 		larg.f = defaultfontsize;
 		zoomabs(&larg);
@@ -237,7 +361,7 @@ mousesel(XEvent *e, int done)
 	int type, seltype = SEL_REGULAR;
 	uint state = e->xbutton.state & ~(Button1Mask | forcemousemod);
 
-	for (type = 1; type < (long)LEN(selmasks); ++type) {
+	for (type = 1; type < LEN(selmasks); ++type) {
 		if (match(selmasks[type], state)) {
 			seltype = type;
 			break;
@@ -485,12 +609,11 @@ xclipcopy(void)
 	clipcopy(NULL);
 }
 
-/* void */
-/* selclear_(XEvent *e) */
-/* { */
-/*     (void)e; */
-/*     selclear(); */
-/* } */
+void
+selclear_(XEvent *e)
+{
+	selclear();
+}
 
 void
 selrequest(XEvent *e)
@@ -574,13 +697,6 @@ xsetsel(char *str)
 void
 brelease(XEvent *e)
 {
-	if (!xw.pointerisvisible) {
-		XDefineCursor(xw.dpy, xw.win, xw.vpointer);
-		xw.pointerisvisible = 1;
-		if (!IS_SET(MODE_MOUSEMANY))
-			xsetpointermotion(0);
-	}
-
 	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
 		mousereport(e);
 		return;
@@ -601,6 +717,7 @@ bmotion(XEvent *e)
 		if (!IS_SET(MODE_MOUSEMANY))
 			xsetpointermotion(0);
 	}
+
 	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
 		mousereport(e);
 		return;
@@ -690,7 +807,7 @@ xloadcols(void)
 		dc.col = xmalloc(dc.collen * sizeof(Color));
 	}
 
-	for (i = 0; i < (long)dc.collen; i++)
+	for (i = 0; i < dc.collen; i++)
 		if (!xloadcolor(i, NULL, &dc.col[i])) {
 			if (colorname[i])
 				die("could not allocate color '%s'\n", colorname[i]);
@@ -704,9 +821,8 @@ int
 xsetcolorname(int x, const char *name)
 {
 	Color ncolor;
-	long tmp = (long)dc.collen;
 
-	if (!BETWEEN(x, 0, tmp))
+	if (!BETWEEN(x, 0, dc.collen))
 		return 1;
 
 	if (!xloadcolor(x, name, &ncolor))
@@ -951,7 +1067,6 @@ ximopen(Display *dpy)
 	XIMCallback imdestroy = { .client_data = NULL, .callback = ximdestroy };
 	XICCallback icdestroy = { .client_data = NULL, .callback = xicdestroy };
 
-	(void)dpy;
 	xw.ime.xim = XOpenIM(xw.dpy, NULL, NULL, NULL);
 	if (xw.ime.xim == NULL)
 		return 0;
@@ -979,8 +1094,6 @@ ximopen(Display *dpy)
 void
 ximinstantiate(Display *dpy, XPointer client, XPointer call)
 {
-	(void)client;
-	(void)call;
 	if (ximopen(dpy))
 		XUnregisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,
 		                                 ximinstantiate, NULL);
@@ -989,9 +1102,6 @@ ximinstantiate(Display *dpy, XPointer client, XPointer call)
 void
 ximdestroy(XIM xim, XPointer client, XPointer call)
 {
-	(void)xim;
-	(void)client;
-	(void)call;
 	xw.ime.xim = NULL;
 	XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL,
 	                               ximinstantiate, NULL);
@@ -1001,9 +1111,6 @@ ximdestroy(XIM xim, XPointer client, XPointer call)
 int
 xicdestroy(XIC xim, XPointer client, XPointer call)
 {
-	(void)xim;
-	(void)client;
-	(void)call;
 	xw.ime.xic = NULL;
 	return 1;
 }
@@ -1107,6 +1214,7 @@ xinit(int w, int h)
 	blankpm = XCreateBitmapFromData(xw.dpy, xw.win, &(char){0}, 1, 1);
 	xw.bpointer = XCreatePixmapCursor(xw.dpy, blankpm, blankpm,
 					  &xmousefg, &xmousebg, 0, 0);
+
 	xw.xembed = XInternAtom(xw.dpy, "_XEMBED", False);
 	xw.wmdeletewin = XInternAtom(xw.dpy, "WM_DELETE_WINDOW", False);
 	xw.netwmname = XInternAtom(xw.dpy, "_NET_WM_NAME", False);
@@ -1588,7 +1696,6 @@ xximspot(int x, int y)
 void
 expose(XEvent *ev)
 {
-	(void)ev;
 	redraw();
 }
 
@@ -1603,7 +1710,6 @@ visibility(XEvent *ev)
 void
 unmap(XEvent *ev)
 {
-	(void)ev;
 	win.mode &= ~MODE_VISIBLE;
 }
 
@@ -1690,7 +1796,7 @@ kmap(KeySym k, uint state)
 	int i;
 
 	/* Check for mapped keys out of X11 function keys. */
-	for (i = 0; i < (long)LEN(mappedkeys); i++) {
+	for (i = 0; i < LEN(mappedkeys); i++) {
 		if (mappedkeys[i] == k)
 			break;
 	}
@@ -1746,7 +1852,7 @@ kpress(XEvent *ev)
 		len = XLookupString(e, buf, sizeof buf, &ksym, NULL);
 	if ( IS_SET(MODE_KBDSELECT) ) {
 		if ( match(XK_NO_MOD, e->state) ||
-				(XK_Shift_L | XK_Shift_R) & e->state )
+		     (XK_Shift_L | XK_Shift_R) & e->state )
 			win.mode ^= trt_kbdselect(ksym, buf, len);
 		return;
 	}
@@ -1796,7 +1902,7 @@ cmessage(XEvent *e)
 		} else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) {
 			win.mode &= ~MODE_FOCUSED;
 		}
-	} else if (e->xclient.data.l[0] == (long)xw.wmdeletewin) {
+	} else if (e->xclient.data.l[0] == xw.wmdeletewin) {
 		ttyhangup();
 		exit(0);
 	}
@@ -1915,19 +2021,6 @@ run(void)
 }
 
 void
-toggle_winmode(int flag)
-{
-	win.mode ^= flag;
-}
-
-void
-keyboard_select(const Arg *dummy)
-{
-	(void)dummy;
-	win.mode ^= trt_kbdselect(-1, NULL, 0);
-}
-
-void
 usage(void)
 {
 	die("usage: %s [-aiv] [-c class] [-f font] [-g geometry]"
@@ -1940,6 +2033,14 @@ usage(void)
 	    " [stty_args ...]\n", argv0, argv0);
 }
 
+void toggle_winmode(int flag) {
+	win.mode ^= flag;
+}
+
+void keyboard_select(const Arg *dummy) {
+	win.mode ^= trt_kbdselect(-1, NULL, 0);
+}
+
 int
 main(int argc, char *argv[])
 {
@@ -1991,7 +2092,7 @@ main(int argc, char *argv[])
 		opt_embed = EARGF(usage());
 		break;
 	case 'v':
-		die("%s 0.8.4\n", argv0);
+		die("%s " VERSION "\n", argv0);
 		break;
 	default:
 		usage();
diff --git a/x.h b/x.h
deleted file mode 100644
index e5baa8b..0000000
--- a/x.h
+++ /dev/null
@@ -1,151 +0,0 @@
-#ifndef __X_H__
-#define __X_H__
-
-#include <errno.h>
-#include <math.h>
-#include <limits.h>
-#include <locale.h>
-#include <signal.h>
-#include <sys/select.h>
-#include <time.h>
-#include <unistd.h>
-#include <libgen.h>
-#include <X11/Xatom.h>
-#include <X11/Xlib.h>
-#include <X11/cursorfont.h>
-#include <X11/keysym.h>
-#include <X11/Xft/Xft.h>
-#include <X11/XKBlib.h>
-
-#include "st.h"
-#include "win.h"
-
-/* types used in config.h */
-typedef struct {
-	uint mod;
-	KeySym keysym;
-	void (*func)(const Arg *);
-	const Arg arg;
-} Shortcut;
-
-typedef struct {
-	uint mod;
-	uint button;
-	void (*func)(const Arg *);
-	const Arg arg;
-	uint  release;
-	int  altscrn;  /* 0: don't care, -1: not alt screen, 1: alt screen */
-} MouseShortcut;
-
-typedef struct {
-	KeySym k;
-	uint mask;
-	char *s;
-	/* three-valued logic variables: 0 indifferent, 1 on, -1 off */
-	signed char appkey;    /* application keypad */
-	signed char appcursor; /* application cursor */
-} Key;
-
-typedef enum {
-	PixelGeometry,
-	CellGeometry
-} Geometry;
-
-/* X modifiers */
-#define XK_ANY_MOD    UINT_MAX
-#define XK_NO_MOD     0
-#define XK_SWITCH_MOD (1<<13)
-
-/* function definitions used in config.h */
-void clipcopy(const Arg *);
-void clippaste(const Arg *);
-void numlock(const Arg *);
-void selpaste(const Arg *);
-void zoom(const Arg *);
-void zoomabs(const Arg *);
-void zoomreset(const Arg *);
-void ttysend(const Arg *);
-
-/* XEMBED messages */
-#define XEMBED_FOCUS_IN  4
-#define XEMBED_FOCUS_OUT 5
-
-/* macros */
-#define IS_SET(flag)		((win.mode & (flag)) != 0)
-#define TRUERED(x)		(((x) & 0xff0000) >> 8)
-#define TRUEGREEN(x)		(((x) & 0xff00))
-#define TRUEBLUE(x)		(((x) & 0xff) << 8)
-
-typedef XftDraw *Draw;
-typedef XftColor Color;
-typedef XftGlyphFontSpec GlyphFontSpec;
-
-/* Purely graphic info */
-typedef struct {
-	int tw, th; /* tty width and height */
-	int w, h; /* window width and height */
-	int ch; /* char height */
-	int cw; /* char width  */
-	int mode; /* window state/mode flags */
-	int cursor; /* cursor style */
-} TermWindow;
-
-typedef struct {
-	Display *dpy;
-	Colormap cmap;
-	Window win;
-	Drawable buf;
-	GlyphFontSpec *specbuf; /* font spec buffer used for rendering */
-	Atom xembed, wmdeletewin, netwmname, netwmiconname, netwmpid;
-	struct {
-		XIM xim;
-		XIC xic;
-		XPoint spot;
-		XVaNestedList spotlist;
-	} ime;
-	Draw draw;
-	Visual *vis;
-	XSetWindowAttributes attrs;
-	/* Here, we use the term *pointer* to differentiate the cursor
-	 * one sees when hovering the mouse over the terminal from, e.g.,
-	 * a green rectangle where text would be entered. */
-	Cursor vpointer, bpointer; /* visible and hidden pointers */
-	int pointerisvisible;
-	int scr;
-	int isfixed; /* is fixed geometry? */
-	int l, t; /* left and top offset */
-	int gm; /* geometry mask */
-} XWindow;
-
-typedef struct {
-	Atom xtarget;
-	char *primary, *clipboard;
-	struct timespec tclick1;
-	struct timespec tclick2;
-} XSelection;
-
-/* Font structure */
-#define Font Font_
-typedef struct {
-	int height;
-	int width;
-	int ascent;
-	int descent;
-	int badslant;
-	int badweight;
-	short lbearing;
-	short rbearing;
-	XftFont *match;
-	FcFontSet *set;
-	FcPattern *pattern;
-} Font;
-
-/* Drawing Context */
-typedef struct {
-	Color *col;
-	size_t collen;
-	Font font, bfont, ifont, ibfont;
-	GC gc;
-} DC;
-
-#endif /* ifndef __X_H__ */