mesa xkeyboard-config xserver git update 15 jan 2014

xserver          commit 2d2d49dab5c5718989de97d7227aac793479745e
xkeyboard-config commit 78af7aa79c6552924295644b911e45d07a0fcdad
mesa             commit a05c596a00916ce6a9c9d35ff36cd1e401fddd43

32 files changed, 523 insertions, 444 deletions

diff --git a/xorg-server/xkeyboard-config/compat/README b/xorg-server/xkeyboard-config/compat/README
index 00d591e7b..3c5747bb8 100644
--- a/xorg-server/xkeyboard-config/compat/README
+++ b/xorg-server/xkeyboard-config/compat/README
@@ -1,7 +1,7 @@
 The core protocol interpretation of keyboard modifiers does not include direct
 support for multiple keyboard groups, so XKB reports the effective keyboard
-group to XKB-aware clients using some of reserved bits in the state field of
-some core protocol events. This modified state field would not be interpreted
+group to XKB-aware clients using some of the reserved bits in the state field
+of some core protocol events. This modified state field would not be interpreted
 correctly by XKB-unaware clients, so XKB provides a group compatibility mapping
 which remaps the keyboard group into a core modifier mask that has similar
 effects, when possible.
@@ -15,8 +15,8 @@ XKB-unaware clients(*) work as well as possible:
 - The compatibility grab state which is the nearest core-protocol equivalent
   of the grab state.
 
-Compatibility state are essentially the corresponding XKB states, but with
-keyboard group possibly encoded as one or more modifiers. 
+Compatibility states are essentially the corresponding XKB states, but with
+the keyboard group possibly encoded as one or more modifiers.
 
 Modifiers that correspond to each keyboard group are described in this
 group compatibility map.
@@ -25,9 +25,9 @@ group compatibility map.
 ----
 (*) The implementation of XKB invisibly extends the X library to use the
 keyboard extension if it is present. That means, clients that use library or
-toolkit routines to interpret keyboard events automatically use all of XKB
-features; clients that directly interpret the state field of core protocol
-events or the keymap direcly may be affected by some of the XKB differences.
+toolkit routines to interpret keyboard events automatically use all of XKB's
+features; clients that directly interpret the state field of core-protocol
+events or the keymap directly may be affected by some of the XKB differences.
 Thus most clients can take all advantages without modification but it also
 means that XKB state can be reported to clients that have not explicitly
 requested the keyboard extension.
diff --git a/xorg-server/xkeyboard-config/compat/accessx b/xorg-server/xkeyboard-config/compat/accessx
index 0ed34ced1..6dd6ca930 100644
--- a/xorg-server/xkeyboard-config/compat/accessx
+++ b/xorg-server/xkeyboard-config/compat/accessx
@@ -1,17 +1,17 @@
 default partial xkb_compatibility "basic" {
-    interpret AccessX_Enable { 
-	action= LockControls(controls=AccessXKeys); 
+    interpret AccessX_Enable {
+	action= LockControls(controls=AccessXKeys);
     };
 };
 
 partial xkb_compatibility "full" {
 
     interpret AccessX_Enable {
-	action= LockControls(controls=AccessXKeys); 
+	action= LockControls(controls=AccessXKeys);
     };
 
-    interpret AccessX_Feedback_Enable { 
-	action= LockControls(controls=AccessXFeedback); 
+    interpret AccessX_Feedback_Enable {
+	action= LockControls(controls=AccessXFeedback);
     };
 
     interpret RepeatKeys_Enable {
diff --git a/xorg-server/xkeyboard-config/compat/basic b/xorg-server/xkeyboard-config/compat/basic
index 393c32445..745cbbaed 100644
--- a/xorg-server/xkeyboard-config/compat/basic
+++ b/xorg-server/xkeyboard-config/compat/basic
@@ -1,10 +1,11 @@
-// Minimal set of symbol interpretations to provide 
-// reasonable default behavior (Num lock, shift and 
-// caps lock and mode switch) and set up the 
+// Minimal set of symbol interpretations to provide
+// reasonable default behavior (Num lock, Shift lock,
+// Caps lock, and Mode switch) and set up the
 // automatic updating of common keyboard LEDs.
 
-default xkb_compatibility "basic"  {
-    virtual_modifiers NumLock,AltGr;
+default xkb_compatibility "basic" {
+
+    virtual_modifiers  NumLock,AltGr;
 
     interpret.repeat= False;
     setMods.clearLocks= True;
diff --git a/xorg-server/xkeyboard-config/compat/caps b/xorg-server/xkeyboard-config/compat/caps
index d787ab63d..4793051ec 100644
--- a/xorg-server/xkeyboard-config/compat/caps
+++ b/xorg-server/xkeyboard-config/compat/caps
@@ -1,11 +1,10 @@
-partial xkb_compatibility "caps_lock"  {
-    // Keysym Caps_Lock locks Lock modifier.
-    // With this, the keysym Caps_Lock can be used without binding the whole
-    // key to a real modifier.
-	// This is essential when you don't want to use caps lock on the first
-	// level.
-	// This should not have any compatibility issues when used together with
-	// other layouts which don't utilize this capability.
+partial xkb_compatibility "caps_lock" {
+    // Keysym Caps_Lock locks the Lock modifier.
+    // With this definition, the keysym Caps_Lock can be used without binding
+    // the whole key to a real modifier.  This is essential when you don't
+    // want to use Caps_Lock on the first level.
+    // This should not have any compatibility issues when used together with
+    // other layouts which don't utilize this capability.
     interpret Caps_Lock {
         action = LockMods(modifiers = Lock);
     };
diff --git a/xorg-server/xkeyboard-config/compat/complete b/xorg-server/xkeyboard-config/compat/complete
index d33c4dbce..8f77538db 100644
--- a/xorg-server/xkeyboard-config/compat/complete
+++ b/xorg-server/xkeyboard-config/compat/complete
@@ -1,4 +1,4 @@
-default xkb_compatibility "complete"  {
+default xkb_compatibility "complete" {
     include "basic"
     augment "iso9995"
     augment "mousekeys"
diff --git a/xorg-server/xkeyboard-config/compat/iso9995 b/xorg-server/xkeyboard-config/compat/iso9995
index 76188d1f0..0f3025b8c 100644
--- a/xorg-server/xkeyboard-config/compat/iso9995
+++ b/xorg-server/xkeyboard-config/compat/iso9995
@@ -1,8 +1,9 @@
-// Fairly complete set of symbol interpretations 
-// to provide reasonable default behavior
+// Fairly complete set of symbol interpretations
+// to provide reasonable default behavior.
 
-default partial xkb_compatibility "default"  {
-    virtual_modifiers LevelThree,AltGr;
+default partial xkb_compatibility "default" {
+
+    virtual_modifiers  LevelThree,AltGr;
 
     interpret.repeat= False;
     setMods.clearLocks= True;
diff --git a/xorg-server/xkeyboard-config/compat/japan b/xorg-server/xkeyboard-config/compat/japan
index ab4f85e4c..322bbdb14 100644
--- a/xorg-server/xkeyboard-config/compat/japan
+++ b/xorg-server/xkeyboard-config/compat/japan
@@ -1,11 +1,11 @@
-// Japanese keyboards need Eisu and Kana shift and 
-// lock keys, which are typically bound to the
-// second shift level for some other modifier key.
+// Japanese keyboards need the Eisu and Kana Shift
+// and Lock keys, which are typically bound to the
+// second shift level of some other modifier key.
 // These interpretations disable the default
 // interpretation (which would have these keys set
-// the same modifier as the level one symbol).
+// to the same modifier as the level one symbol).
 
-default partial xkb_compatibility "japan"  {
+default partial xkb_compatibility "japan" {
 
     interpret.repeat= False;
 
@@ -26,16 +26,16 @@ default partial xkb_compatibility "japan"  {
     };
 };
 
-// Some Japanese keyboards have an explict Kana Lock key & matching LED
+// Some Japanese keyboards have an explict
+// Kana Lock key and matching LED.
+partial xkb_compatibility "kana_lock" {
 
-partial xkb_compatibility "kana_lock"  {
-
-    virtual_modifiers Kana_Lock;
+    virtual_modifiers  Kana_Lock;
 
     interpret Kana_Lock+AnyOfOrNone(all) {
-        virtualModifier= Kana_Lock;
-        useModMapMods=level1;
-        action= LockGroup(group=+1);
+	virtualModifier= Kana_Lock;
+	useModMapMods=level1;
+	action= LockGroup(group=+1);
     };
 
     indicator "Kana" {
diff --git a/xorg-server/xkeyboard-config/compat/ledcaps b/xorg-server/xkeyboard-config/compat/ledcaps
index fc3084eec..f1460ba36 100644
--- a/xorg-server/xkeyboard-config/compat/ledcaps
+++ b/xorg-server/xkeyboard-config/compat/ledcaps
@@ -1,23 +1,24 @@
-// Use Caps Lock LED to show either Caps Lock, Group, or Shift Lock state
+// Use the Caps Lock LED to show either
+// Caps Lock, Group, or Shift Lock state.
 
-default partial xkb_compatibility "caps_lock"   {
-   indicator "Caps Lock" {
-       !allowExplicit;
-       whichModState= Locked;
-       modifiers= Lock;
-   };
+default partial xkb_compatibility "caps_lock" {
+    indicator "Caps Lock" {
+	!allowExplicit;
+	whichModState= Locked;
+	modifiers= Lock;
+    };
 };
 
-partial xkb_compatibility "group_lock"   {
-   indicator "Caps Lock" {
-       modifiers= None;
-       groups=All-group1;
-   };
+partial xkb_compatibility "group_lock" {
+    indicator "Caps Lock" {
+	modifiers= None;
+	groups=All-group1;
+    };
 };
 
-partial xkb_compatibility "shift_lock"   {
-   indicator "Caps Lock" {
-       whichModState= Locked;
-       modifiers= Shift;
-   };
+partial xkb_compatibility "shift_lock" {
+    indicator "Caps Lock" {
+	whichModState= Locked;
+	modifiers= Shift;
+    };
 };
diff --git a/xorg-server/xkeyboard-config/compat/lednum b/xorg-server/xkeyboard-config/compat/lednum
index 24a60a595..bfdcd744e 100644
--- a/xorg-server/xkeyboard-config/compat/lednum
+++ b/xorg-server/xkeyboard-config/compat/lednum
@@ -1,23 +1,24 @@
-// Use Num Lock LED to show either Num Lock, Group, or Shift Lock state
+// Use the Num Lock LED to show either
+// Num Lock, Group, or Shift Lock state.
 
-default partial xkb_compatibility "num_lock"   {
+default partial xkb_compatibility "num_lock" {
     indicator "Num Lock" {
-       !allowExplicit;
-       whichModState= Locked;
-       modifiers= NumLock;
-   };
+	!allowExplicit;
+	whichModState= Locked;
+	modifiers= NumLock;
+    };
 };
 
-partial xkb_compatibility "group_lock"   {
-   indicator "Num Lock" {
-       modifiers= None;
-       groups=All-group1;
-   };
+partial xkb_compatibility "group_lock" {
+    indicator "Num Lock" {
+	modifiers= None;
+	groups=All-group1;
+    };
 };
 
-partial xkb_compatibility "shift_lock"   {
-   indicator "Num Lock" {
-       whichModState= Locked;
-       modifiers= Shift;
-   };
+partial xkb_compatibility "shift_lock" {
+    indicator "Num Lock" {
+	whichModState= Locked;
+	modifiers= Shift;
+    };
 };
diff --git a/xorg-server/xkeyboard-config/compat/ledscroll b/xorg-server/xkeyboard-config/compat/ledscroll
index ca5a82c4c..a24169827 100644
--- a/xorg-server/xkeyboard-config/compat/ledscroll
+++ b/xorg-server/xkeyboard-config/compat/ledscroll
@@ -1,23 +1,24 @@
-// Use Scroll Lock LED to show either Scroll Lock, Group, or Shift Lock state
+// Use the Scroll Lock LED to show either
+// Scroll Lock, Group, or Shift Lock state.
 
-default partial xkb_compatibility "scroll_lock"   {
-   indicator "Scroll Lock" {
-       allowExplicit;
-       whichModState= Locked;
-       modifiers= ScrollLock;
-   };
+default partial xkb_compatibility "scroll_lock" {
+    indicator "Scroll Lock" {
+	allowExplicit;
+	whichModState= Locked;
+	modifiers= ScrollLock;
+    };
 };
 
-partial xkb_compatibility "group_lock"   {
-   indicator "Scroll Lock" {
-       modifiers= None;
-       groups=All-group1;
-   };
+partial xkb_compatibility "group_lock" {
+    indicator "Scroll Lock" {
+	modifiers= None;
+	groups=All-group1;
+    };
 };
 
-partial xkb_compatibility "shift_lock"   {
-   indicator "Scroll Lock" {
-       whichModState= Locked;
-       modifiers= Shift;
-   };
+partial xkb_compatibility "shift_lock" {
+    indicator "Scroll Lock" {
+	whichModState= Locked;
+	modifiers= Shift;
+    };
 };
diff --git a/xorg-server/xkeyboard-config/compat/level5 b/xorg-server/xkeyboard-config/compat/level5
index 8e0cc9c38..54f749d4d 100644
--- a/xorg-server/xkeyboard-config/compat/level5
+++ b/xorg-server/xkeyboard-config/compat/level5
@@ -1,8 +1,9 @@
-// Fairly complete set of symbol interpretations 
-// to provide reasonable default behavior
+// Fairly complete set of symbol interpretations
+// to provide reasonable default behavior.
 
-default partial xkb_compatibility "default"  {
-    virtual_modifiers LevelFive;
+default partial xkb_compatibility "default" {
+
+    virtual_modifiers  LevelFive;
 
     interpret.repeat= False;
     setMods.clearLocks= True;
@@ -39,15 +40,17 @@ default partial xkb_compatibility "default"  {
 	action= LockMods(modifiers=LevelFive);
     };
 };
-partial xkb_compatibility "level5_lock"  {
-	// This defines a Level5-Lock using the NumLock real modifier in order to
-	// create arbitrary level-behaviour, which would not be possible with the
-	// virtual modifier.
-	// See also: types/level5 : EIGHT_LEVEL_LEVEL_FIVE_LOCK
-	// See also: symbols/level5(lock)
-    virtual_modifiers NumLock;
-    
+
+partial xkb_compatibility "level5_lock" {
+    // This defines a Level5-Lock using the NumLock real modifier
+    // in order to create arbitrary level-behaviour, which would
+    // not be possible with the virtual modifier.
+    // See also: types/level5 : EIGHT_LEVEL_LEVEL_FIVE_LOCK
+    // See also: symbols/level5(lock)
+
+    virtual_modifiers  NumLock;
+
     interpret ISO_Level5_Lock {
-        action = LockMods(modifiers = NumLock);
+	action = LockMods(modifiers = NumLock);
     };
 };
diff --git a/xorg-server/xkeyboard-config/compat/misc b/xorg-server/xkeyboard-config/compat/misc
index cfe9a39b4..964f47125 100644
--- a/xorg-server/xkeyboard-config/compat/misc
+++ b/xorg-server/xkeyboard-config/compat/misc
@@ -1,122 +1,122 @@
-default partial xkb_compatibility "misc"  {
+default partial xkb_compatibility "misc" {
 
-    virtual_modifiers	Alt,Meta,Super,Hyper,ScrollLock;
+    virtual_modifiers  Alt,Meta,Super,Hyper,ScrollLock;
 
-    // Interpretations for some other useful keys
+    // Interpretations for some other useful keys.
 
     interpret Terminate_Server {
-        action = Terminate();
+	action = Terminate();
     };
 
     setMods.clearLocks= True;
 
-    // Sets the "Alt" virtual modifier
+    // Sets the "Alt" virtual modifier.
 
-    interpret Alt_L+Any     {
+    interpret Alt_L+Any {
         //useModMapMods= level1;
 	virtualModifier= Alt;
 	action = SetMods(modifiers=modMapMods);
     };
 
-    interpret Alt_L	{
+    interpret Alt_L {
 	action = SetMods(modifiers=Alt);
     };
 
-    interpret Alt_R+Any     {
+    interpret Alt_R+Any {
         //useModMapMods= level1;
 	virtualModifier= Alt;
 	action = SetMods(modifiers=modMapMods);
     };
 
-    interpret Alt_R	{
+    interpret Alt_R {
 	action = SetMods(modifiers=Alt);
     };
 
-    // Sets the "Meta" virtual modifier
+    // Sets the "Meta" virtual modifier.
 
-    interpret Meta_L+Any     {
-//        useModMapMods= level1;
+    interpret Meta_L+Any {
+        //useModMapMods= level1;
 	virtualModifier= Meta;
 	action = SetMods(modifiers=modMapMods);
     };
 
-    interpret Meta_L	{
+    interpret Meta_L {
 	action = SetMods(modifiers=Meta);
     };
 
-    interpret Meta_R+Any     {
+    interpret Meta_R+Any {
         //useModMapMods= level1;
 	virtualModifier= Meta;
 	action = SetMods(modifiers=modMapMods);
     };
 
-    interpret Meta_R	{
+    interpret Meta_R {
 	action = SetMods(modifiers=Meta);
     };
 
-    // Sets the "Super" virtual modifier
+    // Sets the "Super" virtual modifier.
 
-    interpret Super_L+Any     {
-//        useModMapMods= level1;
+    interpret Super_L+Any {
+        //useModMapMods= level1;
 	virtualModifier= Super;
 	action = SetMods(modifiers=modMapMods);
     };
 
-    interpret Super_L	{
+    interpret Super_L {
 	action = SetMods(modifiers=Super);
     };
 
-    interpret Super_R+Any     {
+    interpret Super_R+Any {
         //useModMapMods= level1;
 	virtualModifier= Super;
 	action = SetMods(modifiers=modMapMods);
     };
 
-    interpret Super_R	{
+    interpret Super_R {
 	action = SetMods(modifiers=Super);
     };
 
-    // Sets the "Hyper" virtual modifier
+    // Sets the "Hyper" virtual modifier.
 
-    interpret Hyper_L+Any     {
-//        useModMapMods= level1;
+    interpret Hyper_L+Any {
+        //useModMapMods= level1;
 	virtualModifier= Hyper;
 	action = SetMods(modifiers=modMapMods);
     };
 
-    interpret Hyper_L	{
+    interpret Hyper_L {
 	action = SetMods(modifiers=Hyper);
     };
 
-    interpret Hyper_R+Any     {
+    interpret Hyper_R+Any {
         //useModMapMods= level1;
 	virtualModifier= Hyper;
 	action = SetMods(modifiers=modMapMods);
     };
 
-    interpret Hyper_R	{
+    interpret Hyper_R {
 	action = SetMods(modifiers=Hyper);
     };
 
     // Sets the "ScrollLock" virtual modifier and
     // makes it actually lock when pressed.  Sets
     // up a map for the scroll lock indicator.
-    interpret Scroll_Lock+Any	{
+    interpret Scroll_Lock+Any {
 	virtualModifier= ScrollLock;
 	action = LockMods(modifiers=modMapMods);
     };
 
     include "ledscroll"
-	
+
     include "misc(assign_shift_left_action)"
 };
 
-partial xkb_compatibility "assign_shift_left_action"  {
-    // Because of the irrevertable modifier mapping in symbols/pc <LFSH> is 
-    // getting bound to the Lock modifier when using 
-    // symbols/shift(both_capslock), creating unwanted behaviour. 
+partial xkb_compatibility "assign_shift_left_action" {
+    // Because of the irrevertable modifier mapping in symbols/pc,
+    // <LFSH> is getting bound to the Lock modifier when using
+    // symbols/shift(both_capslock), creating unwanted behaviour.
     // This is a quirk, to circumvent the problem.
     interpret Shift_L {
-        action = SetMods(modifiers = Shift);
+	action = SetMods(modifiers = Shift);
     };
 };
diff --git a/xorg-server/xkeyboard-config/compat/mousekeys b/xorg-server/xkeyboard-config/compat/mousekeys
index f60c756c4..6b96fbcf8 100644
--- a/xorg-server/xkeyboard-config/compat/mousekeys
+++ b/xorg-server/xkeyboard-config/compat/mousekeys
@@ -1,147 +1,147 @@
-// Interpretations for arrow keys and a bunch of other 
-// common keysyms which make it possible to bind "mouse" 
-// keys using xmodmap and activate or deactivate them 
-// from the keyboard.
+// Interpretations for arrow keys and a bunch of
+// other common keysyms which make it possible to
+// bind "mouse" keys using xmodmap and activate or
+// deactivate them from the keyboard.
 
 default partial xkb_compatibility "mousekeys" {
 
     // Keypad actions.
-    //
+
     interpret.repeat= True;
 
-    interpret KP_1 { 
-	action = MovePtr(x=-1,y= +1); 
+    interpret KP_1 {
+	action = MovePtr(x=-1,y= +1);
     };
-    interpret KP_End { 
-	action = MovePtr(x=-1,y= +1); 
+    interpret KP_End {
+	action = MovePtr(x=-1,y= +1);
     };
 
-    interpret KP_2 { 
-	action = MovePtr(x=+0,y= +1); 
+    interpret KP_2 {
+	action = MovePtr(x=+0,y= +1);
     };
-    interpret KP_Down { 
-	action = MovePtr(x=+0,y= +1); 
+    interpret KP_Down {
+	action = MovePtr(x=+0,y= +1);
     };
 
-    interpret KP_3 { 
-	action = MovePtr(x=+1,y=+1); 
+    interpret KP_3 {
+	action = MovePtr(x=+1,y=+1);
     };
-    interpret KP_Next { 
- 	action = MovePtr(x=+1,y=+1); 
+    interpret KP_Next {
+	action = MovePtr(x=+1,y=+1);
     };
 
-    interpret KP_4 { 
-	action = MovePtr(x=-1,y=+0); 
+    interpret KP_4 {
+	action = MovePtr(x=-1,y=+0);
     };
-    interpret KP_Left { 
-	action = MovePtr(x=-1,y=+0); 
+    interpret KP_Left {
+	action = MovePtr(x=-1,y=+0);
     };
 
-    interpret KP_6 { 
-	action = MovePtr(x=+1,y=+0); 
+    interpret KP_6 {
+	action = MovePtr(x=+1,y=+0);
     };
-    interpret KP_Right { 
- 	action = MovePtr(x=+1,y=+0); 
+    interpret KP_Right {
+	action = MovePtr(x=+1,y=+0);
     };
 
-    interpret KP_7 { 
-	action = MovePtr(x=-1,y=-1); 
+    interpret KP_7 {
+	action = MovePtr(x=-1,y=-1);
     };
-    interpret KP_Home { 
-	action = MovePtr(x=-1,y=-1); 
+    interpret KP_Home {
+	action = MovePtr(x=-1,y=-1);
     };
 
-    interpret KP_8 { 
-	action = MovePtr(x=+0,y=-1); 
+    interpret KP_8 {
+	action = MovePtr(x=+0,y=-1);
     };
-    interpret KP_Up { 
-	action = MovePtr(x=+0,y=-1); 
+    interpret KP_Up {
+	action = MovePtr(x=+0,y=-1);
     };
 
-    interpret KP_9 { 
-	action = MovePtr(x=+1,y=-1); 
+    interpret KP_9 {
+	action = MovePtr(x=+1,y=-1);
     };
-    interpret KP_Prior { 
-	action = MovePtr(x=+1,y=-1); 
+    interpret KP_Prior {
+	action = MovePtr(x=+1,y=-1);
     };
 
-    interpret KP_5 { 
-	action = PointerButton(button=default); 
+    interpret KP_5 {
+	action = PointerButton(button=default);
     };
-    interpret KP_Begin { 
-	action = PointerButton(button=default); 
+    interpret KP_Begin {
+	action = PointerButton(button=default);
     };
 
-    interpret KP_F2 { 
-	action = SetPtrDflt(affect=defaultButton,button=1); 
+    interpret KP_F2 {
+	action = SetPtrDflt(affect=defaultButton,button=1);
     };
-    interpret KP_Divide { 
-	action = SetPtrDflt(affect=defaultButton,button=1); 
+    interpret KP_Divide {
+	action = SetPtrDflt(affect=defaultButton,button=1);
     };
 
-    interpret KP_F3 { 
-	action = SetPtrDflt(affect=defaultButton,button=2); 
+    interpret KP_F3 {
+	action = SetPtrDflt(affect=defaultButton,button=2);
     };
-    interpret KP_Multiply { 
-	action = SetPtrDflt(affect=defaultButton,button=2); 
+    interpret KP_Multiply {
+	action = SetPtrDflt(affect=defaultButton,button=2);
     };
 
-    interpret KP_F4 { 
-	action = SetPtrDflt(affect=defaultButton,button=3); 
+    interpret KP_F4 {
+	action = SetPtrDflt(affect=defaultButton,button=3);
     };
-    interpret KP_Subtract { 
-	action = SetPtrDflt(affect=defaultButton,button=3); 
+    interpret KP_Subtract {
+	action = SetPtrDflt(affect=defaultButton,button=3);
     };
 
-    interpret KP_Separator { 
-	action = PointerButton(button=default,count=2); 
+    interpret KP_Separator {
+	action = PointerButton(button=default,count=2);
     };
-    interpret KP_Add { 
+    interpret KP_Add {
 	action = PointerButton(button=default,count=2);
     };
 
-    interpret KP_0 { 
-	action = LockPointerButton(button=default,affect=lock); 
+    interpret KP_0 {
+	action = LockPointerButton(button=default,affect=lock);
     };
-    interpret KP_Insert { 
-	action = LockPointerButton(button=default,affect=lock); 
+    interpret KP_Insert {
+	action = LockPointerButton(button=default,affect=lock);
     };
 
-    interpret KP_Decimal { 
-	action = LockPointerButton(button=default,affect=unlock); 
+    interpret KP_Decimal {
+	action = LockPointerButton(button=default,affect=unlock);
     };
-    interpret KP_Delete { 
-	action = LockPointerButton(button=default,affect=unlock); 
+    interpret KP_Delete {
+	action = LockPointerButton(button=default,affect=unlock);
     };
 
-    // Additional mappings for Solaris keypad compatibility
+    // Additional mappings for Solaris keypad compatibility.
+
     interpret F25 { // aka KP_Divide
-	action = SetPtrDflt(affect=defaultButton,button=1); 
+	action = SetPtrDflt(affect=defaultButton,button=1);
     };
     interpret F26 { // aka KP_Multiply
-	action = SetPtrDflt(affect=defaultButton,button=2); 
+	action = SetPtrDflt(affect=defaultButton,button=2);
     };
     interpret F27 { // aka KP_Home
-	action = MovePtr(x=-1,y=-1); 
+	action = MovePtr(x=-1,y=-1);
     };
     interpret F29 { // aka KP_Prior
-	action = MovePtr(x=+1,y=-1); 
+	action = MovePtr(x=+1,y=-1);
     };
     interpret F31 { // aka KP_Begin
-	action = PointerButton(button=default); 
+	action = PointerButton(button=default);
     };
     interpret F33 { // aka KP_End
-	action = MovePtr(x=-1,y= +1); 
+	action = MovePtr(x=-1,y= +1);
     };
     interpret F35 { // aka KP_Next
- 	action = MovePtr(x=+1,y=+1); 
+	action = MovePtr(x=+1,y=+1);
     };
 
     interpret.repeat= False;
 
+    // New keysym actions.
 
-    // New Keysym Actions.
-    //
     interpret Pointer_Button_Dflt {
 	action= PointerButton(button=default);
     };
@@ -166,7 +166,7 @@ default partial xkb_compatibility "mousekeys" {
     interpret Pointer_DblClick3 {
 	action= PointerButton(button=3,count=2);
     };
-    interpret Pointer_Drag_Dflt	{
+    interpret Pointer_Drag_Dflt {
 	action= LockPointerButton(button=default);
     };
     interpret Pointer_Drag1 {
@@ -192,10 +192,9 @@ default partial xkb_compatibility "mousekeys" {
 	action= SetPtrDflt(affect=defaultButton,button= -1);
     };
 
-
     // Allow an indicator for MouseKeys.
     indicator "Mouse Keys" {
-//	!allowExplicit;
+        //!allowExplicit;
 	indicatorDrivesKeyboard;
 	controls= MouseKeys;
     };
diff --git a/xorg-server/xkeyboard-config/compat/olpc b/xorg-server/xkeyboard-config/compat/olpc
index a7a2cc425..747b444ec 100644
--- a/xorg-server/xkeyboard-config/compat/olpc
+++ b/xorg-server/xkeyboard-config/compat/olpc
@@ -1,51 +1,51 @@
 //
-// Created by Bernardo Innocenti <bernie@codewiz.org>
+// Map the OLPC game keys to virtual modifiers.
 //
-// Map the OLPC game keys to virtual modifiers
+// Created by Bernardo Innocenti <bernie@codewiz.org>
 //
 
-default xkb_compatibility "olpc"  {
+default xkb_compatibility "olpc" {
     include "complete"
 
     virtual_modifiers  Square,Cross,Triangle,Circle;
 
-    interpret KP_Home+Any     {
+    interpret KP_Home+Any {
         //useModMapMods= level1;
-       virtualModifier= Square;
-       action = SetMods(modifiers=modMapMods);
+        virtualModifier= Square;
+        action = SetMods(modifiers=modMapMods);
     };
 
-    interpret KP_Home  {
-       action = SetMods(modifiers=Square);
+    interpret KP_Home {
+        action = SetMods(modifiers=Square);
     };
 
-    interpret KP_Next+Any     {
+    interpret KP_Next+Any {
         //useModMapMods= level1;
-       virtualModifier= Cross;
-       action = SetMods(modifiers=modMapMods);
+        virtualModifier= Cross;
+        action = SetMods(modifiers=modMapMods);
     };
 
-    interpret KP_Next  {
-       action = SetMods(modifiers=Cross);
+    interpret KP_Next {
+        action = SetMods(modifiers=Cross);
     };
 
-    interpret KP_End+Any     {
+    interpret KP_End+Any {
         //useModMapMods= level1;
-       virtualModifier= Circle;
-       action = SetMods(modifiers=modMapMods);
+        virtualModifier= Circle;
+        action = SetMods(modifiers=modMapMods);
     };
 
-    interpret KP_End   {
-       action = SetMods(modifiers=Circle);
+    interpret KP_End {
+        action = SetMods(modifiers=Circle);
     };
 
-    interpret KP_Prior+Any     {
+    interpret KP_Prior+Any {
         //useModMapMods= level1;
-       virtualModifier= Triangle;
-       action = SetMods(modifiers=modMapMods);
+        virtualModifier= Triangle;
+        action = SetMods(modifiers=modMapMods);
     };
 
     interpret KP_Prior {
-       action = SetMods(modifiers=Triangle);
+        action = SetMods(modifiers=Triangle);
     };
 };
diff --git a/xorg-server/xkeyboard-config/compat/pc b/xorg-server/xkeyboard-config/compat/pc
index e970795c7..f69b54d77 100644
--- a/xorg-server/xkeyboard-config/compat/pc
+++ b/xorg-server/xkeyboard-config/compat/pc
@@ -1,16 +1,16 @@
-default partial xkb_compatibility "pc"  {
+default partial xkb_compatibility "pc" {
 
-    // Sets the "Alt" virtual modifier
+    // Sets the "Alt" virtual modifier.
 
-    virtual_modifiers	Alt;
+    virtual_modifiers  Alt;
 
     setMods.clearLocks= True;
-    interpret Alt_L+Any     { 
+    interpret Alt_L+Any {
 	virtualModifier= Alt;
 	action = SetMods(modifiers=modMapMods);
     };
 
-    interpret Alt_R+Any	{
+    interpret Alt_R+Any {
 	virtualModifier= Alt;
 	action = SetMods(modifiers=modMapMods);
     };
diff --git a/xorg-server/xkeyboard-config/compat/pc98 b/xorg-server/xkeyboard-config/compat/pc98
index f7e40014a..0abd623ff 100644
--- a/xorg-server/xkeyboard-config/compat/pc98
+++ b/xorg-server/xkeyboard-config/compat/pc98
@@ -1,10 +1,11 @@
-// Minimal set of symbol interpretations to provide 
-// reasonable default behavior (Num lock, shift and 
-// caps lock and mode switch) and set up the 
-// automatic updating of common keyboard LEDs.
+// Minimal set of symbol interpretations to provide
+// reasonable default behavior (Num lock, Shift lock,
+// and Mode switch) and set up the automatic updating
+// of common keyboard LEDs.
 
-default xkb_compatibility "basic"  {
-    virtual_modifiers NumLock,AltGr;
+default xkb_compatibility "basic" {
+
+    virtual_modifiers  NumLock,AltGr;
 
     interpret.repeat= False;
     setMods.clearLocks= True;
@@ -17,7 +18,7 @@ default xkb_compatibility "basic"  {
 
 //    interpret Any+Lock {
 //	action= LockMods(modifiers=Lock);
-//   }; 
+//    };
 
     interpret Num_Lock+Any {
 	virtualModifier= NumLock;
@@ -39,7 +40,7 @@ default xkb_compatibility "basic"  {
     group 4 = AltGr;
 
     indicator.allowExplicit= False;
-    indicator "Caps Lock" { 
+    indicator "Caps Lock" {
 	whichModState= Locked;
 	modifiers= Lock;
     };
diff --git a/xorg-server/xkeyboard-config/compat/xfree86 b/xorg-server/xkeyboard-config/compat/xfree86
index 52e661dce..cc4381974 100644
--- a/xorg-server/xkeyboard-config/compat/xfree86
+++ b/xorg-server/xkeyboard-config/compat/xfree86
@@ -1,6 +1,6 @@
-//  XFree86 special keysyms
+// XFree86 special keysyms.
 
-default partial xkb_compatibility "basic"  {
+default partial xkb_compatibility "basic" {
 
     interpret.repeat= True;
 
diff --git a/xorg-server/xkeyboard-config/compat/xtest b/xorg-server/xkeyboard-config/compat/xtest
index 5ee88ccf8..f2ca6430d 100644
--- a/xorg-server/xkeyboard-config/compat/xtest
+++ b/xorg-server/xkeyboard-config/compat/xtest
@@ -1,18 +1,17 @@
-default xkb_compatibility "xtest"  {
+default xkb_compatibility "xtest" {
 
     // Minimal set of symbol interpretations to provide
-    // reasonable behavior for testing.   The X Test 
-    // Suite assumes that it can set any modifier by 
-    // simulating a KeyPress and clear it by simulating 
-    // a KeyRelease.  Because of the way that XKB 
-    // implements locking/latching modifiers, this 
-    // approach fails in some cases (typically the 
-    // lock or num lock modifiers).  These symbol
-    // interpretations make all modifier keys just
-    // set the corresponding modifier so that xtest
+    // reasonable behavior for testing.
+    // The X Test Suite assumes that it can set any modifier
+    // by simulating a KeyPress and clear it by simulating a
+    // KeyRelease.  Because of the way that XKB implements
+    // locking/latching modifiers, this approach fails in
+    // some cases (typically the Lock or NumLock modifiers).
+    // These symbol interpretations make all modifier keys
+    // just set the corresponding modifier so that xtest
     // will see the behavior it expects.
 
-    virtual_modifiers NumLock,AltGr;
+    virtual_modifiers  NumLock,AltGr;
 
     interpret.repeat= False;
     setMods.clearLocks= True;
@@ -43,7 +42,7 @@ default xkb_compatibility "xtest"  {
     group 4 = AltGr;
 
     indicator.allowExplicit= False;
-    indicator "Caps Lock" { 
+    indicator "Caps Lock" {
 	modifiers= Lock;
     };
     indicator "Num Lock" {
diff --git a/xorg-server/xkeyboard-config/rules/base.xml.in b/xorg-server/xkeyboard-config/rules/base.xml.in
index 42fda3fb2..eb9586680 100644
--- a/xorg-server/xkeyboard-config/rules/base.xml.in
+++ b/xorg-server/xkeyboard-config/rules/base.xml.in
@@ -1838,6 +1838,13 @@
         </variant>
         <variant>
           <configItem>
+            <name>eeyek</name>
+            <description>Manipuri (Eeyek)</description>
+            <languageList><iso639Id>mni</iso639Id></languageList>
+          </configItem>
+        </variant>
+        <variant>
+          <configItem>
             <name>guj</name>
             <!-- Keyboard indicator for Gujarati layouts -->
             <_shortDescription>gu</_shortDescription>
diff --git a/xorg-server/xkeyboard-config/symbols/il b/xorg-server/xkeyboard-config/symbols/il
index a1f615c62..24028a867 100644
--- a/xorg-server/xkeyboard-config/symbols/il
+++ b/xorg-server/xkeyboard-config/symbols/il
@@ -1,78 +1,74 @@
 // based on a keyboard map from an 'xkb/symbols/il' file
 
-// This is a partial implemetation of the Israeli standard SI-1452
-// It does not implement changes to the English layout ("Alt-English"), 
-// as I believe that it is not the job of this layout to modify the English
-// layout.
+// This is an implemetation of the Israeli standard SI-1452 (2013)
+// It does not implement changes to the English layout, as that part
+// of the standard is not normative nor really useful in the context
+// of xkb.
+// This implementation extends the standard with Yiddish digraphs
+// (a common extension) and Nun Hafukha (a fun character).
+
 default  partial alphanumeric_keys
 xkb_symbols "basic" {
     // uses the kbd layout in use in Israel.
 
     name[Group1]= "Hebrew";
+    key.type[Group1] = "FOUR_LEVEL_SEMIALPHABETIC";
 
-    key <AD01> { [ slash,	Q		]	};
-    key <AD02> { [ apostrophe,	W		]	};
-    key <AD04> { [ hebrew_resh,	R		]	};
-    key <AD05> { [ hebrew_aleph,T		]       };
-    key <AD06> { [ hebrew_tet,	Y		]       };
-    key <AD07> { [ hebrew_waw,	U		]       };
-    key <AD08> { [ hebrew_finalnun,	I	]       };
-    key <AD09> { [ hebrew_finalmem,	O	]       };
-    key <AD10> { [ hebrew_pe,	P		]	};
+    key <AB01> { [ hebrew_zain,	Z		]       };
+    key <AB02> { [ hebrew_samech, X,	U05B6	]       };  // Segol
+    key <AB03> { [ hebrew_bet,	C,	U05B1	]       };  // Hataf Segol
+    key <AB04> { [ hebrew_he,	V		]       };
+    key <AB05> { [ hebrew_nun,	B,	NoSymbol,	U05C6	]}; // Nun Hafukha
+    key <AB06> { [ hebrew_mem,	N		]	};
+    key <AB07> { [ hebrew_zade,	M,	U05B5	]	};  // Tsere
+    key <AB08> { [ hebrew_taw,	greater,	rightsinglequotemark	]}; // greater Mirrored
+    key <AB09> { [ hebrew_finalzade,	less,	singlelowquotemark	]}; // less Mirrored
 
-    key <AC02> { [ hebrew_dalet,S		]       };
+    key <AC01> { [ hebrew_shin,	A,	U05B0	]	};  // Shva
+    key <AC02> { [ hebrew_dalet,S,	U05BC	]       };  // Dagesh
     key <AC03> { [ hebrew_gimel,D		]       };
     key <AC04> { [ hebrew_kaph,	F		]	};
-    key <AC05> { [ hebrew_ayin,	G		]       };
-    key <AC06> { [ hebrew_yod,	H		]       };
-    key <AC07> { [ hebrew_chet,	J		]	};
+    key <AC05> { [ hebrew_ayin,	G,	U05F1	]       };  // Yiddish Vav Yod
+    key <AC06> { [ hebrew_yod,	H,	U05F2	]       };  // Yiddish Double Yod
+    key <AC07> { [ hebrew_chet,	J,	U05B4	]	};  // Hiriq
     key <AC08> { [ hebrew_lamed, K		]	};
-    key <AC09> { [ hebrew_finalkaph,	L	]       };
-    key <AC10> { [ hebrew_finalpe,	colon	]       };
-    key <AC11> { [ comma,	quotedbl	]	};
+    key <AC09> { [ hebrew_finalkaph,	L,	rightdoublequotemark	]};
+    key <AC10> { [ hebrew_finalpe,	colon,	doublelowquotemark	]};
 
-    key <AB01> { [ hebrew_zain,	Z		]       };
-    key <AB02> { [ hebrew_samech, X		]       };
-    key <AB03> { [ hebrew_bet,	C		]       };
-    key <AB04> { [ hebrew_he,	V		]       };
-    key <AB05> { [ hebrew_nun,	B		]       };
-    key <AB06> { [ hebrew_mem,	N		]	};
-    key <AB07> { [ hebrew_zade,	M		]	};
-    // Mirrored:
-    key <AB08> { [ hebrew_taw,	greater		]	};
-    key <AB09> { [ hebrew_finalzade,	less	]	};
-
-    key.type[Group1] = "THREE_LEVEL";
-
-    key <TLDE> { [ semicolon,	asciitilde,0x10005b0	]}; // Sheva
-    key <AB10> { [ period,	question,  0x10005c3	]}; // Sof Pasuq
-    key <AD03> { [ hebrew_qoph,	E,	EuroSign	]};
-    key <AC01> { [ hebrew_shin,	A,	0x10020AA	]};
-
-    // The following may get overriden by the iso9995-3(basic101) symbols.
-    // therefore they are included here. 
-    // Including them isn't a great idea (for instance: what if group 1 uses
-    // UK keyboard mapping, and maps shift-3 to sterling? This mapping won't
-    // preserve that, and I'm not sure that this is a good feature.
-    key <AE01> { [     1, exclam      , 0x10005b1	]}; // H. Segol
-    key <AE02> { [     2, at          , 0x10005b2	]}; // H. Patah
-    key <AE03> { [     3, numbersign  , 0x10005b3	]}; // H.  Qamats
-    key <AE04> { [     4, dollar      , 0x10005b4	]}; // Hiriq
-    key <AE05> { [     5, percent     , 0x10005b5	]}; // Tsere
-    key <AE06> { [     6, asciicircum , 0x10005b6	]}; // Segol
-    key <AE07> { [     7, ampersand   , 0x10005b7	]}; // Patah
-    key <AE08> { [     8, asterisk    , 0x10005b8	]}; // Qamats
-    // Mirrored: 
-    key <AE09> { [     9, parenright   , 0x10005c2	]}; // Sin dot
-    key <AE10> { [     0, parenleft  , 0x10005c1	]}; // Shin dot
-    key <AE11> { [ minus, underscore  , 0x10005b9	]}; // Holam
-    key <AE12> { [ equal, plus        , 0x10005bc	]}; // Dagesh/Shuruq
-
-    // Mirrored: 
-    key <AD11> { [ bracketright, braceright, 0x10005bf	]}; // Rafe
-    key <AD12> { [ bracketleft,  braceleft,  0x10005bd	]}; // Meteg
-
-    key <BKSL> { [ backslash,    bar,  0x10005bb	]}; // Qubuts    
+    key <AD01> { [ slash,	Q,	U05C2	]	};  // Sin Dot
+    key <AD02> { [ apostrophe,	W,	U05C1	]	};  // Shin Dot
+    key <AD03> { [ hebrew_qoph,	E,	U05B8	]	};  // Qamats
+    key <AD04> { [ hebrew_resh,	R,	U05B3	]	};  // Hataf Qamats
+    key <AD05> { [ hebrew_aleph,T		]       };
+    key <AD06> { [ hebrew_tet,	Y,	U05F0	]       };  // Yiddish Double Vav
+    key <AD07> { [ hebrew_waw,	U,	U05B9	]       };  // Holam
+    key <AD08> { [ hebrew_finalnun,	I	]       };
+    key <AD09> { [ hebrew_finalmem,	O	]       };
+    key <AD10> { [ hebrew_pe,	P,	U05B7	]	};  // Patah
+
+    key.type[Group1] = "FOUR_LEVEL";
+
+    // Non-alphanumeric keys
+    key <AB10> { [ period,	question,  division	]};
+    key <AC11> { [ comma,	quotedbl,	U05F4]	};  // Gershayim
+    key <AD11> { [ bracketright, braceright, U05B2	]}; // Mirrored; Hataf Patah
+    key <AD12> { [ bracketleft,  braceleft,  U05BF	]}; // Mirrored; Rafe
+    key <BKSL> { [ backslash,    bar,  U05BB	]	};  // Qubuts
+
+    // Top (digits) row
+    key <TLDE> { [ semicolon,	asciitilde,	U05F3	]}; // Geresh
+    key <AE01> { [     1,	exclam	]		};
+    key <AE02> { [     2,	at	]		};
+    key <AE03> { [     3, 	numbersign,	EuroSign	]};
+    key <AE04> { [     4, 	dollar,		NewSheqelSign	]};
+    key <AE05> { [     5,	percent,	degree	]};
+    key <AE06> { [     6, 	asciicircum,	U05AB	]}; // Hebrew Accent Ole
+    key <AE07> { [     7,	ampersand,	U05BD	]}; // Meteg
+    key <AE08> { [     8,	asterisk,	multiply]};
+    key <AE09> { [     9,	parenright,	U200E	]}; // LRM; Paren Mirrored
+    key <AE10> { [     0,	parenleft,	U200F	]}; // RLM; Paren Mirrored
+    key <AE11> { [ minus,	underscore,	U05BE	]}; // Maqaf
+    key <AE12> { [ equal, 	plus,		endash	]};
 
     include "level3(ralt_switch)"
 };
diff --git a/xorg-server/xkeyboard-config/symbols/in b/xorg-server/xkeyboard-config/symbols/in
index fdf008887..f70e215e6 100644
--- a/xorg-server/xkeyboard-config/symbols/in
+++ b/xorg-server/xkeyboard-config/symbols/in
@@ -2013,4 +2013,72 @@ xkb_symbols "tel-kagapa" {
 
     include "level3(ralt_switch)"
 };
-// ---- END Telugu KaGaPa ----
+
+// Description 	: Keymap for Manipuri language (Meetei mayek script)
+// Encoding    	: Unicode (http://www.unicode.org)
+// Author      	: Santosh Heigrujam <santosh.tomba@gmail.com>
+// Date        	: December, 2013
+// Source	: 
+// Comment	:
+	
+partial alphanumeric_keys modifier_keys
+xkb_symbols "eeyek" {
+
+    name[Group1]= "Manipuri (Eeyek)";
+
+    // Alphanumeric section
+    key <TLDE> {	[     grave,	asciitilde	]	};
+    key <AE01> {	[	  Uabf1,	exclam 		]	};
+    key <AE02> {	[	  Uabf2,	at		]	};
+    key <AE03> {	[	  Uabf3,	numbersign	]	};
+    key <AE04> {	[	  Uabf4,	dollar		]	};
+    key <AE05> {	[	  Uabf5,	percent		]	};
+    key <AE06> {	[	  Uabf6,	asciicircum	]	};
+    key <AE07> {	[	  Uabf7,	ampersand	]	};
+    key <AE08> {	[	  Uabf8,	asterisk	]	};
+    key <AE09> {	[	  Uabf9,	parenleft	]	};
+    key <AE10> {	[	  Uabf0,	parenright	]	};
+    key <AE11> {	[     minus,	underscore	]	};
+    key <AE12> {	[     equal,	plus		]	};
+
+    key <AD01> {	[	  Uabc8,	Uabd8 		]	};
+    key <AD02> {	[	  Uabcb,	Uabcb		]	};
+    key <AD03> {	[	  Uabcf,	Uabe2		]	};
+    key <AD04> {	[	  Uabd4,	Uabd4		]	};
+    key <AD05> {	[	  Uabc7,	Uabe0		]	};
+    key <AD06> {	[	  Uabcc,	Uabe6		]	};
+    key <AD07> {	[	  Uabce,	Uabe8		]	};
+    key <AD08> {	[	  Uabe4,	Uabe9		]	};
+    key <AD09> {	[	  Uabe3,	Uabe7		]	};
+    key <AD10> {	[	  Uabc4,	Uabde		]	};
+    key <AD11> {	[ bracketleft,	braceleft	]	};
+    key <AD12> {	[ bracketright,	braceright	]	};
+
+    key <AC01> {	[	  Uabd1,	Uabe5 		]	};
+    key <AC02> {	[	  Uabc1,	Uabd3		]	};
+    key <AC03> {	[	  Uabd7,	Uabd9		]	};
+    key <AC04> {	[	  Uabd0,	Uabda		]	};
+    key <AC05> {	[	  Uabd2,	Uabd8		]	};
+    key <AC06> {	[	  Uabcd,	Uabea		]	};
+    key <AC07> {	[	  Uabd6,	Uabd3		]	};
+    key <AC08> {	[	  Uabc0,	Uabdb		]	};
+    key <AC09> {	[	  Uabc2,	Uabdc		]	};
+    key <AC10> {	[ semicolon,	colon		]	};
+    key <AC11> {	[ apostrophe,	quotedbl	]	};
+
+    key <AB01> {	[	  Uabc9,	Uabe1 		]	};
+    key <AB02> {	[	  Uabca,	Uabd9		]	};
+    key <AB03> {	[	  Uabc6,	Uabeb		]	};
+    key <AB04> {	[	  Uabda,	Uabed		]	};
+    key <AB05> {	[	  Uabd5,	Uabec		]	};
+    key <AB06> {	[	  Uabc5,	Uabdf		]	};
+    key <AB07> {	[	  Uabc3,	Uabdd		]	};
+    key <AB08> {	[     comma,	less		]	};
+    key <AB09> {	[    period,	greater		]	};
+    key <AB10> {	[     slash,	question	]	};
+
+    key <BKSL> {	[ backslash,         bar	]	};
+    // End alphanumeric section
+    
+    include "level3(ralt_switch)"
+};
diff --git a/xorg-server/xkeyboard-config/symbols/la b/xorg-server/xkeyboard-config/symbols/la
index 20c36c559..a77e971d3 100644
--- a/xorg-server/xkeyboard-config/symbols/la
+++ b/xorg-server/xkeyboard-config/symbols/la
@@ -76,7 +76,7 @@ xkb_symbols "stea" {
 
     name[Group1]= "Lao (STEA proposed standard layout)";
 
-    key <TLDE> { [  quotedbl,      apostrophe           	]};
+    key <TLDE> { [  quotedbl,      apostrophe			]};
     key <AE01> { [ 0x1000ea2,               1,       0x1000ed1	]};
     key <AE02> { [ 0x1000e9f,               2,       0x1000ed2	]};
     key <AE03> { [ 0x1000ec2,               3,       0x1000ed3	]};
@@ -88,48 +88,48 @@ xkb_symbols "stea" {
     key <AE09> { [ 0x1000e88,               7,       0x1000ed9	]};
     key <AE10> { [ 0x1000e82,               8,       0x1000ed0	]};
     key <AE11> { [ 0x1000e8a,               9			]};
-    key <AE12> { [ 0x1000ecd 					]};
+    key <AE12> { [ 0x1000ecd					]};
 
     key <AD01> { [ 0x1000ebb					]};
     key <AD02> { [ 0x1000ec4,               0			]};
-    key <AD03> { [ 0x1000eb3,       asterisk			]};
-    key <AD04> { [ 0x1000e9e,       underscore             	]};
-    key <AD05> { [ 0x1000eb0,       plus                	]};
+    key <AD03> { [ 0x1000eb3,        asterisk			]};
+    key <AD04> { [ 0x1000e9e,      underscore			]};
+    key <AD05> { [ 0x1000eb0,            plus			]};
     key <AD06> { [ 0x1000eb4					]};
     key <AD07> { [ 0x1000eb5					]};
-    key <AD08> { [ 0x1000eae,       0x1000ea3	                ]};
+    key <AD08> { [ 0x1000eae,       0x1000ea3			]};
     key <AD09> { [ 0x1000e99,       0x1000edc			]};
     key <AD10> { [ 0x1000e8d,       0x1000ebd			]};
-    key <AD11> { [ 0x1000e9a,       minus			]};
-    key <AD12> { [ 0x1000ea5        				]};
-    key <BKSL> { [     slash,       backslash	                ]};
+    key <AD11> { [ 0x1000e9a,           minus			]};
+    key <AD12> { [ 0x1000ea5					]};
+    key <BKSL> { [     slash,       backslash			]};
 
-    key <AC01> { [ 0x1000eb1        		]};
+    key <AC01> { [ 0x1000eb1			]};
     key <AC02> { [ 0x1000eab,       semicolon	]};
-    key <AC03> { [ 0x1000e81,       period	]};
-    key <AC04> { [ 0x1000e94,       comma	]};
-    key <AC05> { [ 0x1000ec0,       colon	]};
+    key <AC03> { [ 0x1000e81,          period	]};
+    key <AC04> { [ 0x1000e94,           comma	]};
+    key <AC05> { [ 0x1000ec0,           colon	]};
     key <AC06> { [ 0x1000ec9,       0x1000eca	]};
     key <AC07> { [ 0x1000ec8,       0x1000ecb	]};
-    key <AC08> { [ 0x1000eb2,       exclam	]};
-    key <AC09> { [ 0x1000eaa,       question	]};
-    key <AC10> { [ 0x1000ea7,       percent	]};
-    key <AC11> { [ 0x1000e87,       equal	]};
+    key <AC08> { [ 0x1000eb2,          exclam	]};
+    key <AC09> { [ 0x1000eaa,        question	]};
+    key <AC10> { [ 0x1000ea7,         percent	]};
+    key <AC11> { [ 0x1000e87,           equal	]};
 
     key <AB01> { [ 0x1000e9c,       0x10020ad	]};
     key <AB02> { [ 0x1000e9b,       parenleft	]};
     key <AB03> { [ 0x1000ec1,       0x1000eaf	]};
-    key <AB04> { [ 0x1000ead,       x		]};
+    key <AB04> { [ 0x1000ead,               x	]};
     key <AB05> { [ 0x1000eb6			]};
     key <AB06> { [ 0x1000eb7			]};
     key <AB07> { [ 0x1000e97,       0x1000ec6	]};
     key <AB08> { [ 0x1000ea1,       0x1000edd	]};
-    key <AB09> { [ 0x1000ec3,       dollar	]};
-    key <AB10> { [ 0x1000e9d,       parenright	]};
+    key <AB09> { [ 0x1000ec3,          dollar	]};
+    key <AB10> { [ 0x1000e9d,      parenright	]};
 
-    key <SPCE> { [ space, nobreakspace, nobreakspace		]};
+    key <SPCE> { [     space,    nobreakspace,    nobreakspace	]};
 
-    key <KPDL> { [     comma,       period 			]};
+    key <KPDL> { [     comma,          period 			]};
 
     include "level3(ralt_switch)"
 };
diff --git a/xorg-server/xkeyboard-config/types/README b/xorg-server/xkeyboard-config/types/README
index 1a1e2c01e..ff0f61b9d 100644
--- a/xorg-server/xkeyboard-config/types/README
+++ b/xorg-server/xkeyboard-config/types/README
@@ -1,4 +1,4 @@
 The types component of a keyboard mapping specifies the key types that can be
-associated with the various keyboard keys. The types component can also
-optionally contain real modifiers binding and symbolic names for one
-or more virtual modifiers.
+associated with the various keyboard keys. The types component can optionally
+contain also real modifier bindings and symbolic names for one or more virtual
+modifiers.
diff --git a/xorg-server/xkeyboard-config/types/basic b/xorg-server/xkeyboard-config/types/basic
index 552b83400..341931fe5 100644
--- a/xorg-server/xkeyboard-config/types/basic
+++ b/xorg-server/xkeyboard-config/types/basic
@@ -1,7 +1,7 @@
 default xkb_types "basic" {
 
     // Fairly standard definitions for
-    // the four required key types
+    // the three required key types.
 
     virtual_modifiers NumLock;
 
@@ -19,11 +19,11 @@ default xkb_types "basic" {
     };
 
     type "ALPHABETIC" {
-        modifiers = Shift+Lock;
-        map[Shift] = Level2;
-        map[Lock] = Level2;
-        level_name[Level1] = "Base";
-        level_name[Level2] = "Caps";
+	modifiers = Shift+Lock;
+	map[Shift] = Level2;
+	map[Lock] = Level2;
+	level_name[Level1] = "Base";
+	level_name[Level2] = "Caps";
     };
 
 };
diff --git a/xorg-server/xkeyboard-config/types/caps b/xorg-server/xkeyboard-config/types/caps
index dd7fa2eaf..baff8c4f8 100644
--- a/xorg-server/xkeyboard-config/types/caps
+++ b/xorg-server/xkeyboard-config/types/caps
@@ -1,5 +1,5 @@
-// CapsLock uses internal capitalization rules
-// Shift "pauses" CapsLock
+// CapsLock uses internal capitalization rules,
+// Shift "pauses" CapsLock.
 partial xkb_types "internal" {
     type "ALPHABETIC" {
 	modifiers = Shift+Lock;
@@ -17,7 +17,7 @@ partial xkb_types "internal" {
 	map[LevelThree] = Level3;
 	map[Shift+LevelThree] = Level4;
 	map[Lock+LevelThree] =  Level3;
-        map[Lock+Shift+LevelThree] = Level3;
+	map[Lock+Shift+LevelThree] = Level3;
 	preserve[Lock+LevelThree] = Lock;
 	level_name[Level1] = "Base";
 	level_name[Level2] = "Shift";
@@ -33,7 +33,7 @@ partial xkb_types "internal" {
 	map[LevelThree] = Level3;
 	map[Shift+LevelThree] = Level4;
 	map[Lock+LevelThree] =  Level3;
-        map[Lock+Shift+LevelThree] = Level4;
+	map[Lock+Shift+LevelThree] = Level4;
 	preserve[Lock+LevelThree] = Lock;
 	preserve[Lock+Shift+LevelThree] = Lock;
 	level_name[Level1] = "Base";
@@ -42,8 +42,9 @@ partial xkb_types "internal" {
 	level_name[Level4] = "Shift Alt";
     };
 };
-// CapsLock uses internal capitalization rules
-// Shift doesn't cancel CapsLock
+
+// CapsLock uses internal capitalization rules,
+// Shift doesn't cancel CapsLock.
 partial xkb_types "internal_nocancel" {
     type "ALPHABETIC" {
 	modifiers = Shift;
@@ -77,8 +78,9 @@ partial xkb_types "internal_nocancel" {
 	level_name[Level4] = "Shift Alt";
     };
 };
-// CapsLock acts as Shift with locking
-// Shift "pauses" CapsLock
+
+// CapsLock acts as Shift with locking,
+// Shift "pauses" CapsLock.
 partial xkb_types "shift" {
     type "ALPHABETIC" {
 	modifiers = Shift+Lock;
@@ -111,7 +113,7 @@ partial xkb_types "shift" {
 	map[LevelThree] = Level3;
 	map[Shift+LevelThree] = Level4;
 	map[Lock+LevelThree] =  Level3;
-        map[Lock+Shift+LevelThree] = Level4;
+	map[Lock+Shift+LevelThree] = Level4;
 	preserve[Lock+LevelThree] = Lock;
 	preserve[Lock+Shift+LevelThree] = Lock;
 	level_name[Level1] = "Base";
@@ -120,8 +122,9 @@ partial xkb_types "shift" {
 	level_name[Level4] = "Shift Alt";
     };
 };
-// CapsLock acts as Shift with locking
-// Shift doesn't cancel CapsLock
+
+// CapsLock acts as Shift with locking,
+// Shift doesn't cancel CapsLock.
 partial xkb_types "shift_nocancel" {
     type "ALPHABETIC" {
 	modifiers = Shift+Lock;
@@ -157,7 +160,7 @@ partial xkb_types "shift_nocancel" {
 	map[LevelThree] = Level3;
 	map[Shift+LevelThree] = Level4;
 	map[Lock+LevelThree] =  Level3;
-        map[Lock+Shift+LevelThree] = Level4;
+	map[Lock+Shift+LevelThree] = Level4;
 	preserve[Lock+LevelThree] = Lock;
 	preserve[Lock+Shift+LevelThree] = Lock;
 	level_name[Level1] = "Base";
diff --git a/xorg-server/xkeyboard-config/types/extra b/xorg-server/xkeyboard-config/types/extra
index 465796b53..e7529f40d 100644
--- a/xorg-server/xkeyboard-config/types/extra
+++ b/xorg-server/xkeyboard-config/types/extra
@@ -1,20 +1,20 @@
 partial default xkb_types "default" {
-    // Definition for a key type used for the czech keymap, for instance.
-    // Defines style a with four level shift. It is similar to three_level
-    // type used for iso9995 but it lets the shift key behave "normally".
+
+    // Defines a type with a four-level shift, similar to the three-level
+    // type used for iso9995, but it lets the Shift key behave "normally".
 
     virtual_modifiers LevelThree;
 
     type "FOUR_LEVEL" {
-        modifiers = Shift+LevelThree;
+	modifiers = Shift+LevelThree;
 	map[None] = Level1;
 	map[Shift] = Level2;
 	map[LevelThree] = Level3;
 	map[Shift+LevelThree] = Level4;
 	level_name[Level1] = "Base";
 	level_name[Level2] = "Shift";
-	level_name[Level3] = "Alt Base";  
-	level_name[Level4] = "Shift Alt";  
+	level_name[Level3] = "Alt Base";
+	level_name[Level4] = "Shift Alt";
     };
 
     type "FOUR_LEVEL_ALPHABETIC" {
@@ -40,7 +40,7 @@ partial default xkb_types "default" {
 	map[LevelThree] = Level3;
 	map[Shift+LevelThree] = Level4;
 	map[Lock+LevelThree] =  Level3;
-        map[Lock+Shift+LevelThree] = Level4;
+	map[Lock+Shift+LevelThree] = Level4;
 	preserve[Lock+LevelThree] = Lock;
 	preserve[Lock+Shift+LevelThree] = Lock;
 	level_name[Level1] = "Base";
@@ -49,11 +49,9 @@ partial default xkb_types "default" {
 	level_name[Level4] = "Shift Alt";
     };
 
-    // Another four level keypad variant
-    // First two levels are controled by NumLock (with active Shift-ing like
-    // in KEYPAD). LevelThree overrides this mode, with two additional
-    // Shift-ed levels
-    // NumLock state is intentionnaly ignored when LevelThree is active
+    // A four-level keypad variant. The first two levels are controlled by
+    // NumLock (with active shifting like in KEYPAD).  LevelThree overrides
+    // this mode, with two additional shifted levels.
     type "FOUR_LEVEL_MIXED_KEYPAD" {
         modifiers = Shift+NumLock+LevelThree;
         map[None] = Level1;
@@ -61,32 +59,32 @@ partial default xkb_types "default" {
         map[NumLock] = Level2;
         map[Shift] = Level2;
         map[LevelThree] = Level3;
-	map[NumLock+LevelThree] = Level3;
+        map[NumLock+LevelThree] = Level3;
         map[Shift+LevelThree] = Level4;
-	map[Shift+NumLock+LevelThree] = Level4;
+        map[Shift+NumLock+LevelThree] = Level4;
         level_name[Level1] = "Base";
         level_name[Level2] = "Number";
         level_name[Level3] = "Alt Base";
         level_name[Level4] = "Shift Alt";
     };
 
-    // Base level, two Shift-ed LevelThree levels, one Ctrl+Alt command level
+    // Base level, two shifted LevelThree levels, one Ctrl+Alt command level.
     type "FOUR_LEVEL_X" {
         modifiers = Shift+LevelThree+Control+Alt;
         map[None] = Level1;
         map[LevelThree] = Level2;
-	map[Shift+LevelThree] = Level3;
-	map[Control+Alt] = Level4;
+        map[Shift+LevelThree] = Level3;
+        map[Control+Alt] = Level4;
         level_name[Level1] = "Base";
         level_name[Level2] = "Alt Base";
         level_name[Level3] = "Shift Alt";
-	level_name[Level4] = "Ctrl+Alt";
+        level_name[Level4] = "Ctrl+Alt";
     };
 
-// Special type for keys used in Serbian Latin Unicode map
-// It makes it possible to use all three forms of latin letters 
-// present in Unicode that are made up of two separate letters 
-// (forms like LJ, Lj, and lj; NJ, Nj, and nj; etc)
+// A special type for keys used in the Serbian Latin Unicode keymap.
+// It makes it possible to use all three forms of latin letters
+// present in Unicode that are made up of two separate letters
+// (forms like LJ, Lj, and lj; NJ, Nj, and nj; etcetera).
 
     type "SEPARATE_CAPS_AND_SHIFT_ALPHABETIC" {
         modifiers = Shift+Lock+LevelThree;
@@ -105,21 +103,20 @@ partial default xkb_types "default" {
         level_name[Level4] = "Shift AltGr";
     };
 
-// type for e.g. german ssharp which is capitalized SS.
+// A key type for the German ssharp (for example), which is capitalized as SS.
 // CHARACTERISTICS:
-// It is FOUR_LEVEL with the exception that the fifth level
-// is mapped to the Lock modifier.
-// If other modifiers are used, the Lock state is ignored.
+// It is FOUR_LEVEL with the exception that the fifth level is mapped to the
+// Lock modifier.  If other modifiers are used, the Lock state is ignored.
 // DETAILS ABOUT GERMAN:
-// The capital form of ssharp (called sharp s) only exists for
-// completely capitalized Text, not at the beginning of sentences
-// or nouns (nouns have a captial letter at the beginning in german).
-// The ssharp key, to the right of the zero key, takes this into
-// account and has a questionmark mapped on shift-ssharp since
-// normally no capital version is needed.
-// When typing with active capsLock, this key type is needed to
-// output two capital letters S because this is the only german key
-// whose capital letter is not the same as the one typed with shift.
+// The capital form of ssharp (called sharp s) only exists for completely
+// capitalized text, not for words at the beginning of sentences nor for
+// nouns (nouns in German normally start with a captial letter).
+// The ssharp key, to the right of the zero key, takes this into account
+// and has a questionmark mapped to Shift-ssharp since normally no capital
+// version is needed.
+// When typing with active CapsLock, this key type is needed to
+// output two capital letters S because this is the only German key
+// whose capital letter is not the same as the one typed with Shift.
 
     type "FOUR_LEVEL_PLUS_LOCK" {
         modifiers = Shift+Lock+LevelThree;
@@ -139,7 +136,7 @@ partial default xkb_types "default" {
     };
 };
 
-// This enables the four level shifting also for the keypad.
+// This enables the four-level shifting also for the keypad.
 partial xkb_types "keypad" {
     virtual_modifiers LevelThree;
 
@@ -157,5 +154,5 @@ partial xkb_types "keypad" {
 	level_name[Level2] = "Number";
 	level_name[Level3] = "Alt Base";
 	level_name[Level4] = "Alt Number";
-    };       
+    };
 };
diff --git a/xorg-server/xkeyboard-config/types/iso9995 b/xorg-server/xkeyboard-config/types/iso9995
index 0cf34203c..d3c4e0bf6 100644
--- a/xorg-server/xkeyboard-config/types/iso9995
+++ b/xorg-server/xkeyboard-config/types/iso9995
@@ -1,8 +1,8 @@
 partial default xkb_types "default" {
 
-    // Definition for a key type which 
-    // can be used to implement ISO9995
-    // style level three shift
+    // A key type which can be used to implement
+    // an ISO9995-style level-three shift.
+
     virtual_modifiers LevelThree;
 
     type "THREE_LEVEL" {
diff --git a/xorg-server/xkeyboard-config/types/level5 b/xorg-server/xkeyboard-config/types/level5
index 672f0a1b3..1796f502d 100644
--- a/xorg-server/xkeyboard-config/types/level5
+++ b/xorg-server/xkeyboard-config/types/level5
@@ -1,12 +1,12 @@
 partial default xkb_types "default" {
-    // Definition for a key type used for the czech keymap, for instance.
-    // Defines style a with four level shift. It is similar to three_level
-    // type used for iso9995 but it lets the shift key behave "normally".
+
+    // Defines a type with an eight-level shift, similar to the three-level
+    // type used for iso9995, but it lets the Shift key behave "normally".
 
     virtual_modifiers LevelThree,ScrollLock,LevelFive;
 
     type "EIGHT_LEVEL" {
-        modifiers = Shift+LevelThree+LevelFive;
+	modifiers = Shift+LevelThree+LevelFive;
 	map[None] = Level1;
 	map[Shift] = Level2;
 	map[LevelThree] = Level3;
@@ -17,8 +17,8 @@ partial default xkb_types "default" {
 	map[Shift+LevelThree+LevelFive] = Level8;
 	level_name[Level1] = "Base";
 	level_name[Level2] = "Shift";
-	level_name[Level3] = "Alt Base";  
-	level_name[Level4] = "Shift Alt";  
+	level_name[Level3] = "Alt Base";
+	level_name[Level4] = "Shift Alt";
 	level_name[Level5] = "X";
 	level_name[Level6] = "X Shift";
 	level_name[Level7] = "X Alt Base";
@@ -33,7 +33,7 @@ partial default xkb_types "default" {
 	map[LevelThree] = Level3;
 	map[Shift+LevelThree] = Level4;
 	map[Lock+LevelThree] =  Level4;
-        map[Lock+Shift+LevelThree] = Level3;
+	map[Lock+Shift+LevelThree] = Level3;
 
 	map[LevelFive] = Level5;
 	map[Shift+LevelFive] = Level6;
@@ -41,7 +41,7 @@ partial default xkb_types "default" {
 	map[LevelThree+LevelFive] = Level7;
 	map[Shift+LevelThree+LevelFive] = Level8;
 	map[Lock+LevelThree+LevelFive] =  Level8;
-        map[Lock+Shift+LevelThree+LevelFive] = Level7;
+	map[Lock+Shift+LevelThree+LevelFive] = Level7;
 
 	level_name[Level1] = "Base";
 	level_name[Level2] = "Shift";
@@ -54,9 +54,9 @@ partial default xkb_types "default" {
     };
 
 //    type "EIGHT_LEVEL_LEVEL_FIVE_LOCK" {
-//    	// Level5-Lock is implemented by using NumLock, because a real modifier
-//    	// is required.
-//    	
+//      // Level5-Lock is implemented by using NumLock, because a real modifier
+//      // is required.
+//
 //        modifiers = Shift + Lock + LevelThree + NumLock + LevelFive;
 //
 //        map[None]                                    = Level1;
@@ -116,11 +116,11 @@ partial default xkb_types "default" {
 //    };
 //
 //    type "EIGHT_LEVEL_ALPHABETIC_LEVEL_FIVE_LOCK" {
-//    	// Level5-Lock is implemented by using NumLock, because a real modifier
-//    	// is required.
-//    	
+//      // Level5-Lock is implemented by using NumLock, because a real modifier
+//      // is required.
+//
 //        modifiers = Shift + Lock + LevelThree + NumLock + LevelFive;
-//    
+//
 //        map[None]                                    = Level1;
 //        map[Shift]                                   = Level2;
 //        map[LevelThree]                              = Level3;
@@ -183,7 +183,7 @@ partial default xkb_types "default" {
 	map[LevelThree] = Level3;
 	map[Shift+LevelThree] = Level4;
 	map[Lock+LevelThree] =  Level3;
-        map[Lock+Shift+LevelThree] = Level4;
+	map[Lock+Shift+LevelThree] = Level4;
 
 	map[LevelFive] = Level5;
 	map[Shift+LevelFive] = Level6;
@@ -192,7 +192,7 @@ partial default xkb_types "default" {
 	map[LevelThree+LevelFive] = Level7;
 	map[Shift+LevelThree+LevelFive] = Level8;
 	map[Lock+LevelThree+LevelFive] =  Level7;
-        map[Lock+Shift+LevelThree+LevelFive] = Level8;
+	map[Lock+Shift+LevelThree+LevelFive] = Level8;
 
 	preserve[Lock+LevelThree] = Lock;
 	preserve[Lock+Shift+LevelThree] = Lock;
diff --git a/xorg-server/xkeyboard-config/types/mousekeys b/xorg-server/xkeyboard-config/types/mousekeys
index 88d88a21e..901848aa3 100644
--- a/xorg-server/xkeyboard-config/types/mousekeys
+++ b/xorg-server/xkeyboard-config/types/mousekeys
@@ -2,9 +2,9 @@ partial default xkb_types "default" {
     virtual_modifiers Alt;
 
     type "SHIFT+ALT" {
-   	modifiers = Shift+Alt;
-    	map[Shift+Alt] = Level2;
-    	level_name[Level1] = "Base";
+	modifiers = Shift+Alt;
+	map[Shift+Alt] = Level2;
+	level_name[Level1] = "Base";
 	level_name[Level2] = "Shift+Alt";
     };
 };
diff --git a/xorg-server/xkeyboard-config/types/nokia b/xorg-server/xkeyboard-config/types/nokia
index f77d8868a..300fe4169 100644
--- a/xorg-server/xkeyboard-config/types/nokia
+++ b/xorg-server/xkeyboard-config/types/nokia
@@ -1,6 +1,7 @@
 partial default xkb_types "default" {
 
-    // Some types that are used by Nokia devices and keyboard.
+    // A type that is used by Nokia devices and keyboards.
+
     virtual_modifiers LevelThree;
 
     type "PC_FN_LEVEL2" {
diff --git a/xorg-server/xkeyboard-config/types/numpad b/xorg-server/xkeyboard-config/types/numpad
index 7888d7db1..5861f118a 100644
--- a/xorg-server/xkeyboard-config/types/numpad
+++ b/xorg-server/xkeyboard-config/types/numpad
@@ -11,7 +11,7 @@ partial default xkb_types "pc" {
     include "extra(keypad)"
 };
 
-// On Mac keypads, level 1 and 2 are swapped
+// On Mac keypads, level 1 and 2 are swapped.
 partial xkb_types "mac" {
     type "KEYPAD" {
 	modifiers = None;
@@ -33,11 +33,11 @@ partial xkb_types "microsoft" {
     include "extra(keypad)"
 };
 
-// Swiss-German style numeric keypad: Shift and NumLock operates as
+// Swiss-German style numeric keypad: Shift and NumLock operate as
 // two independent modifiers; however, since we want shift state for
 // the cursor keys, only three levels are used from the key mappings.
-// Closest type is actually FOUR_LEVEL_X, but most numpad layouts uses
-// FOUR_LEVEL_MIXED_KEYPAD so that's the one we are going to override.
+// Closest type is actually FOUR_LEVEL_X, but most numpad layouts use
+// FOUR_LEVEL_MIXED_KEYPAD, so that's the one we are going to override.
 partial xkb_types "shift3" {
     type "FOUR_LEVEL_MIXED_KEYPAD" {
         modifiers = Shift+NumLock+Control+Alt;
diff --git a/xorg-server/xkeyboard-config/types/pc b/xorg-server/xkeyboard-config/types/pc
index daebe7442..17e494b30 100644
--- a/xorg-server/xkeyboard-config/types/pc
+++ b/xorg-server/xkeyboard-config/types/pc
@@ -2,7 +2,8 @@ partial default xkb_types "default" {
 
     // Some types that are necessary
     // for a full implementation of
-    // a PC compatible keyboard.
+    // a PC-compatible keyboard.
+
     virtual_modifiers Alt;
     virtual_modifiers LevelThree;
     virtual_modifiers LAlt;
@@ -74,13 +75,13 @@ partial default xkb_types "default" {
         level_name[Level5] = "Ctrl+Alt";
     };
 
-   // Local eight level
-   // Needed when you want part of your layout eight-level but can not use
-   // LevelFive as modifier, as this will take over right ctrl by default
-   // for all the layout and is too invasive for your average four-level user
-   // Needed to fix bug #9529
-   // FIXME Should really use RControl but it's seems not to be enabled by
-   // default and touching this requires a lot of testing
+   // Local eight level.
+   // Needed when you want part of your layout eight-level but cannot use
+   // LevelFive as modifier, as this will take over the right Ctrl by default
+   // for the whole layout and is too invasive for the average four-level user.
+   // Needed to fix bug #9529.
+   // FIXME: Should really use RControl but it seems not to be enabled by
+   // default and touching this requires a lot of testing.
    type "LOCAL_EIGHT_LEVEL" {
 	modifiers = Shift+Lock+LevelThree+Control;