tab--

git-svn-id: svn+ssh://svn.enlightenment.org/var/svn/e/trunk/ecore@52922 7cbeb6ba-43b4-40fd-8cce-4c39aea84d33

diff --git a/src/lib/ecore_ipc/Ecore_Ipc.h b/src/lib/ecore_ipc/Ecore_Ipc.h
index 8011539..000fca9 100644 (file)
--- a/src/lib/ecore_ipc/Ecore_Ipc.h
+++ b/src/lib/ecore_ipc/Ecore_Ipc.h
@@ -68,44 +68,44 @@ EAPI unsigned long long _ecore_ipc_swap_64(unsigned long long v);
 /* unpacking */
 #define ECORE_IPC_GET64(v)\
     { \
-       p->v = ECORE_IPC_SWAP2CPU64(*(long long *)(ptr)); \
-       ptr += 8; \
+        p->v = ECORE_IPC_SWAP2CPU64(*(long long *)(ptr)); \
+        ptr += 8; \
     }
 #define ECORE_IPC_GET32(v)\
     { \
-       p->v = ECORE_IPC_SWAP2CPU32(*(int *)(ptr)); \
-       ptr += 4; \
+        p->v = ECORE_IPC_SWAP2CPU32(*(int *)(ptr)); \
+        ptr += 4; \
     }
 #define ECORE_IPC_GET16(v)\
     { \
-       p->v = ECORE_IPC_SWAP2CPU16(*(short *)(ptr)); \
-       ptr += 2; \
+        p->v = ECORE_IPC_SWAP2CPU16(*(short *)(ptr)); \
+        ptr += 2; \
     }
 #define ECORE_IPC_GET8(v) \
     { \
-       p->v = ECORE_IPC_SWAP2CPU8(*(char *)(ptr)); \
-       ptr += 1; \
+        p->v = ECORE_IPC_SWAP2CPU8(*(char *)(ptr)); \
+        ptr += 1; \
     }
 /* packing */
 #define ECORE_IPC_PUT64(v)\
     { \
-       *(long long *)(ptr) = ECORE_IPC_SWAP2NET64(p->v); \
-       ptr += 8; \
+        *(long long *)(ptr) = ECORE_IPC_SWAP2NET64(p->v); \
+        ptr += 8; \
     }
 #define ECORE_IPC_PUT32(v)\
     { \
-       *(int *)(ptr) = ECORE_IPC_SWAP2NET32(p->v); \
-       ptr += 4; \
+        *(int *)(ptr) = ECORE_IPC_SWAP2NET32(p->v); \
+        ptr += 4; \
     }
 #define ECORE_IPC_PUT16(v)\
     { \
-       *(short *)(ptr) = ECORE_IPC_SWAP2NET16(p->v); \
-       ptr += 2; \
+        *(short *)(ptr) = ECORE_IPC_SWAP2NET16(p->v); \
+        ptr += 2; \
     }
 #define ECORE_IPC_PUT8(v) \
     { \
-       *(char *)(ptr) = ECORE_IPC_SWAP2NET8(p->v); \
-       ptr += 1; \
+        *(char *)(ptr) = ECORE_IPC_SWAP2NET8(p->v); \
+        ptr += 1; \
     }
 /* padding data */
 #define ECORE_IPC_PAD8()   ptr += 1
@@ -123,16 +123,16 @@ EAPI unsigned long long _ecore_ipc_swap_64(unsigned long long v);
 #define ECORE_IPC_CHEKS() if (*((unsigned char *)d + s - 1) != 0) return 0;
 #define ECORE_IPC_GETS(v) \
     { \
-       if (ptr < ((unsigned char *)d + s)) \
-           { \
-               p->v = (char *)ptr; \
-               ptr += strlen(p->v) + 1; \
-           } \
+        if (ptr < ((unsigned char *)d + s)) \
+            { \
+                p->v = (char *)ptr; \
+                ptr += strlen(p->v) + 1; \
+            } \
     } 
 #define ECORE_IPC_PUTS(v, l)\
     { \
-       strcpy((char *)ptr, p->v); \
-       ptr += l + 1; \
+        strcpy((char *)ptr, p->v); \
+        ptr += l + 1; \
     }
 
 /* handy to calculate what sized block we need to alloc */
@@ -189,7 +189,7 @@ EAPI unsigned long long _ecore_ipc_swap_64(unsigned long long v);
             p = malloc(sizeof(typ));
 
 #define ECORE_IPC_DEC_EINA_LIST_FOOT() \
-           l = eina_list_append(l, p); \
+            l = eina_list_append(l, p); \
         } \
     return l
 #define ECORE_IPC_ENC_EINA_LIST_HEAD_START(typ) \

diff --git a/src/lib/ecore_ipc/ecore_ipc.c b/src/lib/ecore_ipc/ecore_ipc.c
index 0ab5469..3900be4 100644 (file)
--- a/src/lib/ecore_ipc/ecore_ipc.c
+++ b/src/lib/ecore_ipc/ecore_ipc.c
@@ -84,78 +84,78 @@ _ecore_ipc_dlt_int(int out, int prev, int *mode)
    /* 0 byte */
    if (out == 0)
      {
-       *mode = DLT_ZERO;
-       return 0;
+        *mode = DLT_ZERO;
+        return 0;
      }
    if (out == (int)0xffffffff)
      {
-       *mode = DLT_ONE;
-       return 0;
+        *mode = DLT_ONE;
+        return 0;
      }
    if (out == prev)
      {
-       *mode = DLT_SAME;
-       return 0;
+        *mode = DLT_SAME;
+        return 0;
      }
    if (out == prev << 1)
      {
-       *mode = DLT_SHL;
-       return 0;
+        *mode = DLT_SHL;
+        return 0;
      }
    if (out == prev >> 1)
      {
-       *mode = DLT_SHR;
-       return 0;
+        *mode = DLT_SHR;
+        return 0;
      }
    /* 1 byte */
    dlt = out - prev;
    if (!(dlt & 0xffffff00))
      {
-       *mode = DLT_ADD8;
-       return dlt & 0xff;
+        *mode = DLT_ADD8;
+        return dlt & 0xff;
      }
    dlt = prev - out;
    if (!(dlt & 0xffffff00))
      {
-       *mode = DLT_DEL8;
-       return dlt & 0xff;
+        *mode = DLT_DEL8;
+        return dlt & 0xff;
      }
    dlt = out - prev;
    if (!(dlt & 0x00ffffff))
      {
-       *mode = DLT_ADDU8;
-       return (dlt >> 24) & 0xff;
+        *mode = DLT_ADDU8;
+        return (dlt >> 24) & 0xff;
      }
    dlt = prev - out;
    if (!(dlt & 0x00ffffff))
      {
-       *mode = DLT_DELU8;
-       return (dlt >> 24) & 0xff;
+        *mode = DLT_DELU8;
+        return (dlt >> 24) & 0xff;
      }
    /* 2 byte */
    dlt = out - prev;
    if (!(dlt & 0xffff0000))
      {
-       *mode = DLT_ADD16;
-       return dlt & 0xffff;
+        *mode = DLT_ADD16;
+        return dlt & 0xffff;
      }
    dlt = prev - out;
    if (!(dlt & 0xffff0000))
      {
-       *mode = DLT_DEL16;
-       return dlt & 0xffff;
+        *mode = DLT_DEL16;
+        return dlt & 0xffff;
      }
    dlt = out - prev;
    if (!(dlt & 0x0000ffff))
      {
-       *mode = DLT_ADDU16;
-       return (dlt >> 16) & 0xffff;
+        *mode = DLT_ADDU16;
+        return (dlt >> 16) & 0xffff;
      }
    dlt = prev - out;
    if (!(dlt & 0x0000ffff))
      {
-       *mode = DLT_DELU16;
-       return (dlt >> 16) & 0xffff;
+        *mode = DLT_DELU16;
+        return (dlt >> 16) & 0xffff;
      }
    /* 4 byte */
    *mode = DLT_SET;
@@ -168,55 +168,55 @@ _ecore_ipc_ddlt_int(int in, int prev, int mode)
    switch (mode)
      {
       case DLT_ZERO:
-       return 0;
-       break;
+        return 0;
+        break;
       case DLT_ONE:
-       return 0xffffffff;
-       break;
+        return 0xffffffff;
+        break;
       case DLT_SAME:
-       return prev;
-       break;
+        return prev;
+        break;
       case DLT_SHL:
-       return prev << 1;
-       break;
+        return prev << 1;
+        break;
       case DLT_SHR:
-       return prev >> 1;
-       break;
+        return prev >> 1;
+        break;
       case DLT_ADD8:
-       return prev + in;
-       break;
+        return prev + in;
+        break;
       case DLT_DEL8:
-       return prev - in;
-       break;
+        return prev - in;
+        break;
       case DLT_ADDU8:
-       return prev + (in << 24);
-       break;
+        return prev + (in << 24);
+        break;
       case DLT_DELU8:
-       return prev - (in << 24);
-       break;
+        return prev - (in << 24);
+        break;
       case DLT_ADD16:
-       return prev + in;
-       break;
+        return prev + in;
+        break;
       case DLT_DEL16:
-       return prev - in;
-       break;
+        return prev - in;
+        break;
       case DLT_ADDU16:
-       return prev + (in << 16);
-       break;
+        return prev + (in << 16);
+        break;
       case DLT_DELU16:
-       return prev - (in << 16);
-       break;
+        return prev - (in << 16);
+        break;
       case DLT_SET:
-       return in;
-       break;
+        return in;
+        break;
       case DLT_R1:
-       return 0;
-       break;
+        return 0;
+        break;
       case DLT_R2:
-       return 0;
-       break;
+        return 0;
+        break;
       default:
-       break;
+        break;
      }
    return 0;
 }
@@ -281,17 +281,17 @@ ecore_ipc_init(void)
    ECORE_IPC_EVENT_SERVER_DATA = ecore_event_type_new();
 
    handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD,
-                                         _ecore_ipc_event_client_add, NULL);
+                                          _ecore_ipc_event_client_add, NULL);
    handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL,
-                                         _ecore_ipc_event_client_del, NULL);
+                                          _ecore_ipc_event_client_del, NULL);
    handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD,
-                                         _ecore_ipc_event_server_add, NULL);
+                                          _ecore_ipc_event_server_add, NULL);
    handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL,
-                                         _ecore_ipc_event_server_del, NULL);
+                                          _ecore_ipc_event_server_del, NULL);
    handler[i++] = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA,
-                                         _ecore_ipc_event_client_data, NULL);
+                                          _ecore_ipc_event_client_data, NULL);
    handler[i] = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
-                                         _ecore_ipc_event_server_data, NULL);
+                                          _ecore_ipc_event_server_data, NULL);
    return _ecore_ipc_init_count;
 }
 
@@ -355,22 +355,22 @@ ecore_ipc_server_add(Ecore_Ipc_Type compl_type, const char *name, int port, cons
    switch (type)
      {
       case ECORE_IPC_LOCAL_USER:
-       svr->server = ecore_con_server_add(ECORE_CON_LOCAL_USER | extra, name, port, svr);
-       break;
+        svr->server = ecore_con_server_add(ECORE_CON_LOCAL_USER | extra, name, port, svr);
+        break;
       case ECORE_IPC_LOCAL_SYSTEM:
-       svr->server = ecore_con_server_add(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
-       break;
+        svr->server = ecore_con_server_add(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
+        break;
       case ECORE_IPC_REMOTE_SYSTEM:
-       svr->server = ecore_con_server_add(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
-       break;
+        svr->server = ecore_con_server_add(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
+        break;
       default:
-       free(svr);
-       return NULL;
+        free(svr);
+        return NULL;
      }
    if (!svr->server)
      {
-       free(svr);
-       return NULL;
+        free(svr);
+        return NULL;
      }
    svr->max_buf_size = 32 * 1024;
    svr->data = (void *)data;
@@ -411,22 +411,22 @@ ecore_ipc_server_connect(Ecore_Ipc_Type compl_type, char *name, int port, const
    switch (type)
      {
       case ECORE_IPC_LOCAL_USER:
-       svr->server = ecore_con_server_connect(ECORE_CON_LOCAL_USER | extra, name, port, svr);
-       break;
+        svr->server = ecore_con_server_connect(ECORE_CON_LOCAL_USER | extra, name, port, svr);
+        break;
       case ECORE_IPC_LOCAL_SYSTEM:
-       svr->server = ecore_con_server_connect(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
-       break;
+        svr->server = ecore_con_server_connect(ECORE_CON_LOCAL_SYSTEM | extra, name, port, svr);
+        break;
       case ECORE_IPC_REMOTE_SYSTEM:
-       svr->server = ecore_con_server_connect(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
-       break;
+        svr->server = ecore_con_server_connect(ECORE_CON_REMOTE_SYSTEM | extra, name, port, svr);
+        break;
       default:
-       free(svr);
-       return NULL;
+        free(svr);
+        return NULL;
      }
    if (!svr->server)
      {
-       free(svr);
-       return NULL;
+        free(svr);
+        return NULL;
      }
    svr->max_buf_size = -1;
    svr->data = (void *)data;
@@ -448,9 +448,9 @@ ecore_ipc_server_del(Ecore_Ipc_Server *svr)
 
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_del");
-       return NULL;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_del");
+        return NULL;
      }
    if (svr->delete_me) return NULL;
 
@@ -459,16 +459,16 @@ ecore_ipc_server_del(Ecore_Ipc_Server *svr)
    svr->delete_me = 1;
    if (svr->event_count == 0)
      {
-       Ecore_Ipc_Client *cl;
+        Ecore_Ipc_Client *cl;
 
-       EINA_LIST_FREE(svr->clients, cl)
-         ecore_ipc_client_del(cl);
-       ecore_con_server_del(svr->server);
-       servers = eina_list_remove(servers, svr);
+        EINA_LIST_FREE(svr->clients, cl)
+          ecore_ipc_client_del(cl);
+        ecore_con_server_del(svr->server);
+        servers = eina_list_remove(servers, svr);
 
-       if (svr->buf) free(svr->buf);
-       ECORE_MAGIC_SET(svr, ECORE_MAGIC_NONE);
-       free(svr);
+        if (svr->buf) free(svr->buf);
+        ECORE_MAGIC_SET(svr, ECORE_MAGIC_NONE);
+        free(svr);
      }
    return data;
 }
@@ -484,9 +484,9 @@ ecore_ipc_server_data_get(Ecore_Ipc_Server *svr)
 {
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_data_get");
-       return NULL;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_data_get");
+        return NULL;
      }
    return svr->data;
 }
@@ -502,9 +502,9 @@ ecore_ipc_server_connected_get(Ecore_Ipc_Server *svr)
 {
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_connected_get");
-       return EINA_FALSE;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_connected_get");
+        return EINA_FALSE;
      }
    return ecore_con_server_connected_get(svr->server);
 }
@@ -520,9 +520,9 @@ ecore_ipc_server_clients_get(Ecore_Ipc_Server *svr)
 {
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_clients_get");
-       return NULL;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_clients_get");
+        return NULL;
      }
    return svr->client_list;
 }
@@ -531,32 +531,32 @@ ecore_ipc_server_clients_get(Ecore_Ipc_Server *svr)
    d = _ecore_ipc_dlt_int(msg._member, svr->prev.o._member, &md); \
    if (md >= DLT_SET) \
      { \
-       unsigned int v; \
-       unsigned char *dd; \
-       dd = (unsigned char *)&v; \
-       v = d; \
-       v = htonl(v); \
-       *(dat + s + 0) = dd[0]; \
-       *(dat + s + 1) = dd[1]; \
-       *(dat + s + 2) = dd[2]; \
-       *(dat + s + 3) = dd[3]; \
-       s += 4; \
+        unsigned int v; \
+        unsigned char *dd; \
+        dd = (unsigned char *)&v; \
+        v = d; \
+        v = htonl(v); \
+        *(dat + s + 0) = dd[0]; \
+        *(dat + s + 1) = dd[1]; \
+        *(dat + s + 2) = dd[2]; \
+        *(dat + s + 3) = dd[3]; \
+        s += 4; \
      } \
    else if (md >= DLT_ADD16) \
      { \
-       unsigned short v; \
-       unsigned char *dd; \
-       dd = (unsigned char *)&v; \
-       v = d; \
-       v = htons(v); \
-       *(dat + s + 0) = dd[0]; \
-       *(dat + s + 1) = dd[1]; \
-       s += 2; \
+        unsigned short v; \
+        unsigned char *dd; \
+        dd = (unsigned char *)&v; \
+        v = d; \
+        v = htons(v); \
+        *(dat + s + 0) = dd[0]; \
+        *(dat + s + 1) = dd[1]; \
+        s += 2; \
      } \
    else if (md >= DLT_ADD8) \
      { \
-       *(dat + s + 0) = (unsigned char)d; \
-       s += 1; \
+        *(dat + s + 0) = (unsigned char)d; \
+        s += 1; \
      }
 
 /**
@@ -588,9 +588,9 @@ ecore_ipc_server_send(Ecore_Ipc_Server *svr, int major, int minor, int ref, int
 
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_send");
-       return 0;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_send");
+        return 0;
      }
    if (size < 0) size = 0;
    msg.major    = major;
@@ -647,9 +647,9 @@ ecore_ipc_server_client_limit_set(Ecore_Ipc_Server *svr, int client_limit, char
 {
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_client_limit_set");
-       return;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_client_limit_set");
+        return;
      }
    ecore_con_server_client_limit_set(svr->server, client_limit, reject_excess_clients);
 }
@@ -666,9 +666,9 @@ ecore_ipc_server_data_size_max_set(Ecore_Ipc_Server *svr, int size)
 {
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_data_size_max_set");
-       return;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_data_size_max_set");
+        return;
      }
    svr->max_buf_size = size;
 }
@@ -685,9 +685,9 @@ ecore_ipc_server_data_size_max_get(Ecore_Ipc_Server *svr)
 {
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_data_size_max_get");
-       return -1;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_data_size_max_get");
+        return -1;
      }
    return svr->max_buf_size;
 }
@@ -707,9 +707,9 @@ ecore_ipc_server_ip_get(Ecore_Ipc_Server *svr)
 {
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_ip_get");
-       return NULL;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_ip_get");
+        return NULL;
      }
    return ecore_con_server_ip_get(svr->server);
 }
@@ -725,9 +725,9 @@ ecore_ipc_server_flush(Ecore_Ipc_Server *svr)
 {
    if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_IPC_SERVER))
      {
-       ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
-                        "ecore_ipc_server_server_flush");
-       return;
+        ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_IPC_SERVER,
+                         "ecore_ipc_server_server_flush");
+        return;
      }
    ecore_con_server_flush(svr->server);
 }
@@ -736,32 +736,32 @@ ecore_ipc_server_flush(Ecore_Ipc_Server *svr)
    d = _ecore_ipc_dlt_int(msg._member, cl->prev.o._member, &md); \
    if (md >= DLT_SET) \
      { \
-       unsigned int v; \
-       unsigned char *dd; \
-       dd = (unsigned char *)&v; \
-       v = d; \
-       v = htonl(v); \
-       *(dat + s + 0) = dd[0]; \
-       *(dat + s + 1) = dd[1]; \
-       *(dat + s + 2) = dd[2]; \
-       *(dat + s + 3) = dd[3]; \
-       s += 4; \
+        unsigned int v; \
+        unsigned char *dd; \
+        dd = (unsigned char *)&v; \
+        v = d; \
+        v = htonl(v); \
+        *(dat + s + 0) = dd[0]; \
+        *(dat + s + 1) = dd[1]; \
+        *(dat + s + 2) = dd[2]; \
+        *(dat + s + 3) = dd[3]; \
+        s += 4; \
      } \
    else if (md >= DLT_ADD16) \
      { \
-       unsigned short v; \
-       unsigned char *dd; \
-       dd = (unsigned char *)&v; \
-       v = d; \
-       v = htons(v); \
-       *(dat + s + 0) = dd[0]; \
-       *(dat + s + 1) = dd[1]; \
-       s += 2; \
+        unsigned short v; \
+        unsigned char *dd; \
+        dd = (unsigned char *)&v; \
+        v = d; \
+        v = htons(v); \
+        *(dat + s + 0) = dd[0]; \
+        *(dat + s + 1) = dd[1]; \
+        s += 2; \
      } \
    else if (md >= DLT_ADD8) \
      { \
-       *(dat + s) = (unsigned char)d; \
-       s += 1; \
+        *(dat + s) = (unsigned char)d; \
+        s += 1; \
      }
 
 /**
@@ -796,9 +796,9 @@ ecore_ipc_client_send(Ecore_Ipc_Client *cl, int major, int minor, int ref, int r
 
    if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
      {
-       ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
-                        "ecore_ipc_client_send");
-       return 0;
+        ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
+                         "ecore_ipc_client_send");
+        return 0;
      }
    if (size < 0) size = 0;
    msg.major    = major;
@@ -839,9 +839,9 @@ ecore_ipc_client_server_get(Ecore_Ipc_Client *cl)
 {
    if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
      {
-       ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
-                        "ecore_ipc_client_server_get");
-       return NULL;
+        ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
+                         "ecore_ipc_client_server_get");
+        return NULL;
      }
    return (ecore_con_server_data_get(ecore_con_client_server_get(cl->client)));
 }
@@ -861,21 +861,21 @@ ecore_ipc_client_del(Ecore_Ipc_Client *cl)
 
    if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
      {
-       ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
-                        "ecore_ipc_client_del");
-       return NULL;
+        ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
+                         "ecore_ipc_client_del");
+        return NULL;
      }
    data = cl->data;
    cl->data = NULL;
    cl->delete_me = 1;
    if (cl->event_count == 0)
      {
-       svr = ecore_con_server_data_get(ecore_con_client_server_get(cl->client));
-       ecore_con_client_del(cl->client);
-       svr->clients = eina_list_remove(svr->clients, cl);
-       if (cl->buf) free(cl->buf);
-       ECORE_MAGIC_SET(cl, ECORE_MAGIC_NONE);
-       free(cl);
+        svr = ecore_con_server_data_get(ecore_con_client_server_get(cl->client));
+        ecore_con_client_del(cl->client);
+        svr->clients = eina_list_remove(svr->clients, cl);
+        if (cl->buf) free(cl->buf);
+        ECORE_MAGIC_SET(cl, ECORE_MAGIC_NONE);
+        free(cl);
      }
    return data;
 }
@@ -891,9 +891,9 @@ ecore_ipc_client_data_set(Ecore_Ipc_Client *cl, const void *data)
 {
    if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
      {
-       ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
-                        "ecore_ipc_client_data_set");
-       return;
+        ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
+                         "ecore_ipc_client_data_set");
+        return;
      }
    cl->data = (void *)data;
 }
@@ -909,9 +909,9 @@ ecore_ipc_client_data_get(Ecore_Ipc_Client *cl)
 {
    if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
      {
-       ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
-                        "ecore_ipc_client_data_get");
-       return NULL;
+        ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
+                         "ecore_ipc_client_data_get");
+        return NULL;
      }
    return cl->data;
 }
@@ -928,9 +928,9 @@ ecore_ipc_client_data_size_max_set(Ecore_Ipc_Client *cl, int size)
 {
    if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
      {
-       ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
-                        "ecore_ipc_client_data_size_max_set");
-       return;
+        ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
+                         "ecore_ipc_client_data_size_max_set");
+        return;
      }
    cl->max_buf_size = size;
 }
@@ -947,9 +947,9 @@ ecore_ipc_client_data_size_max_get(Ecore_Ipc_Client *cl)
 {
    if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
      {
-       ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
-                        "ecore_ipc_client_data_size_max_get");
-       return -1;
+        ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
+                         "ecore_ipc_client_data_size_max_get");
+        return -1;
      }
    return cl->max_buf_size;
 }
@@ -969,9 +969,9 @@ ecore_ipc_client_ip_get(Ecore_Ipc_Client *cl)
 {
    if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
      {
-       ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
-                        "ecore_ipc_client_ip_get");
-       return NULL;
+        ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
+                         "ecore_ipc_client_ip_get");
+        return NULL;
      }
    return ecore_con_client_ip_get(cl->client);
 }
@@ -987,9 +987,9 @@ ecore_ipc_client_flush(Ecore_Ipc_Client *cl)
 {
    if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_IPC_CLIENT))
      {
-       ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
-                        "ecore_ipc_client_flush");
-       return;
+        ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_IPC_CLIENT,
+                         "ecore_ipc_client_flush");
+        return;
      }
    ecore_con_client_flush(cl->client);
 }
@@ -1015,31 +1015,31 @@ _ecore_ipc_event_client_add(void *data __UNUSED__, int ev_type __UNUSED__, void
    if (!eina_list_data_find(servers, ecore_con_server_data_get(ecore_con_client_server_get(e->client)))) return ECORE_CALLBACK_RENEW;
    /* handling code here */
      {
-       Ecore_Ipc_Client *cl;
-       Ecore_Ipc_Server *svr;
-
-       cl = calloc(1, sizeof(Ecore_Ipc_Client));
-       if (!cl) return ECORE_CALLBACK_CANCEL;
-       svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
-       ECORE_MAGIC_SET(cl, ECORE_MAGIC_IPC_CLIENT);
-       cl->client = e->client;
-       cl->max_buf_size = 32 * 1024;
-       ecore_con_client_data_set(cl->client, (void *)cl);
-       svr->clients = eina_list_append(svr->clients, cl);
-       svr->client_list = eina_list_append(svr->client_list, cl);
-       if (!cl->delete_me)
-         {
-            Ecore_Ipc_Event_Client_Add *e2;
-
-            e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Add));
-            if (e2)
-              {
+        Ecore_Ipc_Client *cl;
+        Ecore_Ipc_Server *svr;
+
+        cl = calloc(1, sizeof(Ecore_Ipc_Client));
+        if (!cl) return ECORE_CALLBACK_CANCEL;
+        svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
+        ECORE_MAGIC_SET(cl, ECORE_MAGIC_IPC_CLIENT);
+        cl->client = e->client;
+        cl->max_buf_size = 32 * 1024;
+        ecore_con_client_data_set(cl->client, (void *)cl);
+        svr->clients = eina_list_append(svr->clients, cl);
+        svr->client_list = eina_list_append(svr->client_list, cl);
+        if (!cl->delete_me)
+          {
+             Ecore_Ipc_Event_Client_Add *e2;
+
+             e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Add));
+             if (e2)
+               {
                   cl->event_count++;
-                 e2->client = cl;
-                 ecore_event_add(ECORE_IPC_EVENT_CLIENT_ADD, e2,
-                                 _ecore_ipc_event_client_add_free, NULL);
-              }
-         }
+                  e2->client = cl;
+                  ecore_event_add(ECORE_IPC_EVENT_CLIENT_ADD, e2,
+                                  _ecore_ipc_event_client_add_free, NULL);
+               }
+          }
      }
    return ECORE_CALLBACK_CANCEL;
 }
@@ -1053,27 +1053,27 @@ _ecore_ipc_event_client_del(void *data __UNUSED__, int ev_type __UNUSED__, void
    if (!eina_list_data_find(servers, ecore_con_server_data_get(ecore_con_client_server_get(e->client)))) return ECORE_CALLBACK_RENEW;
    /* handling code here */
      {
-       Ecore_Ipc_Client *cl;
-
-       cl = ecore_con_client_data_get(e->client);
-         {
-            Ecore_Ipc_Event_Client_Del *e2;
-            Ecore_Ipc_Server *svr;
-
-            svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
-            svr->client_list = eina_list_remove(svr->client_list, cl);
-            if (!cl->delete_me)
-              {
-                 e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Del));
-                 if (e2)
-                   {
-                      cl->event_count++;
-                      e2->client = cl;
-                      ecore_event_add(ECORE_IPC_EVENT_CLIENT_DEL, e2,
-                                      _ecore_ipc_event_client_del_free, NULL);
-                   }
-              }
-         }
+        Ecore_Ipc_Client *cl;
+
+        cl = ecore_con_client_data_get(e->client);
+          {
+             Ecore_Ipc_Event_Client_Del *e2;
+             Ecore_Ipc_Server *svr;
+
+             svr = ecore_con_server_data_get(ecore_con_client_server_get(e->client));
+             svr->client_list = eina_list_remove(svr->client_list, cl);
+             if (!cl->delete_me)
+               {
+                  e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Del));
+                  if (e2)
+                    {
+                       cl->event_count++;
+                       e2->client = cl;
+                       ecore_event_add(ECORE_IPC_EVENT_CLIENT_DEL, e2,
+                                       _ecore_ipc_event_client_del_free, NULL);
+                    }
+               }
+          }
      }
    return ECORE_CALLBACK_CANCEL;
 }
@@ -1087,22 +1087,22 @@ _ecore_ipc_event_server_add(void *data __UNUSED__, int ev_type __UNUSED__, void
    if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return ECORE_CALLBACK_RENEW;
    /* handling code here */
      {
-       Ecore_Ipc_Server *svr;
+        Ecore_Ipc_Server *svr;
 
-       svr = ecore_con_server_data_get(e->server);
-       if (!svr->delete_me)
-         {
-            Ecore_Ipc_Event_Server_Add *e2;
+        svr = ecore_con_server_data_get(e->server);
+        if (!svr->delete_me)
+          {
+             Ecore_Ipc_Event_Server_Add *e2;
 
-            e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Add));
-            if (e2)
-              {
+             e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Add));
+             if (e2)
+               {
                   svr->event_count++;
-                 e2->server = svr;
-                 ecore_event_add(ECORE_IPC_EVENT_SERVER_ADD, e2,
-                                 _ecore_ipc_event_server_add_free, NULL);
-              }
-         }
+                  e2->server = svr;
+                  ecore_event_add(ECORE_IPC_EVENT_SERVER_ADD, e2,
+                                  _ecore_ipc_event_server_add_free, NULL);
+               }
+          }
      }
    return ECORE_CALLBACK_CANCEL;
 }
@@ -1116,22 +1116,22 @@ _ecore_ipc_event_server_del(void *data __UNUSED__, int ev_type __UNUSED__, void
    if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return ECORE_CALLBACK_RENEW;
    /* handling code here */
      {
-       Ecore_Ipc_Server *svr;
+        Ecore_Ipc_Server *svr;
 
-       svr = ecore_con_server_data_get(e->server);
-       if (!svr->delete_me)
-         {
-            Ecore_Ipc_Event_Server_Del *e2;
+        svr = ecore_con_server_data_get(e->server);
+        if (!svr->delete_me)
+          {
+             Ecore_Ipc_Event_Server_Del *e2;
 
-            e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Del));
-            if (e2)
-              {
+             e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Del));
+             if (e2)
+               {
                   svr->event_count++;
-                 e2->server = svr;
-                 ecore_event_add(ECORE_IPC_EVENT_SERVER_DEL, e2,
-                                 _ecore_ipc_event_server_del_free, NULL);
-              }
-         }
+                  e2->server = svr;
+                  ecore_event_add(ECORE_IPC_EVENT_SERVER_DEL, e2,
+                                  _ecore_ipc_event_server_del_free, NULL);
+               }
+          }
      }
    return ECORE_CALLBACK_CANCEL;
 }
@@ -1146,34 +1146,34 @@ _ecore_ipc_event_server_del(void *data __UNUSED__, int ev_type __UNUSED__, void
    md = ((head >> (4 * _n)) & 0xf); \
    if (md >= DLT_SET) \
      { \
-       unsigned int v; \
-       unsigned char *dv; \
-       dv = (unsigned char *)&v; \
-       dv[0] = *(cl->buf + offset + s + 0); \
-       dv[1] = *(cl->buf + offset + s + 1); \
-       dv[2] = *(cl->buf + offset + s + 2); \
-       dv[3] = *(cl->buf + offset + s + 3); \
-       d = (int)ntohl(v); \
-       s += 4; \
+        unsigned int v; \
+        unsigned char *dv; \
+        dv = (unsigned char *)&v; \
+        dv[0] = *(cl->buf + offset + s + 0); \
+        dv[1] = *(cl->buf + offset + s + 1); \
+        dv[2] = *(cl->buf + offset + s + 2); \
+        dv[3] = *(cl->buf + offset + s + 3); \
+        d = (int)ntohl(v); \
+        s += 4; \
      } \
    else if (md >= DLT_ADD16) \
      { \
-       unsigned short v; \
-       unsigned char *dv; \
-       dv = (unsigned char *)&v; \
-       dv[0] = *(cl->buf + offset + s + 0); \
-       dv[1] = *(cl->buf + offset + s + 1); \
-       d = (int)ntohs(v); \
-       s += 2; \
+        unsigned short v; \
+        unsigned char *dv; \
+        dv = (unsigned char *)&v; \
+        dv[0] = *(cl->buf + offset + s + 0); \
+        dv[1] = *(cl->buf + offset + s + 1); \
+        d = (int)ntohs(v); \
+        s += 2; \
      } \
    else if (md >= DLT_ADD8) \
      { \
-       unsigned char v; \
-       unsigned char *dv; \
-       dv = (unsigned char *)&v; \
-       dv[0] = *(cl->buf + offset + s + 0); \
-       d = (int)v; \
-       s += 1; \
+        unsigned char v; \
+        unsigned char *dv; \
+        dv = (unsigned char *)&v; \
+        dv[0] = *(cl->buf + offset + s + 0); \
+        d = (int)v; \
+        s += 1; \
      } \
    msg._member = _ecore_ipc_ddlt_int(d, cl->prev.i._member, md);
 
@@ -1186,144 +1186,144 @@ _ecore_ipc_event_client_data(void *data __UNUSED__, int ev_type __UNUSED__, void
    if (!eina_list_data_find(servers, ecore_con_server_data_get(ecore_con_client_server_get(e->client)))) return ECORE_CALLBACK_RENEW;
    /* handling code here */
      {
-       Ecore_Ipc_Client *cl;
-       Ecore_Ipc_Msg_Head msg;
-       int offset = 0;
-       unsigned char *buf;
-
-       cl = ecore_con_client_data_get(e->client);
-
-       if (!cl->buf)
-         {
-            cl->buf_size = e->size;
-            cl->buf = e->data;
-            e->data = NULL; /* take it out of the old event */
-         }
-       else
-         {
-            buf = realloc(cl->buf, cl->buf_size + e->size);
-            if (!buf)
-              {
-                 free(cl->buf);
-                 cl->buf = 0;
-                 cl->buf_size  = 0;
-                 return ECORE_CALLBACK_CANCEL;
-              }
-            cl->buf = buf;
-            memcpy(cl->buf + cl->buf_size, e->data, e->size);
-            cl->buf_size += e->size;
-         }
-       /* examine header */
-       redo:
-       if ((cl->buf_size - offset) >= (int)sizeof(int))
-         {
-            int s, md, d = 0, head;
-            unsigned char *dd;
-
-            dd = (unsigned char *)&head;
-            dd[0] = *(cl->buf + offset + 0);
-            dd[1] = *(cl->buf + offset + 1);
-            dd[2] = *(cl->buf + offset + 2);
-            dd[3] = *(cl->buf + offset + 3);
-            head = ntohl(head);
-            dd = (unsigned char *)&d;
-            s = 4;
-            CLSZ(0);
-            CLSZ(1);
-            CLSZ(2);
-            CLSZ(3);
-            CLSZ(4);
-            CLSZ(5);
-            if ((cl->buf_size - offset) < s)
-              {
-                 if (offset > 0) goto scroll;
-                 return ECORE_CALLBACK_CANCEL;
-              }
-
-            s = 4;
-            CLDEC(0, major);
-            CLDEC(1, minor);
-            CLDEC(2, ref);
-            CLDEC(3, ref_to);
-            CLDEC(4, response);
-            CLDEC(5, size);
-            if (msg.size < 0) msg.size = 0;
-            /* there is enough data in the buffer for a full message */
-            if ((cl->buf_size - offset) >= (s + msg.size))
-              {
-                 Ecore_Ipc_Event_Client_Data *e2;
-                 Ecore_Ipc_Server *svr;
-                 int max, max2;
-
-                 buf = NULL;
-                 svr = ecore_con_server_data_get(ecore_con_client_server_get(cl->client));
-                 max = svr->max_buf_size;
-                 max2 = cl->max_buf_size;
-                 if ((max >= 0) && (max2 >= 0))
-                   {
-                      if (max2 < max) max = max2;
-                   }
-                 else
-                   {
-                      if (max < 0) max = max2;
-                   }
-                 if ((max < 0) || (msg.size <= max))
-                   {
-                      if (msg.size > 0)
-                        {
-                           buf = malloc(msg.size);
-                           if (!buf) return ECORE_CALLBACK_CANCEL;
-                           memcpy(buf, cl->buf + offset + s, msg.size);
-                        }
-                      if (!cl->delete_me)
-                        {
-                           e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Data));
-                           if (e2)
-                             {
-                                cl->event_count++;
-                                e2->client   = cl;
-                                e2->major    = msg.major;
-                                e2->minor    = msg.minor;
-                                e2->ref      = msg.ref;
-                                e2->ref_to   = msg.ref_to;
-                                e2->response = msg.response;
-                                e2->size     = msg.size;
-                                e2->data     = buf;
-                                ecore_event_add(ECORE_IPC_EVENT_CLIENT_DATA, e2,
-                                                _ecore_ipc_event_client_data_free,
-                                                NULL);
-                             }
-                        }
-                   }
-                 cl->prev.i = msg;
-                 offset += (s + msg.size);
-                 if (cl->buf_size == offset)
-                   {
-                      free(cl->buf);
-                      cl->buf = NULL;
-                      cl->buf_size = 0;
-                      return ECORE_CALLBACK_CANCEL;
-                   }
-                 goto redo;
-              }
-            else goto scroll;
-         }
-       else
-         {
-            scroll:
-            buf = malloc(cl->buf_size - offset);
-            if (!buf)
-              {
-                 free(cl->buf);
-                 cl->buf = NULL;
-                 cl->buf_size = 0;
-                 return ECORE_CALLBACK_CANCEL;
-              }
-            memcpy(buf, cl->buf + offset, cl->buf_size - offset);
-            free(cl->buf);
-            cl->buf = buf;
-            cl->buf_size -= offset;
-         }
+        Ecore_Ipc_Client *cl;
+        Ecore_Ipc_Msg_Head msg;
+        int offset = 0;
+        unsigned char *buf;
+
+        cl = ecore_con_client_data_get(e->client);
+
+        if (!cl->buf)
+          {
+             cl->buf_size = e->size;
+             cl->buf = e->data;
+             e->data = NULL; /* take it out of the old event */
+          }
+        else
+          {
+             buf = realloc(cl->buf, cl->buf_size + e->size);
+             if (!buf)
+               {
+                  free(cl->buf);
+                  cl->buf = 0;
+                  cl->buf_size  = 0;
+                  return ECORE_CALLBACK_CANCEL;
+               }
+             cl->buf = buf;
+             memcpy(cl->buf + cl->buf_size, e->data, e->size);
+             cl->buf_size += e->size;
+          }
+        /* examine header */
+        redo:
+        if ((cl->buf_size - offset) >= (int)sizeof(int))
+          {
+             int s, md, d = 0, head;
+             unsigned char *dd;
+
+             dd = (unsigned char *)&head;
+             dd[0] = *(cl->buf + offset + 0);
+             dd[1] = *(cl->buf + offset + 1);
+             dd[2] = *(cl->buf + offset + 2);
+             dd[3] = *(cl->buf + offset + 3);
+             head = ntohl(head);
+             dd = (unsigned char *)&d;
+             s = 4;
+             CLSZ(0);
+             CLSZ(1);
+             CLSZ(2);
+             CLSZ(3);
+             CLSZ(4);
+             CLSZ(5);
+             if ((cl->buf_size - offset) < s)
+               {
+                  if (offset > 0) goto scroll;
+                  return ECORE_CALLBACK_CANCEL;
+               }
+
+             s = 4;
+             CLDEC(0, major);
+             CLDEC(1, minor);
+             CLDEC(2, ref);
+             CLDEC(3, ref_to);
+             CLDEC(4, response);
+             CLDEC(5, size);
+             if (msg.size < 0) msg.size = 0;
+             /* there is enough data in the buffer for a full message */
+             if ((cl->buf_size - offset) >= (s + msg.size))
+               {
+                  Ecore_Ipc_Event_Client_Data *e2;
+                  Ecore_Ipc_Server *svr;
+                  int max, max2;
+
+                  buf = NULL;
+                  svr = ecore_con_server_data_get(ecore_con_client_server_get(cl->client));
+                  max = svr->max_buf_size;
+                  max2 = cl->max_buf_size;
+                  if ((max >= 0) && (max2 >= 0))
+                    {
+                       if (max2 < max) max = max2;
+                    }
+                  else
+                    {
+                       if (max < 0) max = max2;
+                    }
+                  if ((max < 0) || (msg.size <= max))
+                    {
+                       if (msg.size > 0)
+                         {
+                            buf = malloc(msg.size);
+                            if (!buf) return ECORE_CALLBACK_CANCEL;
+                            memcpy(buf, cl->buf + offset + s, msg.size);
+                         }
+                       if (!cl->delete_me)
+                         {
+                            e2 = calloc(1, sizeof(Ecore_Ipc_Event_Client_Data));
+                            if (e2)
+                              {
+                                 cl->event_count++;
+                                 e2->client   = cl;
+                                 e2->major    = msg.major;
+                                 e2->minor    = msg.minor;
+                                 e2->ref      = msg.ref;
+                                 e2->ref_to   = msg.ref_to;
+                                 e2->response = msg.response;
+                                 e2->size     = msg.size;
+                                 e2->data     = buf;
+                                 ecore_event_add(ECORE_IPC_EVENT_CLIENT_DATA, e2,
+                                                 _ecore_ipc_event_client_data_free,
+                                                 NULL);
+                              }
+                         }
+                    }
+                  cl->prev.i = msg;
+                  offset += (s + msg.size);
+                  if (cl->buf_size == offset)
+                    {
+                       free(cl->buf);
+                       cl->buf = NULL;
+                       cl->buf_size = 0;
+                       return ECORE_CALLBACK_CANCEL;
+                    }
+                  goto redo;
+               }
+             else goto scroll;
+          }
+        else
+          {
+             scroll:
+             buf = malloc(cl->buf_size - offset);
+             if (!buf)
+               {
+                  free(cl->buf);
+                  cl->buf = NULL;
+                  cl->buf_size = 0;
+                  return ECORE_CALLBACK_CANCEL;
+               }
+             memcpy(buf, cl->buf + offset, cl->buf_size - offset);
+             free(cl->buf);
+             cl->buf = buf;
+             cl->buf_size -= offset;
+          }
      }
    return ECORE_CALLBACK_CANCEL;
 }
@@ -1338,34 +1338,34 @@ _ecore_ipc_event_client_data(void *data __UNUSED__, int ev_type __UNUSED__, void
    md = ((head >> (4 * _n)) & 0xf); \
    if (md >= DLT_SET) \
      { \
-       unsigned int v; \
-       unsigned char *dv; \
-       dv = (unsigned char *)&v; \
-       dv[0] = *(svr->buf + offset + s + 0); \
-       dv[1] = *(svr->buf + offset + s + 1); \
-       dv[2] = *(svr->buf + offset + s + 2); \
-       dv[3] = *(svr->buf + offset + s + 3); \
-       d = (int)ntohl(v); \
-       s += 4; \
+        unsigned int v; \
+        unsigned char *dv; \
+        dv = (unsigned char *)&v; \
+        dv[0] = *(svr->buf + offset + s + 0); \
+        dv[1] = *(svr->buf + offset + s + 1); \
+        dv[2] = *(svr->buf + offset + s + 2); \
+        dv[3] = *(svr->buf + offset + s + 3); \
+        d = (int)ntohl(v); \
+        s += 4; \
      } \
    else if (md >= DLT_ADD16) \
      { \
-       unsigned short v; \
-       unsigned char *dv; \
-       dv = (unsigned char *)&v; \
-       dv[0] = *(svr->buf + offset + s + 0); \
-       dv[1] = *(svr->buf + offset + s + 1); \
-       d = (int)ntohs(v); \
-       s += 2; \
+        unsigned short v; \
+        unsigned char *dv; \
+        dv = (unsigned char *)&v; \
+        dv[0] = *(svr->buf + offset + s + 0); \
+        dv[1] = *(svr->buf + offset + s + 1); \
+        d = (int)ntohs(v); \
+        s += 2; \
      } \
    else if (md >= DLT_ADD8) \
      { \
-       unsigned char v; \
-       unsigned char *dv; \
-       dv = (unsigned char *)&v; \
-       dv[0] = *(svr->buf + offset + s + 0); \
-       d = (int)v; \
-       s += 1; \
+        unsigned char v; \
+        unsigned char *dv; \
+        dv = (unsigned char *)&v; \
+        dv[0] = *(svr->buf + offset + s + 0); \
+        d = (int)v; \
+        s += 1; \
      } \
    msg._member = _ecore_ipc_ddlt_int(d, svr->prev.i._member, md);
 
@@ -1378,133 +1378,133 @@ _ecore_ipc_event_server_data(void *data __UNUSED__, int ev_type __UNUSED__, void
    if (!eina_list_data_find(servers, ecore_con_server_data_get(e->server))) return ECORE_CALLBACK_RENEW;
    /* handling code here */
      {
-       Ecore_Ipc_Server *svr;
-       Ecore_Ipc_Msg_Head msg;
-       int offset = 0;
-       unsigned char *buf;
-
-       svr = ecore_con_server_data_get(e->server);
-
-       if (!svr->buf)
-         {
-            svr->buf_size = e->size;
-            svr->buf = e->data;
-            e->data = NULL; /* take it out of the old event */
-         }
-       else
-         {
-            buf = realloc(svr->buf, svr->buf_size + e->size);
-            if (!buf)
-              {
-                 free(svr->buf);
-                 svr->buf = 0;
-                 svr->buf_size  = 0;
-                 return ECORE_CALLBACK_CANCEL;
-              }
-            svr->buf = buf;
-            memcpy(svr->buf + svr->buf_size, e->data, e->size);
-            svr->buf_size += e->size;
-         }
-       /* examine header */
-       redo:
-       if ((svr->buf_size - offset) >= (int)sizeof(int))
-         {
-            int s, md, d = 0, head;
-            unsigned char *dd;
-
-            dd = (unsigned char *)&head;
-            dd[0] = *(svr->buf + offset + 0);
-            dd[1] = *(svr->buf + offset + 1);
-            dd[2] = *(svr->buf + offset + 2);
-            dd[3] = *(svr->buf + offset + 3);
-            head = ntohl(head);
-            dd = (unsigned char *)&d;
-            s = 4;
-            SVSZ(0);
-            SVSZ(1);
-            SVSZ(2);
-            SVSZ(3);
-            SVSZ(4);
-            SVSZ(5);
-            if ((svr->buf_size - offset) < s)
-              {
-                 if (offset > 0) goto scroll;
-                 return ECORE_CALLBACK_CANCEL;
-              }
-
-            s = 4;
-            SVDEC(0, major);
-            SVDEC(1, minor);
-            SVDEC(2, ref);
-            SVDEC(3, ref_to);
-            SVDEC(4, response);
-            SVDEC(5, size);
-            if (msg.size < 0) msg.size = 0;
-            /* there is enough data in the buffer for a full message */
-            if ((svr->buf_size - offset) >= (s + msg.size))
-              {
-                 Ecore_Ipc_Event_Server_Data *e2;
-                 int max;
-
-                 buf = NULL;
-                 max = svr->max_buf_size;
-                 if ((max < 0) || (msg.size <= max))
-                   {
-                      if (msg.size > 0)
-                        {
-                           buf = malloc(msg.size);
-                           if (!buf) return ECORE_CALLBACK_CANCEL;
-                           memcpy(buf, svr->buf + offset + s, msg.size);
-                        }
-                      if (!svr->delete_me)
-                        {
-                           e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Data));
-                           if (e2)
-                             {
-                                svr->event_count++;
-                                e2->server   = svr;
-                                e2->major    = msg.major;
-                                e2->minor    = msg.minor;
-                                e2->ref      = msg.ref;
-                                e2->ref_to   = msg.ref_to;
-                                e2->response = msg.response;
-                                e2->size     = msg.size;
-                                e2->data     = buf;
-                                ecore_event_add(ECORE_IPC_EVENT_SERVER_DATA, e2,
-                                                _ecore_ipc_event_server_data_free,
-                                                NULL);
-                             }
-                        }
-                   }
-                 svr->prev.i = msg;
-                 offset += (s + msg.size);
-                 if (svr->buf_size == offset)
-                   {
-                      free(svr->buf);
-                      svr->buf = NULL;
-                      svr->buf_size = 0;
-                      return ECORE_CALLBACK_CANCEL;
-                   }
-                 goto redo;
-              }
-            else goto scroll;
-         }
-       else
-         {
-            scroll:
-            buf = malloc(svr->buf_size - offset);
-            if (!buf)
-              {
-                 free(svr->buf);
-                 svr->buf = NULL;
-                 svr->buf_size = 0;
-                 return ECORE_CALLBACK_CANCEL;
-              }
-            memcpy(buf, svr->buf + offset, svr->buf_size - offset);
-            free(svr->buf);
-            svr->buf = buf;
-            svr->buf_size -= offset;
-         }
+        Ecore_Ipc_Server *svr;
+        Ecore_Ipc_Msg_Head msg;
+        int offset = 0;
+        unsigned char *buf;
+
+        svr = ecore_con_server_data_get(e->server);
+
+        if (!svr->buf)
+          {
+             svr->buf_size = e->size;
+             svr->buf = e->data;
+             e->data = NULL; /* take it out of the old event */
+          }
+        else
+          {
+             buf = realloc(svr->buf, svr->buf_size + e->size);
+             if (!buf)
+               {
+                  free(svr->buf);
+                  svr->buf = 0;
+                  svr->buf_size  = 0;
+                  return ECORE_CALLBACK_CANCEL;
+               }
+             svr->buf = buf;
+             memcpy(svr->buf + svr->buf_size, e->data, e->size);
+             svr->buf_size += e->size;
+          }
+        /* examine header */
+        redo:
+        if ((svr->buf_size - offset) >= (int)sizeof(int))
+          {
+             int s, md, d = 0, head;
+             unsigned char *dd;
+
+             dd = (unsigned char *)&head;
+             dd[0] = *(svr->buf + offset + 0);
+             dd[1] = *(svr->buf + offset + 1);
+             dd[2] = *(svr->buf + offset + 2);
+             dd[3] = *(svr->buf + offset + 3);
+             head = ntohl(head);
+             dd = (unsigned char *)&d;
+             s = 4;
+             SVSZ(0);
+             SVSZ(1);
+             SVSZ(2);
+             SVSZ(3);
+             SVSZ(4);
+             SVSZ(5);
+             if ((svr->buf_size - offset) < s)
+               {
+                  if (offset > 0) goto scroll;
+                  return ECORE_CALLBACK_CANCEL;
+               }
+
+             s = 4;
+             SVDEC(0, major);
+             SVDEC(1, minor);
+             SVDEC(2, ref);
+             SVDEC(3, ref_to);
+             SVDEC(4, response);
+             SVDEC(5, size);
+             if (msg.size < 0) msg.size = 0;
+             /* there is enough data in the buffer for a full message */
+             if ((svr->buf_size - offset) >= (s + msg.size))
+               {
+                  Ecore_Ipc_Event_Server_Data *e2;
+                  int max;
+
+                  buf = NULL;
+                  max = svr->max_buf_size;
+                  if ((max < 0) || (msg.size <= max))
+                    {
+                       if (msg.size > 0)
+                         {
+                            buf = malloc(msg.size);
+                            if (!buf) return ECORE_CALLBACK_CANCEL;
+                            memcpy(buf, svr->buf + offset + s, msg.size);
+                         }
+                       if (!svr->delete_me)
+                         {
+                            e2 = calloc(1, sizeof(Ecore_Ipc_Event_Server_Data));
+                            if (e2)
+                              {
+                                 svr->event_count++;
+                                 e2->server   = svr;
+                                 e2->major    = msg.major;
+                                 e2->minor    = msg.minor;
+                                 e2->ref      = msg.ref;
+                                 e2->ref_to   = msg.ref_to;
+                                 e2->response = msg.response;
+                                 e2->size     = msg.size;
+                                 e2->data     = buf;
+                                 ecore_event_add(ECORE_IPC_EVENT_SERVER_DATA, e2,
+                                                 _ecore_ipc_event_server_data_free,
+                                                 NULL);
+                              }
+                         }
+                    }
+                  svr->prev.i = msg;
+                  offset += (s + msg.size);
+                  if (svr->buf_size == offset)
+                    {
+                       free(svr->buf);
+                       svr->buf = NULL;
+                       svr->buf_size = 0;
+                       return ECORE_CALLBACK_CANCEL;
+                    }
+                  goto redo;
+               }
+             else goto scroll;
+          }
+        else
+          {
+             scroll:
+             buf = malloc(svr->buf_size - offset);
+             if (!buf)
+               {
+                  free(svr->buf);
+                  svr->buf = NULL;
+                  svr->buf_size = 0;
+                  return ECORE_CALLBACK_CANCEL;
+               }
+             memcpy(buf, svr->buf + offset, svr->buf_size - offset);
+             free(svr->buf);
+             svr->buf = buf;
+             svr->buf_size -= offset;
+          }
      }
    return ECORE_CALLBACK_CANCEL;
 }

diff --git a/src/lib/ecore_sdl/ecore_sdl.c b/src/lib/ecore_sdl/ecore_sdl.c
index 766bf30..5a95cbf 100644 (file)
--- a/src/lib/ecore_sdl/ecore_sdl.c
+++ b/src/lib/ecore_sdl/ecore_sdl.c
@@ -34,17 +34,17 @@ static Eina_Rbtree *repeat = NULL;
 
 static Eina_Rbtree_Direction
 _ecore_sdl_pressed_key(const Ecore_SDL_Pressed *left,
-                      const Ecore_SDL_Pressed *right,
-                      __UNUSED__ void *data)
+                       const Ecore_SDL_Pressed *right,
+                       __UNUSED__ void *data)
 {
    return left->key < right->key ? EINA_RBTREE_LEFT : EINA_RBTREE_RIGHT;
 }
 
 static int
 _ecore_sdl_pressed_node(const Ecore_SDL_Pressed *node,
-                       const SDLKey *key,
-                       __UNUSED__ int length,
-                       __UNUSED__ void *data)
+                        const SDLKey *key,
+                        __UNUSED__ int length,
+                        __UNUSED__ void *data)
 {
    return node->key - *key;
 }
@@ -139,10 +139,10 @@ _ecore_sdl_event_key(SDL_Event *event, double time)
    for (i = 0; i < sizeof(keystable) / sizeof(struct _ecore_sdl_keys_s); ++i)
      if (keystable[i].code == event->key.keysym.sym)
        {
-         ev->keyname = keystable[i].name;
-         ev->string = keystable[i].compose;
+          ev->keyname = keystable[i].name;
+          ev->string = keystable[i].compose;
 
-         return ev;
+          return ev;
        }
 
    free(ev);
@@ -162,18 +162,18 @@ ecore_sdl_feed_events(void)
           {
           case SDL_MOUSEMOTION:
           {
-            Ecore_Event_Mouse_Move *ev;
+             Ecore_Event_Mouse_Move *ev;
 
-            ev = malloc(sizeof(Ecore_Event_Mouse_Move));
-            if (!ev) return ;
+             ev = malloc(sizeof(Ecore_Event_Mouse_Move));
+             if (!ev) return ;
 
-            ev->timestamp = time;
-            ev->window = 0;
-            ev->modifiers = 0; /* FIXME: keep modifier around. */
+             ev->timestamp = time;
+             ev->window = 0;
+             ev->modifiers = 0; /* FIXME: keep modifier around. */
              ev->x = event.motion.x;
              ev->y = event.motion.y;
-            ev->root.x = ev->x;
-            ev->root.y = ev->y;
+             ev->root.x = ev->x;
+             ev->root.y = ev->y;
 
              ecore_event_add(ECORE_EVENT_MOUSE_MOVE, ev, NULL, NULL);
              break;
@@ -186,11 +186,11 @@ ecore_sdl_feed_events(void)
                   Ecore_Event_Mouse_Wheel *ev;
 
                   ev = malloc(sizeof(Ecore_Event_Mouse_Wheel));
-                 if (!ev) return ;
+                  if (!ev) return ;
 
-                 ev->timestamp = time;
-                 ev->window = 0;
-                 ev->modifiers = 0; /* FIXME: keep modifier around. */
+                  ev->timestamp = time;
+                  ev->window = 0;
+                  ev->modifiers = 0; /* FIXME: keep modifier around. */
                   ev->direction = 0;
                   ev->z = event.button.button == SDL_BUTTON_WHEELDOWN ? -1 : 1;
 
@@ -201,11 +201,11 @@ ecore_sdl_feed_events(void)
                   Ecore_Event_Mouse_Button *ev;
 
                   ev = malloc(sizeof(Ecore_Event_Mouse_Button));
-                 if (!ev) return ;
+                  if (!ev) return ;
 
-                 ev->timestamp = time;
-                 ev->window = 0;
-                 ev->modifiers = 0; /* FIXME: keep modifier around. */
+                  ev->timestamp = time;
+                  ev->window = 0;
+                  ev->modifiers = 0; /* FIXME: keep modifier around. */
                   ev->buttons = event.button.button;
                   ev->double_click = 0;
                   ev->triple_click = 0;
@@ -219,10 +219,10 @@ ecore_sdl_feed_events(void)
              Ecore_Event_Mouse_Button *ev;
 
              ev = malloc(sizeof(Ecore_Event_Mouse_Button));
-            if (!ev) return ;
-            ev->timestamp = time;
-            ev->window = 0;
-            ev->modifiers = 0; /* FIXME: keep modifier around. */
+             if (!ev) return ;
+             ev->timestamp = time;
+             ev->window = 0;
+             ev->modifiers = 0; /* FIXME: keep modifier around. */
              ev->buttons = event.button.button;
              ev->double_click = 0;
              ev->triple_click = 0;
@@ -250,48 +250,48 @@ ecore_sdl_feed_events(void)
 
           case SDL_KEYDOWN:
           {
-            Ecore_SDL_Pressed *entry;
+             Ecore_SDL_Pressed *entry;
              Ecore_Event_Key *ev;
 
-            entry = (Ecore_SDL_Pressed*) eina_rbtree_inline_lookup(repeat, &event.key.keysym.sym, sizeof (event.key.keysym.sym),
-                                                                   EINA_RBTREE_CMP_KEY_CB(_ecore_sdl_pressed_node), NULL);
-            if (entry)
-              {
-                 ev = _ecore_sdl_event_key(&event, time);
-                 if (ev) ecore_event_add(ECORE_EVENT_KEY_UP, ev, NULL, NULL);
-              }
+             entry = (Ecore_SDL_Pressed*) eina_rbtree_inline_lookup(repeat, &event.key.keysym.sym, sizeof (event.key.keysym.sym),
+                                                                    EINA_RBTREE_CMP_KEY_CB(_ecore_sdl_pressed_node), NULL);
+             if (entry)
+               {
+                  ev = _ecore_sdl_event_key(&event, time);
+                  if (ev) ecore_event_add(ECORE_EVENT_KEY_UP, ev, NULL, NULL);
+               }
 
-            ev = _ecore_sdl_event_key(&event, time);
-            if (ev) ecore_event_add(ECORE_EVENT_KEY_DOWN, ev, NULL, NULL);
+             ev = _ecore_sdl_event_key(&event, time);
+             if (ev) ecore_event_add(ECORE_EVENT_KEY_DOWN, ev, NULL, NULL);
 
-            if (!entry)
-              {
-                 entry = malloc(sizeof (Ecore_SDL_Pressed));
-                 if (!entry) break;
+             if (!entry)
+               {
+                  entry = malloc(sizeof (Ecore_SDL_Pressed));
+                  if (!entry) break;
 
-                 entry->key = event.key.keysym.sym;
+                  entry->key = event.key.keysym.sym;
 
-                 repeat = eina_rbtree_inline_insert(repeat, EINA_RBTREE_GET(entry),
-                                                    EINA_RBTREE_CMP_NODE_CB(_ecore_sdl_pressed_key), NULL);
-              }
+                  repeat = eina_rbtree_inline_insert(repeat, EINA_RBTREE_GET(entry),
+                                                     EINA_RBTREE_CMP_NODE_CB(_ecore_sdl_pressed_key), NULL);
+               }
              break;
           }
           case SDL_KEYUP:
           {
              Ecore_Event_Key *ev;
-            Ecore_SDL_Pressed *entry;
-
-            entry = (Ecore_SDL_Pressed*) eina_rbtree_inline_lookup(repeat, &event.key.keysym.sym, sizeof (event.key.keysym.sym),
-                                                                   EINA_RBTREE_CMP_KEY_CB(_ecore_sdl_pressed_node), NULL);
-            if (entry)
-              {
-                 repeat = eina_rbtree_inline_remove(repeat, EINA_RBTREE_GET(entry),
-                                                    EINA_RBTREE_CMP_NODE_CB(_ecore_sdl_pressed_key), NULL);
-                 free(entry);
-              }
-
-            ev = _ecore_sdl_event_key(&event, time);
-            if (ev) ecore_event_add(ECORE_EVENT_KEY_UP, ev, NULL, NULL);
+             Ecore_SDL_Pressed *entry;
+
+             entry = (Ecore_SDL_Pressed*) eina_rbtree_inline_lookup(repeat, &event.key.keysym.sym, sizeof (event.key.keysym.sym),
+                                                                    EINA_RBTREE_CMP_KEY_CB(_ecore_sdl_pressed_node), NULL);
+             if (entry)
+               {
+                  repeat = eina_rbtree_inline_remove(repeat, EINA_RBTREE_GET(entry),
+                                                     EINA_RBTREE_CMP_NODE_CB(_ecore_sdl_pressed_key), NULL);
+                  free(entry);
+               }
+
+             ev = _ecore_sdl_event_key(&event, time);
+             if (ev) ecore_event_add(ECORE_EVENT_KEY_UP, ev, NULL, NULL);
              break;
           }
           case SDL_ACTIVEEVENT: