Drop trailing whitespaces

sed -i "s/[ ]\+$//g" **/*.(c|h)

happy reviewing...
git diff -w is an empty diff.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

5 files changed, 56 insertions, 56 deletions

diff --git a/hw/xfree86/x86emu/debug.c b/hw/xfree86/x86emu/debug.c
index 1a8d1d6c4..cbea9947f 100644
--- a/hw/xfree86/x86emu/debug.c
+++ b/hw/xfree86/x86emu/debug.c
@@ -103,11 +103,11 @@ disassemble_forward(u16 seg, u16 off, int n)
      * SINGLE_STEP(r,m); which disappear if DEBUG is not defined to
      * the preprocessor.  The TRACE_REGS macro expands to:
      *
-     * if (debug&DEBUG_DISASSEMBLE) 
+     * if (debug&DEBUG_DISASSEMBLE)
      *     {just_disassemble(); goto EndOfInstruction;}
      *     if (debug&DEBUG_TRACE) trace_regs(r,m);
      *
-     * ......  and at the last line of the routine. 
+     * ......  and at the last line of the routine.
      *
      * EndOfInstruction: end_instr();
      *
diff --git a/hw/xfree86/x86emu/ops.c b/hw/xfree86/x86emu/ops.c
index b50badb28..853792e7e 100644
--- a/hw/xfree86/x86emu/ops.c
+++ b/hw/xfree86/x86emu/ops.c
@@ -5530,7 +5530,7 @@ x86emuOp_opc80_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
     if (DEBUG_DECODE()) {
         /* XXX DECODE_PRINTF may be changed to something more
            general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
+           in the same format, even though the result is that the
            above test is done twice. */
 
         switch (rh) {
@@ -5658,7 +5658,7 @@ x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
     if (DEBUG_DECODE()) {
         /* XXX DECODE_PRINTF may be changed to something more
            general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
+           in the same format, even though the result is that the
            above test is done twice. */
 
         switch (rh) {
@@ -5690,7 +5690,7 @@ x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
     }
 #endif
     /*
-     * Know operation, decode the mod byte to find the addressing 
+     * Know operation, decode the mod byte to find the addressing
      * mode.
      */
     switch (mod) {
@@ -5853,7 +5853,7 @@ x86emuOp_opc82_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
     if (DEBUG_DECODE()) {
         /* XXX DECODE_PRINTF may be changed to something more
            general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
+           in the same format, even though the result is that the
            above test is done twice. */
         switch (rh) {
         case 0:
@@ -5977,7 +5977,7 @@ x86emuOp_opc83_word_RM_IMM(u8 X86EMU_UNUSED(op1))
     if (DEBUG_DECODE()) {
         /* XXX DECODE_PRINTF may be changed to something more
            general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
+           in the same format, even though the result is that the
            above test is done twice. */
         switch (rh) {
         case 0:
@@ -7472,7 +7472,7 @@ x86emuOp_call_far_IMM(u8 X86EMU_UNUSED(op1))
     CALL_TRACE(M.x86.saved_cs, M.x86.saved_ip, farseg, faroff, "FAR ");
 
     /* XXX
-     * 
+     *
      * Hooked interrupt vectors calling into our "BIOS" will cause
      * problems unless all intersegment stuff is checked for BIOS
      * access.  Check needed here.  For moment, let it alone.
@@ -8688,7 +8688,7 @@ x86emuOp_opcC0_byte_RM_MEM(u8 X86EMU_UNUSED(op1))
     if (DEBUG_DECODE()) {
         /* XXX DECODE_PRINTF may be changed to something more
            general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
+           in the same format, even though the result is that the
            above test is done twice. */
 
         switch (rh) {
@@ -8797,7 +8797,7 @@ x86emuOp_opcC1_word_RM_MEM(u8 X86EMU_UNUSED(op1))
     if (DEBUG_DECODE()) {
         /* XXX DECODE_PRINTF may be changed to something more
            general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
+           in the same format, even though the result is that the
            above test is done twice. */
 
         switch (rh) {
@@ -9700,7 +9700,7 @@ x86emuOp_opcD2_byte_RM_CL(u8 X86EMU_UNUSED(op1))
     if (DEBUG_DECODE()) {
         /* XXX DECODE_PRINTF may be changed to something more
            general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
+           in the same format, even though the result is that the
            above test is done twice. */
         switch (rh) {
         case 0:
@@ -9795,7 +9795,7 @@ x86emuOp_opcD3_word_RM_CL(u8 X86EMU_UNUSED(op1))
     if (DEBUG_DECODE()) {
         /* XXX DECODE_PRINTF may be changed to something more
            general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
+           in the same format, even though the result is that the
            above test is done twice. */
         switch (rh) {
         case 0:
@@ -11538,7 +11538,7 @@ x86emuOp_opcFE_byte_RM(u8 X86EMU_UNUSED(op1))
     if (DEBUG_DECODE()) {
         /* XXX DECODE_PRINTF may be changed to something more
            general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
+           in the same format, even though the result is that the
            above test is done twice. */
 
         switch (rh) {
diff --git a/hw/xfree86/x86emu/prim_ops.c b/hw/xfree86/x86emu/prim_ops.c
index 24f76b47f..5604c7e81 100644
--- a/hw/xfree86/x86emu/prim_ops.c
+++ b/hw/xfree86/x86emu/prim_ops.c
@@ -883,9 +883,9 @@ rcl_byte(u8 d, u8 s)
     /* s is the rotate distance.  It varies from 0 - 8. */
     /* have
 
-       CF  B_7 B_6 B_5 B_4 B_3 B_2 B_1 B_0 
+       CF  B_7 B_6 B_5 B_4 B_3 B_2 B_1 B_0
 
-       want to rotate through the carry by "s" bits.  We could 
+       want to rotate through the carry by "s" bits.  We could
        loop, but that's inefficient.  So the width is 9,
        and we split into three parts:
 
@@ -895,12 +895,12 @@ rcl_byte(u8 d, u8 s)
 
        The new rotate is done mod 9, and given this,
        for a rotation of n bits (mod 9) the new carry flag is
-       then located n bits from the MSB.  The low part is 
+       then located n bits from the MSB.  The low part is
        then shifted up cnt bits, and the high part is or'd
-       in.  Using CAPS for new values, and lowercase for the 
+       in.  Using CAPS for new values, and lowercase for the
        original values, this can be expressed as:
 
-       IF n > 0 
+       IF n > 0
        1) CF <-  b_(8-n)
        2) B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_0
        3) B_(n-1) <- cf
@@ -912,17 +912,17 @@ rcl_byte(u8 d, u8 s)
         /* CF <-  b_(8-n)             */
         cf = (d >> (8 - cnt)) & 0x1;
 
-        /* get the low stuff which rotated 
+        /* get the low stuff which rotated
            into the range B_7 .. B_cnt */
         /* B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_0  */
         /* note that the right hand side done by the mask */
         res = (d << cnt) & 0xff;
 
-        /* now the high stuff which rotated around 
+        /* now the high stuff which rotated around
            into the positions B_cnt-2 .. B_0 */
         /* B_(n-2) .. B_0 <-  b_7 .. b_(8-(n-1)) */
-        /* shift it downward, 7-(n-2) = 9-n positions. 
-           and mask off the result before or'ing in. 
+        /* shift it downward, 7-(n-2) = 9-n positions.
+           and mask off the result before or'ing in.
          */
         mask = (1 << (cnt - 1)) - 1;
         res |= (d >> (9 - cnt)) & mask;
@@ -934,7 +934,7 @@ rcl_byte(u8 d, u8 s)
         }
         /* set the new carry flag, based on the variable "cf" */
         CONDITIONAL_SET_FLAG(cf, F_CF);
-        /* OVERFLOW is set *IFF* cnt==1, then it is the 
+        /* OVERFLOW is set *IFF* cnt==1, then it is the
            xor of CF and the most significant bit.  Blecck. */
         /* parenthesized this expression since it appears to
            be causing OF to be misset */
@@ -1003,22 +1003,22 @@ rcr_byte(u8 d, u8 s)
     u32 mask, cf, ocf = 0;
 
     /* rotate right through carry */
-    /* 
+    /*
        s is the rotate distance.  It varies from 0 - 8.
-       d is the byte object rotated.  
+       d is the byte object rotated.
 
-       have 
+       have
 
-       CF  B_7 B_6 B_5 B_4 B_3 B_2 B_1 B_0 
+       CF  B_7 B_6 B_5 B_4 B_3 B_2 B_1 B_0
 
        The new rotate is done mod 9, and given this,
        for a rotation of n bits (mod 9) the new carry flag is
-       then located n bits from the LSB.  The low part is 
+       then located n bits from the LSB.  The low part is
        then shifted up cnt bits, and the high part is or'd
-       in.  Using CAPS for new values, and lowercase for the 
+       in.  Using CAPS for new values, and lowercase for the
        original values, this can be expressed as:
 
-       IF n > 0 
+       IF n > 0
        1) CF <-  b_(n-1)
        2) B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_(n)
        3) B_(8-n) <- cf
@@ -1033,7 +1033,7 @@ rcr_byte(u8 d, u8 s)
             /* note hackery here.  Access_flag(..) evaluates to either
                0 if flag not set
                non-zero if flag is set.
-               doing access_flag(..) != 0 casts that into either 
+               doing access_flag(..) != 0 casts that into either
                0..1 in any representation of the flags register
                (i.e. packed bit array or unpacked.)
              */
@@ -1044,19 +1044,19 @@ rcr_byte(u8 d, u8 s)
 
         /* B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_n  */
         /* note that the right hand side done by the mask
-           This is effectively done by shifting the 
+           This is effectively done by shifting the
            object to the right.  The result must be masked,
-           in case the object came in and was treated 
+           in case the object came in and was treated
            as a negative number.  Needed??? */
 
         mask = (1 << (8 - cnt)) - 1;
         res = (d >> cnt) & mask;
 
-        /* now the high stuff which rotated around 
+        /* now the high stuff which rotated around
            into the positions B_cnt-2 .. B_0 */
         /* B_(7) .. B_(8-(n-1)) <-  b_(n-2) .. b_(0) */
-        /* shift it downward, 7-(n-2) = 9-n positions. 
-           and mask off the result before or'ing in. 
+        /* shift it downward, 7-(n-2) = 9-n positions.
+           and mask off the result before or'ing in.
          */
         res |= (d << (9 - cnt));
 
@@ -1067,7 +1067,7 @@ rcr_byte(u8 d, u8 s)
         }
         /* set the new carry flag, based on the variable "cf" */
         CONDITIONAL_SET_FLAG(cf, F_CF);
-        /* OVERFLOW is set *IFF* cnt==1, then it is the 
+        /* OVERFLOW is set *IFF* cnt==1, then it is the
            xor of CF and the most significant bit.  Blecck. */
         /* parenthesized... */
         if (cnt == 1) {
@@ -1154,18 +1154,18 @@ rol_byte(u8 d, u8 s)
     register unsigned int res, cnt, mask;
 
     /* rotate left */
-    /* 
+    /*
        s is the rotate distance.  It varies from 0 - 8.
-       d is the byte object rotated.  
+       d is the byte object rotated.
 
-       have 
+       have
 
-       CF  B_7 ... B_0 
+       CF  B_7 ... B_0
 
        The new rotate is done mod 8.
        Much simpler than the "rcl" or "rcr" operations.
 
-       IF n > 0 
+       IF n > 0
        1) B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_(0)
        2) B_(n-1) .. B_(0) <-  b_(7) .. b_(8-n)
      */
@@ -1256,17 +1256,17 @@ ror_byte(u8 d, u8 s)
     register unsigned int res, cnt, mask;
 
     /* rotate right */
-    /* 
+    /*
        s is the rotate distance.  It varies from 0 - 8.
-       d is the byte object rotated.  
+       d is the byte object rotated.
 
-       have 
+       have
 
-       B_7 ... B_0 
+       B_7 ... B_0
 
        The rotate is done mod 8.
 
-       IF n > 0 
+       IF n > 0
        1) B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_(n)
        2) B_(7) .. B_(8-n) <-  b_(n-1) .. b_(0)
      */
@@ -1279,7 +1279,7 @@ ror_byte(u8 d, u8 s)
         mask = (1 << (8 - cnt)) - 1;
         res |= (d >> (cnt)) & mask;
 
-        /* set the new carry flag, Note that it is the low order 
+        /* set the new carry flag, Note that it is the low order
            bit of the result!!!                               */
         CONDITIONAL_SET_FLAG(res & 0x80, F_CF);
         /* OVERFLOW is set *IFF* s==1, then it is the
diff --git a/hw/xfree86/x86emu/sys.c b/hw/xfree86/x86emu/sys.c
index c514ddeea..5eba35856 100644
--- a/hw/xfree86/x86emu/sys.c
+++ b/hw/xfree86/x86emu/sys.c
@@ -183,7 +183,7 @@ RETURNS:
 Byte value read from emulator memory.
 
 REMARKS:
-Reads a byte value from the emulator memory. 
+Reads a byte value from the emulator memory.
 ****************************************************************************/
 u8 X86API
 rdb(u32 addr)
@@ -241,7 +241,7 @@ addr	- Emulator memory address to read
 RETURNS:
 Long value read from emulator memory.
 REMARKS:
-Reads a long value from the emulator memory. 
+Reads a long value from the emulator memory.
 ****************************************************************************/
 u32 X86API
 rdl(u32 addr)
@@ -323,7 +323,7 @@ addr	- Emulator memory address to read
 val		- Value to store
 
 REMARKS:
-Writes a long value to emulator memory. 
+Writes a long value to emulator memory.
 ****************************************************************************/
 void X86API
 wrl(u32 addr, u32 val)
diff --git a/hw/xfree86/x86emu/x86emu/regs.h b/hw/xfree86/x86emu/x86emu/regs.h
index 3a7456e4c..c040259fa 100644
--- a/hw/xfree86/x86emu/x86emu/regs.h
+++ b/hw/xfree86/x86emu/x86emu/regs.h
@@ -109,7 +109,7 @@ struct i386_special_regs {
     u32 FLAGS;
 };
 
-/*  
+/*
  * Segment registers here represent the 16 bit quantities
  * CS, DS, ES, SS.
  */
@@ -196,8 +196,8 @@ struct i386_segment_regs {
 #define F_ALWAYS_ON  (0x0002)   /* flag bits always on */
 
 /*
- * Define a mask for only those flag bits we will ever pass back 
- * (via PUSHF) 
+ * Define a mask for only those flag bits we will ever pass back
+ * (via PUSHF)
  */
 #define F_MSK (FB_CF|FB_PF|FB_AF|FB_ZF|FB_SF|FB_TF|FB_IF|FB_DF|FB_OF)
 
@@ -279,8 +279,8 @@ typedef struct {
      *  Delayed flag set        3 bits  (zero, signed, parity)
      *  reserved                6 bits
      *  interrupt #             8 bits  instruction raised interrupt
-     *  BIOS video segregs      4 bits  
-     *  Interrupt Pending       1 bits  
+     *  BIOS video segregs      4 bits
+     *  Interrupt Pending       1 bits
      *  Extern interrupt        1 bits
      *  Halted                  1 bits
      */