Fix code style and some new compilation warnings.

1 files changed, 188 insertions, 161 deletions

diff --git a/src/utils/copynpaste.cpp b/src/utils/copynpaste.cpp
index 498c012b5..1107400e1 100644
--- a/src/utils/copynpaste.cpp
+++ b/src/utils/copynpaste.cpp
@@ -36,55 +36,57 @@
 #include "copynpaste.h"
 
 #ifdef WIN32
-bool RetrieveBuffer(std::string& text, std::string::size_type& pos)
+bool retrieveBuffer(std::string& text, std::string::size_type& pos)
 {
-  bool  ret = false;
+    bool  ret = false;
 
-  if (!OpenClipboard(NULL))
-    return false;
-
-  HANDLE  h = GetClipboardData(CF_UNICODETEXT);
-  if (h)
-  {
-    LPCWSTR data = (LPCWSTR)GlobalLock(h);
+    if (!OpenClipboard(NULL))
+        return false;
 
-    if (data)
+    HANDLE  h = GetClipboardData(CF_UNICODETEXT);
+    if (h)
     {
-      int len = WideCharToMultiByte(CP_UTF8, 0, data, -1, NULL, 0, NULL, NULL);
-      if (len > 0)
-      {
-        // Convert from UTF-16 to UTF-8
-        void *temp = malloc(len);
-        if (WideCharToMultiByte(CP_UTF8, 0, data, -1, (LPSTR)temp, len, NULL, NULL))
+        LPCWSTR data = (LPCWSTR)GlobalLock(h);
+
+        if (data)
         {
-          text.insert(pos, (char*)temp);
-          pos += len-1;
+            int len = WideCharToMultiByte(CP_UTF8, 0, data, -1,
+                NULL, 0, NULL, NULL);
+            if (len > 0)
+            {
+                // Convert from UTF-16 to UTF-8
+                void *temp = malloc(len);
+                if (WideCharToMultiByte(CP_UTF8, 0, data, -1,
+                    (LPSTR)temp, len, NULL, NULL))
+                {
+                    text.insert(pos, (char*)temp);
+                    pos += len-1;
+                }
+                free(temp);
+                ret = true;
+            }
         }
-        free(temp);
-        ret = true;
-      }
+        GlobalUnlock(h);
     }
-    GlobalUnlock(h);
-  }
-  else
-  {
-    h = GetClipboardData(CF_TEXT);
-
-    if (h)
+    else
     {
-      const char *data = (char*)GlobalLock(h);
-      if (data)
-      {
-        text.insert(pos, data);
-        pos += strlen(data);
-        ret = true;
-      }
-      GlobalUnlock(h);
+        h = GetClipboardData(CF_TEXT);
+
+        if (h)
+        {
+            const char *data = (char*)GlobalLock(h);
+            if (data)
+            {
+                text.insert(pos, data);
+                pos += strlen(data);
+                ret = true;
+            }
+            GlobalUnlock(h);
+        }
     }
-  }
 
-  CloseClipboard();
-  return ret;
+    CloseClipboard();
+    return ret;
 }
 #elif defined(__APPLE__)
 
@@ -94,99 +96,120 @@ bool RetrieveBuffer(std::string& text, std::string::size_type& pos)
 
 #include <Carbon/Carbon.h>
 
-// Sorry for the very long code, all nicer OS X APIs are coded in Objective C and not C!
+// Sorry for the very long code, all nicer OS X APIs are coded in
+// Objective C and not C!
 // Also it does very thorough error handling
-bool GetDataFromPasteboard( PasteboardRef inPasteboard, char* flavorText /* out */, const int bufSize )
+bool getDataFromPasteboard(PasteboardRef inPasteboard,
+                           char* flavorText /* out */,
+                           const int bufSize)
 {
     OSStatus            err = noErr;
     PasteboardSyncFlags syncFlags;
     ItemCount           itemCount;
 
-    syncFlags = PasteboardSynchronize( inPasteboard );
+    syncFlags = PasteboardSynchronize(inPasteboard);
 
     //require_action( syncFlags & kPasteboardModified, PasteboardOutOfSync,
     //               err = badPasteboardSyncErr );
 
-    err = PasteboardGetItemCount( inPasteboard, &itemCount );
-    require_noerr( err, CantGetPasteboardItemCount );
+    err = PasteboardGetItemCount(inPasteboard, &itemCount);
+    require_noerr(err, CantGetPasteboardItemCount);
 
-    for (UInt32 itemIndex = 1; itemIndex <= itemCount; itemIndex++)
+    for (UInt32 itemIndex = 1; itemIndex <= itemCount; itemIndex ++)
     {
         PasteboardItemID    itemID;
         CFArrayRef          flavorTypeArray;
         CFIndex             flavorCount;
 
-        err = PasteboardGetItemIdentifier( inPasteboard, itemIndex, &itemID );
-        require_noerr( err, CantGetPasteboardItemIdentifier );
+        err = PasteboardGetItemIdentifier(inPasteboard, itemIndex, &itemID);
+        require_noerr(err, CantGetPasteboardItemIdentifier);
 
-        err = PasteboardCopyItemFlavors( inPasteboard, itemID, &flavorTypeArray );
-        require_noerr( err, CantCopyPasteboardItemFlavors );
+        err = PasteboardCopyItemFlavors(inPasteboard,
+            itemID, &flavorTypeArray);
+        require_noerr(err, CantCopyPasteboardItemFlavors);
 
-        flavorCount = CFArrayGetCount( flavorTypeArray );
+        flavorCount = CFArrayGetCount(flavorTypeArray);
 
-        for (CFIndex flavorIndex = 0; flavorIndex < flavorCount; flavorIndex++)
+        for (CFIndex flavorIndex = 0; flavorIndex < flavorCount;
+             flavorIndex ++)
         {
             CFStringRef             flavorType;
             CFDataRef               flavorData;
             CFIndex                 flavorDataSize;
-            flavorType = (CFStringRef)CFArrayGetValueAtIndex(flavorTypeArray, flavorIndex);
+            flavorType = (CFStringRef)CFArrayGetValueAtIndex(
+                flavorTypeArray, flavorIndex);
 
             // we're only interested by text...
             if (UTTypeConformsTo(flavorType, CFSTR("public.utf8-plain-text")))
             {
-                err = PasteboardCopyItemFlavorData( inPasteboard, itemID,
-                                                   flavorType, &flavorData );
-                require_noerr( err, CantCopyFlavorData );
-                flavorDataSize = CFDataGetLength( flavorData );
+                err = PasteboardCopyItemFlavorData(inPasteboard, itemID,
+                                                   flavorType, &flavorData);
+                require_noerr(err, CantCopyFlavorData);
+                flavorDataSize = CFDataGetLength(flavorData);
                 flavorDataSize = (flavorDataSize<254) ? flavorDataSize : 254;
 
-                if (flavorDataSize+2 > bufSize)
+                if (flavorDataSize + 2 > bufSize)
                 {
-                    fprintf(stderr, "Cannot copy clipboard, contents is too big!\n");
+                    fprintf(stderr,
+                        "Cannot copy clipboard, contents is too big!\n");
                     return false;
                 }
 
-                for (short dataIndex = 0; dataIndex <= flavorDataSize; dataIndex++)
+                for (short dataIndex = 0; dataIndex <= flavorDataSize;
+                     dataIndex ++)
                 {
-                    char byte = *(CFDataGetBytePtr( flavorData ) + dataIndex);
+                    char byte = *(CFDataGetBytePtr(flavorData) + dataIndex);
                     flavorText[dataIndex] = byte;
                 }
 
                 flavorText[flavorDataSize] = '\0';
-                flavorText[flavorDataSize+1] = '\n';
+                flavorText[flavorDataSize + 1] = '\n';
 
                 CFRelease (flavorData);
                 return true;
             }
 
             continue;
-            CantCopyFlavorData:   fprintf(stderr, "Cannot copy clipboard, CantCopyFlavorData!\n");
+CantCopyFlavorData:
+            fprintf(stderr, "Cannot copy clipboard, CantCopyFlavorData!\n");
         }
 
         CFRelease (flavorTypeArray);
         continue;
 
-    CantCopyPasteboardItemFlavors:   fprintf(stderr, "Cannot copy clipboard, CantCopyPasteboardItemFlavors!\n");   continue;
-    CantGetPasteboardItemIdentifier: fprintf(stderr, "Cannot copy clipboard, CantGetPasteboardItemIdentifier!\n"); continue;
+CantCopyPasteboardItemFlavors:
+        fprintf(stderr,
+            "Cannot copy clipboard, CantCopyPasteboardItemFlavors!\n");
+        continue;
+CantGetPasteboardItemIdentifier:
+        fprintf(stderr,
+            "Cannot copy clipboard, CantGetPasteboardItemIdentifier!\n");
+        continue;
     }
-    fprintf(stderr, "Cannot copy clipboard, found no acceptable flavour!\n");
+    fprintf(stderr,
+        "Cannot copy clipboard, found no acceptable flavour!\n");
     return false;
 
-    CantGetPasteboardItemCount:  fprintf(stderr, "Cannot copy clipboard, CantGetPasteboardItemCount!\n"); return false;
-    //PasteboardOutOfSync:         fprintf(stderr, "Cannot copy clipboard, PasteboardOutOfSync!\n");        return false;
+CantGetPasteboardItemCount:
+    fprintf(stderr, "Cannot copy clipboard, CantGetPasteboardItemCount!\n");
+    return false;
+//PasteboardOutOfSync:
+//    fprintf(stderr, "Cannot copy clipboard, PasteboardOutOfSync!\n");
+//      return false;
 }
 
-bool getClipBoard(char* text /* out */, const int bufSize )
+bool getClipBoard(char* text /* out */, const int bufSize)
 {
     OSStatus err = noErr;
 
     PasteboardRef theClipboard;
-    err = PasteboardCreate( kPasteboardClipboard, &theClipboard );
-    require_noerr( err, PasteboardCreateFailed );
+    err = PasteboardCreate(kPasteboardClipboard, &theClipboard);
+    require_noerr(err, PasteboardCreateFailed);
 
-    if (!GetDataFromPasteboard(theClipboard, text, bufSize))
+    if (!getDataFromPasteboard(theClipboard, text, bufSize))
     {
-        fprintf(stderr, "Cannot copy clipboard, GetDataFromPasteboardFailed!\n");
+        fprintf(stderr,
+            "Cannot copy clipboard, getDataFromPasteboardFailed!\n");
         return false;
     }
 
@@ -195,15 +218,16 @@ bool getClipBoard(char* text /* out */, const int bufSize )
     return true;
 
     // ---- error handling
-    PasteboardCreateFailed:       fprintf(stderr, "Cannot copy clipboard, PasteboardCreateFailed!\n");
+PasteboardCreateFailed:
+    fprintf(stderr, "Cannot copy clipboard, PasteboardCreateFailed!\n");
     CFRelease(theClipboard);
     return false;
 }
 
-bool RetrieveBuffer(std::string& text, std::string::size_type& pos)
+bool retrieveBuffer(std::string& text, std::string::size_type& pos)
 {
     const int bufSize = 512;
-    char buffer[bufSize+1];
+    char buffer[bufSize + 1];
 
     if (getClipBoard(buffer, bufSize))
     {
@@ -220,105 +244,108 @@ bool RetrieveBuffer(std::string& text, std::string::size_type& pos)
 #elif USE_X11
 static char* getSelection(Display *dpy, Window us, Atom selection)
 {
-  int    max_events = 50;
-  Window owner      = XGetSelectionOwner (dpy, selection);
-  int    ret;
-
-  //printf("XConvertSelection on %s\n", XGetAtomName(dpy, selection));
-  if (owner == None)
-  {
-    //printf("No owner\n");
-    return NULL;
-  }
-  XConvertSelection(dpy, selection, XA_STRING, XA_PRIMARY, us, CurrentTime);
-  XFlush(dpy);
-
-  while (max_events--)
-  {
-    XEvent        e;
+    int max_events = 50;
+    Window owner = XGetSelectionOwner(dpy, selection);
+    int ret;
 
-    XNextEvent(dpy, &e);
-    if(e.type == SelectionNotify)
+    //printf("XConvertSelection on %s\n", XGetAtomName(dpy, selection));
+    if (owner == None)
     {
-      //printf("Received %s\n", XGetAtomName(dpy, e.xselection.selection));
-      if(e.xselection.property == None)
-      {
-        //printf("Couldn't convert\n");
-        return NULL;
-      }
-
-      long unsigned len, left, dummy;
-      int           format;
-      Atom          type;
-      unsigned char *data = NULL;
-
-      ret = XGetWindowProperty(dpy, us, e.xselection.property, 0, 0, False,
-                               AnyPropertyType, &type, &format, &len, &left,
-                               &data);
-      if (left < 1)
-      {
-        if (ret == Success)
-          XFree(data);
-        return NULL;
-      }
-
-      ret = XGetWindowProperty(dpy, us, e.xselection.property, 0, left, False,
-                               AnyPropertyType, &type, &format, &len, &dummy,
-                               &data);
-      if (ret != Success)
-      {
-        //printf("Failed to get property: %p on %lu\n", data, len);
+        //printf("No owner\n");
         return NULL;
-      }
+    }
+    XConvertSelection(dpy, selection, XA_STRING, XA_PRIMARY, us, CurrentTime);
+    XFlush(dpy);
+
+    while (max_events --)
+    {
+        XEvent e;
+
+        XNextEvent(dpy, &e);
+        if (e.type == SelectionNotify)
+        {
+            //printf("Received %s\n", XGetAtomName(dpy, e.xselection.selection));
+            if (e.xselection.property == None)
+            {
+                //printf("Couldn't convert\n");
+                return NULL;
+            }
 
-      //printf(">>>  Got %s: len=%lu left=%lu (event %i)\n", data, len, left, 50-max_events);
-      return (char*)data;
+            long unsigned len, left, dummy;
+            int format;
+            Atom type;
+            unsigned char *data = NULL;
+
+            ret = XGetWindowProperty(dpy, us, e.xselection.property, 0, 0,
+                False, AnyPropertyType, &type, &format, &len, &left, &data);
+            if (left < 1)
+            {
+                if (ret == Success)
+                XFree(data);
+                return NULL;
+            }
+
+            ret = XGetWindowProperty(dpy, us, e.xselection.property, 0,
+                left, False, AnyPropertyType, &type, &format, &len,
+                &dummy, &data);
+
+            if (ret != Success)
+            {
+                //printf("Failed to get property: %p on %lu\n", data, len);
+                return NULL;
+            }
+
+            //printf(">>>  Got %s: len=%lu left=%lu (event %i)\n", data,
+            //    len, left, 50-max_events);
+            return (char*)data;
+        }
     }
-  }
-  return NULL;
+    return NULL;
 }
 
-bool RetrieveBuffer(std::string& text, std::string::size_type& pos)
+bool retrieveBuffer(std::string& text, std::string::size_type& pos)
 {
-  SDL_SysWMinfo info;
+    SDL_SysWMinfo info;
 
-  //printf("Retrieving buffer...\n");
-  SDL_VERSION(&info.version);
-  if ( SDL_GetWMInfo(&info) )
-  {
-    Display *dpy  = info.info.x11.display;
-    Window  us    = info.info.x11.window;
-    char    *data = NULL;
-
-    if (!data)
-    {
-      data = getSelection(dpy, us, XA_PRIMARY);
-    }
-    if (!data)
-    {
-      data = getSelection(dpy, us, XA_SECONDARY);
-    }
-    if (!data)
+    //printf("Retrieving buffer...\n");
+    SDL_VERSION(&info.version);
+    if (SDL_GetWMInfo(&info))
     {
-      Atom XA_CLIPBOARD = XInternAtom(dpy, "CLIPBOARD", 0);
-      data = getSelection(dpy, us, XA_CLIPBOARD);
-    }
-    if (data)
-    {
-      // check cursor position
-      if (pos > text.size()) {
-        pos = text.size();
-      }
+        Display *dpy = info.info.x11.display;
+        Window us = info.info.x11.window;
+        char *data = NULL;
 
-      text.insert(pos, data);
-      pos += strlen(data);
-      XFree(data);
+        if (!data)
+        {
+            data = getSelection(dpy, us, XA_PRIMARY);
+        }
+        if (!data)
+        {
+            data = getSelection(dpy, us, XA_SECONDARY);
+        }
+        if (!data)
+        {
+            Atom XA_CLIPBOARD = XInternAtom(dpy, "CLIPBOARD", 0);
+            data = getSelection(dpy, us, XA_CLIPBOARD);
+        }
+        if (data)
+        {
+            // check cursor position
+            if (pos > text.size())
+                pos = text.size();
+
+            text.insert(pos, data);
+            pos += strlen(data);
+            XFree(data);
 
-      return true;
+            return true;
+        }
     }
-  }
-  return false;
+    return false;
 }
 #else
-bool RetrieveBuffer(std::string&, std::string::size_type&) { return false; }
+bool retrieveBuffer(std::string&, std::string::size_type&)
+{
+    return false;
+}
 #endif