janitor: stick to kernel-style formattingalpha-1

With this commit, the whole code base complies with the
kernel format style, and patches can be checked against
the kernel-provided ./scripts/checkpatch.pl

15 files changed, 73 insertions, 201 deletions

diff --git a/src/capabilities.c b/src/capabilities.c
index 201c127..cdd05c5 100644
--- a/src/capabilities.c
+++ b/src/capabilities.c
@@ -21,15 +21,11 @@
 
 #include "capabilities.h"
 
-////////////////////////////////////////////////////////
-
 #define SETABS(c, x, map, key, fd)                                      \
-        c->has_##x = getbit(map, key) && getabs(&c->abs_##x, key, fd)
+        (c->has_##x = getbit(map, key) && getabs(&c->abs_##x, key, fd))
 
 #define ADDCAP(s, c, x) strcat(s, c->has_##x ? " " #x : "")
 
-////////////////////////////////////////////////////////
-
 static const int bits_per_long = 8 * sizeof(long);
 
 static inline int nlongs(int nbit)
@@ -37,20 +33,18 @@ static inline int nlongs(int nbit)
         return (nbit + bits_per_long - 1) / bits_per_long;
 }
 
-static inline bool getbit(const unsigned long* map, int key)
+static inline int getbit(const unsigned long *map, int key)
 {
         return (map[key / bits_per_long] >> (key % bits_per_long)) & 0x01;
 }
 
-static bool getabs(struct input_absinfo *abs, int key, int fd)
+static int getabs(struct input_absinfo *abs, int key, int fd)
 {
         int rc;
         SYSCALL(rc = ioctl(fd, EVIOCGABS(key), abs));
         return rc >= 0;
 }
 
-////////////////////////////////////////////////////////
-
 int read_capabilities(struct Capabilities *cap, int fd)
 {
         unsigned long evbits[nlongs(EV_MAX)];
@@ -87,8 +81,6 @@ int read_capabilities(struct Capabilities *cap, int fd)
         return 0;
 }
 
-////////////////////////////////////////////////////////
-
 void output_capabilities(const struct Capabilities *cap)
 {
         char line[1024];
@@ -126,5 +118,3 @@ void output_capabilities(const struct Capabilities *cap)
                         cap->abs_position_y.minimum,
                         cap->abs_position_y.maximum);
 }
-
-////////////////////////////////////////////////////////
diff --git a/src/capabilities.h b/src/capabilities.h
index 63dada5..66ce29b 100644
--- a/src/capabilities.h
+++ b/src/capabilities.h
@@ -24,15 +24,13 @@
 
 #include "common.h"
 
-////////////////////////////////////////////////////////
-
 struct Capabilities {
-        bool has_left, has_middle;
-        bool has_right, has_mtdata;
-        bool has_touch_major, has_touch_minor;
-        bool has_width_major, has_width_minor;
-        bool has_orientation, has_dummy;
-        bool has_position_x, has_position_y;
+        int has_left, has_middle;
+        int has_right, has_mtdata;
+        int has_touch_major, has_touch_minor;
+        int has_width_major, has_width_minor;
+        int has_orientation, has_dummy;
+        int has_position_x, has_position_y;
         struct input_absinfo abs_touch_major;
         struct input_absinfo abs_touch_minor;
         struct input_absinfo abs_width_major;
@@ -42,11 +40,7 @@ struct Capabilities {
         struct input_absinfo abs_position_y;
 };
 
-////////////////////////////////////////////////////////
-
 int read_capabilities(struct Capabilities *cap, int fd);
 void output_capabilities(const struct Capabilities *cap);
 
-////////////////////////////////////////////////////////
-
 #endif
diff --git a/src/common.h b/src/common.h
index b1c3273..f64e114 100644
--- a/src/common.h
+++ b/src/common.h
@@ -30,9 +30,7 @@
 #include <errno.h>
 #include <match/match.h>
 
-////////////////////////////////////////////////////////
-
-// includes available in 2.6.30-rc5
+/* includes available in 2.6.30-rc5 */
 
 #ifndef BTN_TOOL_QUADTAP
 #define BTN_TOOL_QUADTAP        0x14f   /* Four fingers on trackpad */
@@ -50,8 +48,6 @@
 #define MT_TOOL_PEN             1
 #endif
 
-////////////////////////////////////////////////////////
-
 #define SYSCALL(call) while (((call) == -1) && (errno == EINTR))
 
 #define BITMASK(x) (1U << (x))
@@ -60,6 +56,4 @@
 #define SETBIT(m, x) (m |= BITMASK(x))
 #define CLEARBIT(m, x) (m &= ~BITMASK(x))
 
-////////////////////////////////////////////////////////
-
 #endif
diff --git a/src/gestures.c b/src/gestures.c
index 0b0ba1d..2390d35 100644
--- a/src/gestures.c
+++ b/src/gestures.c
@@ -34,7 +34,8 @@ void extract_gestures(struct Gestures *gs, struct MTouch* mt)
         memset(gs, 0, sizeof(struct Gestures));
         if (nof == nsf) {
                 for (p = b; p != e; p++) {
-                        if (fs = find_finger(&mt->os, p->id)) {
+                        fs = find_finger(&mt->os, p->id);
+                        if (fs) {
                                 gs->dx += p->hw.position_x - fs->hw.position_x;
                                 gs->dy += p->hw.position_y - fs->hw.position_y;
                                 dn++;
diff --git a/src/gestures.h b/src/gestures.h
index 0e2a49e..0428195 100644
--- a/src/gestures.h
+++ b/src/gestures.h
@@ -24,25 +24,16 @@
 
 #include "mtouch.h"
 
-////////////////////////////////////////////////////////
-
 #define GS_BUTTON 0
 #define GS_MOVE 1
 #define GS_VSCROLL 2
 #define GS_HSCROLL 3
 
-////////////////////////////////////////////////////////
-
 struct Gestures {
-        unsigned type;
+        unsigned type, btmask, btdata;
         int dx, dy;
-   button_t btmask, btdata;
 };
 
-////////////////////////////////////////////////////////
-
 void extract_gestures(struct Gestures *gs, struct MTouch* mt);
 
-////////////////////////////////////////////////////////
-
 #endif
diff --git a/src/hwdata.c b/src/hwdata.c
index 3b7c41c..bd42710 100644
--- a/src/hwdata.c
+++ b/src/hwdata.c
@@ -21,16 +21,12 @@
 
 #include "hwdata.h"
 
-/******************************************************/
-
 void init_hwdata(struct HWData *hw)
 {
         memset(hw, 0, sizeof(struct HWData));
 }
 
-/******************************************************/
-
-bool read_hwdata(struct HWData *hw, const struct input_event* ev)
+int read_hwdata(struct HWData *hw, const struct input_event* ev)
 {
         switch (ev->type) {
         case EV_SYN:
@@ -97,10 +93,6 @@ bool read_hwdata(struct HWData *hw, const struct input_event* ev)
         return 0;
 }
 
-/******************************************************/
-
 void output_hwdata(const struct HWData *hw)
 {
 }
-
-/******************************************************/
diff --git a/src/hwdata.h b/src/hwdata.h
index d552b1b..9b46073 100644
--- a/src/hwdata.h
+++ b/src/hwdata.h
@@ -34,10 +34,6 @@
 #define MT_BUTTON_HWHEEL_LEFT 5
 #define MT_BUTTON_HWHEEL_RIGHT 6
 
-typedef unsigned int button_t;
-
-////////////////////////////////////////////////////////
-
 struct FingerData {
         int touch_major, touch_minor;
         int width_major, width_minor;
@@ -45,20 +41,14 @@ struct FingerData {
         int position_x, position_y;
 };
 
-////////////////////////////////////////////////////////
-
 struct HWData {
         struct FingerData finger[DIM_FINGER];
-        button_t button;
+        unsigned button;
         int nfinger, nread;
 };
 
-////////////////////////////////////////////////////////
-
 void init_hwdata(struct HWData *hw);
-bool read_hwdata(struct HWData *hw, const struct input_event* ev);
+int read_hwdata(struct HWData *hw, const struct input_event* ev);
 void output_hwdata(const struct HWData *hw);
 
-////////////////////////////////////////////////////////
-
 #endif
diff --git a/src/iobuffer.c b/src/iobuffer.c
index 54955d6..35b61e9 100644
--- a/src/iobuffer.c
+++ b/src/iobuffer.c
@@ -21,8 +21,6 @@
 
 #include "iobuffer.h"
 
-////////////////////////////////////////////////////////
-
 void init_iobuf(struct IOBuffer *buf)
 {
         memset(buf, 0, sizeof(struct IOBuffer));
@@ -31,9 +29,7 @@ void init_iobuf(struct IOBuffer *buf)
         buf->end = buf->begin + DIM_BUFFER;
 }
 
-////////////////////////////////////////////////////////
-
-const struct input_event* get_iobuf_event(struct IOBuffer *buf, int fd)
+const struct input_event *get_iobuf_event(struct IOBuffer *buf, int fd)
 {
         const struct input_event *ev;
         int n = buf->top - buf->at;
@@ -56,5 +52,3 @@ const struct input_event* get_iobuf_event(struct IOBuffer *buf, int fd)
         buf->at += EVENT_SIZE;
         return ev;
 }
-
-////////////////////////////////////////////////////////
diff --git a/src/iobuffer.h b/src/iobuffer.h
index 05f412c..2e3d0c8 100644
--- a/src/iobuffer.h
+++ b/src/iobuffer.h
@@ -28,17 +28,11 @@
 #define DIM_EVENTS 64
 #define DIM_BUFFER (DIM_EVENTS * EVENT_SIZE)
 
-////////////////////////////////////////////////////////
-
 struct IOBuffer {
         char begin[DIM_BUFFER], *at, *top, *end;
 };
 
-////////////////////////////////////////////////////////
-
 void init_iobuf(struct IOBuffer *buf);
-const struct input_event* get_iobuf_event(struct IOBuffer *buf, int fd);
-
-////////////////////////////////////////////////////////
+const struct input_event *get_iobuf_event(struct IOBuffer *buf, int fd);
 
 #endif
diff --git a/src/mtouch.c b/src/mtouch.c
index 5cb84fe..f7ffb12 100644
--- a/src/mtouch.c
+++ b/src/mtouch.c
@@ -21,8 +21,6 @@
 
 #include "mtouch.h"
 
-/******************************************************/
-
 int configure_mtouch(struct MTouch *mt, int fd)
 {
         int rc = read_capabilities(&mt->caps, fd);
@@ -32,8 +30,6 @@ int configure_mtouch(struct MTouch *mt, int fd)
         return 0;
 }
 
-/******************************************************/
-
 int open_mtouch(struct MTouch *mt, int fd)
 {
         int rc;
@@ -45,8 +41,6 @@ int open_mtouch(struct MTouch *mt, int fd)
         return rc;
 }
 
-/******************************************************/
-
 int close_mtouch(struct MTouch *mt, int fd)
 {
         int rc;
@@ -54,22 +48,16 @@ int close_mtouch(struct MTouch *mt, int fd)
         return rc;
 }
 
-/******************************************************/
-
-bool read_synchronized_event(struct MTouch *mt, int fd)
+int read_synchronized_event(struct MTouch *mt, int fd)
 {
-        const struct input_event* ev;
-        while(ev = get_iobuf_event(&mt->buf, fd))
+        const struct input_event *ev;
+        while (ev = get_iobuf_event(&mt->buf, fd))
                 if (read_hwdata(&mt->hw, ev))
-                    return 1;
+                        return 1;
         return 0;
 }
 
-/******************************************************/
-
 void parse_event(struct MTouch *mt)
 {
         modify_state(&mt->ns, &mt->hw, &mt->caps);
 }
-
-/******************************************************/
diff --git a/src/mtouch.h b/src/mtouch.h
index 900d825..753a400 100644
--- a/src/mtouch.h
+++ b/src/mtouch.h
@@ -27,8 +27,6 @@
 #include "hwdata.h"
 #include "state.h"
 
-////////////////////////////////////////////////////////
-
 struct MTouch {
         struct Capabilities caps;
         struct IOBuffer buf;
@@ -36,15 +34,11 @@ struct MTouch {
         struct State os, ns;
 };
 
-////////////////////////////////////////////////////////
-
 int configure_mtouch(struct MTouch *mt, int fd);
 int open_mtouch(struct MTouch *mt, int fd);
 int close_mtouch(struct MTouch *mt, int fd);
 
-bool read_synchronized_event(struct MTouch *mt, int fd);
+int read_synchronized_event(struct MTouch *mt, int fd);
 void parse_event(struct MTouch *mt);
 
-////////////////////////////////////////////////////////
-
 #endif
diff --git a/src/multitouch.c b/src/multitouch.c
index acaeea1..2919b9d 100644
--- a/src/multitouch.c
+++ b/src/multitouch.c
@@ -26,13 +26,11 @@
 #include <xserver-properties.h>
 #endif
 
-////////////////////////////////////////////////////////////////////////////
-
-// these should be user-configurable at some point
+/* these should be user-configurable at some point */
 static const float vscroll_fraction = 0.05;
 static const float hscroll_fraction = 0.2;
 
-// flip these to enable event debugging
+/* flip these to enable event debugging */
 #if 1
 #define TRACE1(format, arg1)
 #define TRACE2(format, arg1, arg2)
@@ -41,18 +39,14 @@ static const float hscroll_fraction = 0.2;
 #define TRACE2(format, arg1, arg2) xf86Msg(X_INFO, format, arg1, arg2)
 #endif
 
-// button mapping simplified
+/* button mapping simplified */
 #define PROPMAP(m, x, y) m[x] = XIGetKnownProperty(y)
 
-////////////////////////////////////////////////////////////////////////////
-
 static void pointer_control(DeviceIntPtr dev, PtrCtrl *ctrl)
 {
         xf86Msg(X_INFO, "pointer_control\n");
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 static int pointer_property(DeviceIntPtr dev,
                             Atom property,
                             XIPropertyValuePtr prop,
@@ -62,36 +56,34 @@ static int pointer_property(DeviceIntPtr dev,
         return Success;
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
 static void initAxesLabels(Atom map[2])
 {
-   memset(map, 0, 2 * sizeof(Atom));
-   PROPMAP(map, 0, AXIS_LABEL_PROP_REL_X);
-   PROPMAP(map, 1, AXIS_LABEL_PROP_REL_Y);
+        memset(map, 0, 2 * sizeof(Atom));
+        PROPMAP(map, 0, AXIS_LABEL_PROP_REL_X);
+        PROPMAP(map, 1, AXIS_LABEL_PROP_REL_Y);
 }
 
 static void initButtonLabels(Atom map[DIM_BUTTON])
 {
-   memset(map, 0, DIM_BUTTON * sizeof(Atom));
-   PROPMAP(map, MT_BUTTON_LEFT, BTN_LABEL_PROP_BTN_LEFT);
-   PROPMAP(map, MT_BUTTON_MIDDLE, BTN_LABEL_PROP_BTN_MIDDLE);
-   PROPMAP(map, MT_BUTTON_RIGHT, BTN_LABEL_PROP_BTN_RIGHT);
-   PROPMAP(map, MT_BUTTON_WHEEL_UP, BTN_LABEL_PROP_BTN_WHEEL_UP);
-   PROPMAP(map, MT_BUTTON_WHEEL_DOWN, BTN_LABEL_PROP_BTN_WHEEL_DOWN);
-   PROPMAP(map, MT_BUTTON_HWHEEL_LEFT, BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
-   PROPMAP(map, MT_BUTTON_HWHEEL_RIGHT, BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
+        memset(map, 0, DIM_BUTTON * sizeof(Atom));
+        PROPMAP(map, MT_BUTTON_LEFT, BTN_LABEL_PROP_BTN_LEFT);
+        PROPMAP(map, MT_BUTTON_MIDDLE, BTN_LABEL_PROP_BTN_MIDDLE);
+        PROPMAP(map, MT_BUTTON_RIGHT, BTN_LABEL_PROP_BTN_RIGHT);
+        PROPMAP(map, MT_BUTTON_WHEEL_UP, BTN_LABEL_PROP_BTN_WHEEL_UP);
+        PROPMAP(map, MT_BUTTON_WHEEL_DOWN, BTN_LABEL_PROP_BTN_WHEEL_DOWN);
+        PROPMAP(map, MT_BUTTON_HWHEEL_LEFT, BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
+        PROPMAP(map, MT_BUTTON_HWHEEL_RIGHT, BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
 }
 #endif
 
 static int device_init(DeviceIntPtr dev, LocalDevicePtr local)
 {
         struct MTouch *mt = local->private;
-        unsigned char btmap[DIM_BUTTON + 1]={0,1,2,3,4,5,6,7};
+        unsigned char btmap[DIM_BUTTON + 1] = { 0, 1, 2, 3, 4, 5, 6, 7 };
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
         Atom axes_labels[2], btn_labels[DIM_BUTTON];
-   initAxesLabels(axes_labels);
+        initAxesLabels(axes_labels);
         initButtonLabels(btn_labels);
 #endif
 
@@ -131,7 +123,7 @@ static int device_init(DeviceIntPtr dev, LocalDevicePtr local)
 
         xf86InitValuatorAxisStruct(dev, 0,
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
-                                        axes_labels[0],
+                                   axes_labels[0],
 #endif
                                    mt->caps.abs_position_x.minimum,
                                    mt->caps.abs_position_x.maximum,
@@ -139,7 +131,7 @@ static int device_init(DeviceIntPtr dev, LocalDevicePtr local)
         xf86InitValuatorDefaults(dev, 0);
         xf86InitValuatorAxisStruct(dev, 1,
 #if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
-                                        axes_labels[1],
+                                   axes_labels[1],
 #endif
                                    mt->caps.abs_position_y.minimum,
                                    mt->caps.abs_position_y.maximum,
@@ -151,8 +143,6 @@ static int device_init(DeviceIntPtr dev, LocalDevicePtr local)
         return Success;
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 static int device_on(LocalDevicePtr local)
 {
         struct MTouch *mt = local->private;
@@ -169,54 +159,45 @@ static int device_on(LocalDevicePtr local)
         return Success;
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 static int device_off(LocalDevicePtr local)
 {
         struct MTouch *mt = local->private;
         xf86RemoveEnabledDevice(local);
-        if(close_mtouch(mt, local->fd)) {
+        if (close_mtouch(mt, local->fd))
                 xf86Msg(X_WARNING, "multitouch: cannot ungrab device\n");
-        }
         xf86CloseSerial(local->fd);
         return Success;
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 static int device_close(LocalDevicePtr local)
 {
         return Success;
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 static void tickle_button(LocalDevicePtr local, int id)
 {
         xf86PostButtonEvent(local->dev, FALSE, id, 1, 0, 0);
         xf86PostButtonEvent(local->dev, FALSE, id, 0, 0, 0);
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 static void handle_gestures(LocalDevicePtr local,
                             const struct Gestures *gs,
                             const struct Capabilities *caps)
 {
         static int vscroll, hscroll;
-   int vstep = 1 +
-      vscroll_fraction * (caps->abs_position_y.maximum -
-                          caps->abs_position_y.minimum);
-   int hstep = 1 +
-      hscroll_fraction * (caps->abs_position_x.maximum -
-                          caps->abs_position_x.minimum);
-   int i;
-   for (i = 0; i < DIM_BUTTON; i++) {
-      if (GETBIT(gs->btmask, i)) {
-         xf86PostButtonEvent(local->dev, FALSE,
-                             i + 1, GETBIT(gs->btdata, i), 0, 0);
-         TRACE2("button bit: %d %d\n", i, GETBIT(gs->btdata, i));
-      }
+        int vstep = 1 +
+                vscroll_fraction * (caps->abs_position_y.maximum -
+                                    caps->abs_position_y.minimum);
+        int hstep = 1 +
+                hscroll_fraction * (caps->abs_position_x.maximum -
+                                    caps->abs_position_x.minimum);
+        int i;
+        for (i = 0; i < DIM_BUTTON; i++) {
+                if (GETBIT(gs->btmask, i)) {
+                        xf86PostButtonEvent(local->dev, FALSE,
+                                            i + 1, GETBIT(gs->btdata, i), 0, 0);
+                        TRACE2("button bit: %d %d\n", i, GETBIT(gs->btdata, i));
+                }
         }
         if (GETBIT(gs->type, GS_MOVE)) {
                 xf86PostMotionEvent(local->dev, 0, 0, 2,
@@ -249,8 +230,6 @@ static void handle_gestures(LocalDevicePtr local,
         }
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 /* called for each full received packet from the touchpad */
 static void read_input(LocalDevicePtr local)
 {
@@ -263,8 +242,6 @@ static void read_input(LocalDevicePtr local)
         }
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 static Bool device_control(DeviceIntPtr dev, int mode)
 {
         LocalDevicePtr local = dev->public.devicePrivate;
@@ -288,8 +265,6 @@ static Bool device_control(DeviceIntPtr dev, int mode)
 }
 
 
-////////////////////////////////////////////////////////////////////////////
-
 static InputInfoPtr preinit(InputDriverPtr drv, IDevPtr dev, int flags)
 {
         struct MTouch *mt;
@@ -309,7 +284,7 @@ static InputInfoPtr preinit(InputDriverPtr drv, IDevPtr dev, int flags)
         local->conf_idev = dev;
 
         xf86CollectInputOptions(local, NULL, NULL);
-        //xf86OptionListReport(local->options);
+        /* xf86OptionListReport(local->options); */
         xf86ProcessCommonOptions(local, local->options);
 
         local->flags |= XI86_CONFIGURED;
@@ -320,12 +295,10 @@ static InputInfoPtr preinit(InputDriverPtr drv, IDevPtr dev, int flags)
 static void uninit(InputDriverPtr drv, InputInfoPtr local, int flags)
 {
         xfree(local->private);
-   local->private = 0;
+        local->private = 0;
         xf86DeleteInput(local, 0);
 }
 
-////////////////////////////////////////////////////////////////////////////
-
 static InputDriverRec MULTITOUCH = {
         1,
         "multitouch",
@@ -356,5 +329,3 @@ static pointer setup(pointer module, pointer options, int *errmaj, int *errmin)
 }
 
 XF86ModuleData multitouchModuleData = {&VERSION, &setup, NULL };
-
-////////////////////////////////////////////////////////////////////////////
diff --git a/src/state.c b/src/state.c
index 4c8370f..5387828 100644
--- a/src/state.c
+++ b/src/state.c
@@ -26,21 +26,17 @@
 const double FTW = 0.05;
 const double FTS = 0.05;
 
-/******************************************************/
-
 void init_state(struct State *s)
 {
         memset(s, 0, sizeof(struct State));
 }
 
-/******************************************************/
-
-static int fincmp(const void* a,const void* b)
+static int fincmp(const void *a, const void *b)
 {
         return ((struct FingerState *)a)->id - ((struct FingerState *)b)->id;
 }
 
-inline float dist2(const struct FingerData* a,const struct FingerData* b)
+inline float dist2(const struct FingerData *a, const struct FingerData *b)
 {
         float dx = a->position_x - b->position_x;
         float dy = a->position_y - b->position_y;
@@ -48,9 +44,9 @@ inline float dist2(const struct FingerData* a,const struct FingerData* b)
         return dx * dx + dy * dy;
 }
 
-static void set_finger(struct FingerState* fs,
-                       const struct FingerData* hw, int id,
-                       const struct Capabilities* caps)
+static void set_finger(struct FingerState *fs,
+                       const struct FingerData *hw, int id,
+                       const struct Capabilities *caps)
 {
         fs->hw = *hw;
         fs->id = id;
@@ -60,8 +56,8 @@ static void set_finger(struct FingerState* fs,
                 fs->hw.width_minor = hw->width_major;
 }
 
-static bool touching_finger(const struct FingerData* hw,
-                            const struct Capabilities* caps)
+static int touching_finger(const struct FingerData *hw,
+                           const struct Capabilities *caps)
 {
         if (caps->has_touch_major && caps->has_width_major)
                 return hw->width_major > 0 &&
@@ -71,11 +67,9 @@ static bool touching_finger(const struct FingerData* hw,
         return 1;
 }
 
-/******************************************************/
-
 void modify_state(struct State *s,
-                  const struct HWData* hw,
-                  const struct Capabilities* caps)
+                  const struct HWData *hw,
+                  const struct Capabilities *caps)
 {
         float A[DIM2_FINGER], *row;
         int sid[DIM_FINGER], hw2s[DIM_FINGER];
@@ -97,8 +91,9 @@ void modify_state(struct State *s,
                 id = sk >= 0 ? sid[sk] : 0;
                 if (!touching_finger(&hw->finger[hwk], caps))
                         id = 0;
-                else while (!id)
-                        id = ++s->lastid;
+                else
+                        while (!id)
+                                id = ++s->lastid;
                 set_finger(&s->finger[hwk], &hw->finger[hwk], id, caps);
         }
 
@@ -109,8 +104,6 @@ void modify_state(struct State *s,
         qsort(s->finger, s->nfinger, sizeof(struct FingerState), fincmp);
 }
 
-/******************************************************/
-
 const struct FingerState *find_finger(const struct State *s, int id)
 {
         int i;
@@ -124,8 +117,6 @@ const struct FingerState *find_finger(const struct State *s, int id)
         return NULL;
 }
 
-/******************************************************/
-
 int count_fingers(const struct State *s)
 {
         int i, n = 0;
@@ -135,8 +126,6 @@ int count_fingers(const struct State *s)
         return n;
 }
 
-/******************************************************/
-
 void output_state(const struct State *s)
 {
         int i;
@@ -159,5 +148,3 @@ void output_state(const struct State *s)
                         s->finger[i].hw.position_y);
         }
 }
-
-/******************************************************/
diff --git a/src/state.h b/src/state.h
index d8e096a..340803a 100644
--- a/src/state.h
+++ b/src/state.h
@@ -25,34 +25,26 @@
 #include "capabilities.h"
 #include "hwdata.h"
 
-////////////////////////////////////////////////////////
-
 /* zero id means not mapped (not touching) */
 struct FingerState {
         struct FingerData hw;
         int id;
 };
 
-////////////////////////////////////////////////////////
-
 struct State {
         struct FingerState finger[DIM_FINGER];
-        button_t button;
+        unsigned button;
         int nfinger;
         int lastid;
 };
 
-////////////////////////////////////////////////////////
-
 void init_state(struct State *s);
 void modify_state(struct State *s,
-                  const struct HWData* hw,
-                  const struct Capabilities* caps);
+                  const struct HWData *hw,
+                  const struct Capabilities *caps);
 void output_state(const struct State *s);
 
 const struct FingerState *find_finger(const struct State *s, int id);
 int count_fingers(const struct State *s);
 
-////////////////////////////////////////////////////////
-
 #endif
diff --git a/src/test.c b/src/test.c
index 82e30e6..e9b8ce3 100644
--- a/src/test.c
+++ b/src/test.c
@@ -22,7 +22,7 @@
 #include <stdio.h>
 #include <time.h>
 
-int main(int argc,char* argv[])
+int main(int argc, char *argv[])
 {
         return 0;
 }