1 files changed, 277 insertions, 196 deletions
diff --git a/hw/dmx/config/dmxparse.c b/hw/dmx/config/dmxparse.c
index 35f1c2185..cf510844d 100644
--- a/hw/dmx/config/dmxparse.c
+++ b/hw/dmx/config/dmxparse.c
@@ -52,10 +52,11 @@
 
 /** A general error logging routine that does not depend on the dmxLog
  * functions. */
-void dmxConfigLog(const char *format, ...)
+void
+dmxConfigLog(const char *format, ...)
 {
     va_list args;
-    
+
     va_start(args, format);
     vprintf(format, args);      /* RATS: All calls to dmxConfigLog from
                                  * dmxparse.c and dmxprint.c use a
@@ -63,9 +64,11 @@ void dmxConfigLog(const char *format, ...)
     va_end(args);
 }
 
-void *dmxConfigAlloc(unsigned long bytes)
+void *
+dmxConfigAlloc(unsigned long bytes)
 {
     void *area = calloc(1, bytes);
+
     if (!area) {
         dmxConfigLog("dmxConfigAlloc: out of memory\n");
         return NULL;
@@ -73,10 +76,11 @@ void *dmxConfigAlloc(unsigned long bytes)
     return area;
 }
 
-void *dmxConfigRealloc(void *orig, unsigned long orig_bytes,
-                       unsigned long bytes)
+void *
+dmxConfigRealloc(void *orig, unsigned long orig_bytes, unsigned long bytes)
 {
     unsigned char *area = realloc(orig, bytes);
+
     if (!area) {
         dmxConfigLog("dmxConfigRealloc: out of memory\n");
         return NULL;
@@ -85,216 +89,237 @@ void *dmxConfigRealloc(void *orig, unsigned long orig_bytes,
     return area;
 }
 
-const char *dmxConfigCopyString(const char *string, int length)
+const char *
+dmxConfigCopyString(const char *string, int length)
 {
     char *copy;
-    
-    if (!length) length = strlen(string);
+
+    if (!length)
+        length = strlen(string);
     copy = dmxConfigAlloc(length + 1);
-    if (length) strncpy(copy, string, length);
+    if (length)
+        strncpy(copy, string, length);
     copy[length] = '\0';
     return copy;
 }
 
-void dmxConfigFree(void *area)
+void
+dmxConfigFree(void *area)
 {
     free(area);
 }
 
-DMXConfigTokenPtr dmxConfigCreateToken(int token, int line,
-                                       const char *comment)
+DMXConfigTokenPtr
+dmxConfigCreateToken(int token, int line, const char *comment)
 {
     DMXConfigTokenPtr pToken = dmxConfigAlloc(sizeof(*pToken));
-    pToken->token   = token;
-    pToken->line    = line;
+
+    pToken->token = token;
+    pToken->line = line;
     pToken->comment = comment;
     return pToken;
 }
 
-void dmxConfigFreeToken(DMXConfigTokenPtr p)
+void
+dmxConfigFreeToken(DMXConfigTokenPtr p)
 {
-    if (!p) return;
-    dmxConfigFree((void *)p->comment);
+    if (!p)
+        return;
+    dmxConfigFree((void *) p->comment);
     dmxConfigFree(p);
 }
 
-DMXConfigStringPtr dmxConfigCreateString(int token, int line,
-                                         const char *comment,
-                                         const char *string)
+DMXConfigStringPtr
+dmxConfigCreateString(int token, int line,
+                      const char *comment, const char *string)
 {
     DMXConfigStringPtr pString = dmxConfigAlloc(sizeof(*pString));
 
-    pString->token   = token;
-    pString->line    = line;
+    pString->token = token;
+    pString->line = line;
     pString->comment = comment;
-    pString->string  = string;
+    pString->string = string;
     return pString;
 }
 
-void dmxConfigFreeString(DMXConfigStringPtr p)
+void
+dmxConfigFreeString(DMXConfigStringPtr p)
 {
     DMXConfigStringPtr next;
 
-    if (!p) return;
+    if (!p)
+        return;
     do {
         next = p->next;
-        dmxConfigFree((void *)p->comment);
-        dmxConfigFree((void *)p->string);
+        dmxConfigFree((void *) p->comment);
+        dmxConfigFree((void *) p->string);
         dmxConfigFree(p);
     } while ((p = next));
 }
- 
-DMXConfigNumberPtr dmxConfigCreateNumber(int token, int line,
-                                         const char *comment,
-                                         int number)
+
+DMXConfigNumberPtr
+dmxConfigCreateNumber(int token, int line, const char *comment, int number)
 {
     DMXConfigNumberPtr pNumber = dmxConfigAlloc(sizeof(*pNumber));
 
-    pNumber->token   = token;
-    pNumber->line    = line;
+    pNumber->token = token;
+    pNumber->line = line;
     pNumber->comment = comment;
-    pNumber->number  = number;
+    pNumber->number = number;
     return pNumber;
 }
 
-void dmxConfigFreeNumber(DMXConfigNumberPtr p)
+void
+dmxConfigFreeNumber(DMXConfigNumberPtr p)
 {
-    if (!p) return;
-    dmxConfigFree((void *)p->comment);
+    if (!p)
+        return;
+    dmxConfigFree((void *) p->comment);
     dmxConfigFree(p);
 }
 
-DMXConfigPairPtr dmxConfigCreatePair(int token, int line,
-                                     const char *comment,
-                                     int x, int y,
-                                     int xsign, int ysign)
+DMXConfigPairPtr
+dmxConfigCreatePair(int token, int line,
+                    const char *comment, int x, int y, int xsign, int ysign)
 {
     DMXConfigPairPtr pPair = dmxConfigAlloc(sizeof(*pPair));
 
-    pPair->token   = token;
-    pPair->line    = line;
+    pPair->token = token;
+    pPair->line = line;
     pPair->comment = comment;
-    pPair->x       = x;
-    pPair->y       = y;
-    pPair->xsign   = (xsign < 0) ? -1 : 1;
-    pPair->ysign   = (ysign < 0) ? -1 : 1;
+    pPair->x = x;
+    pPair->y = y;
+    pPair->xsign = (xsign < 0) ? -1 : 1;
+    pPair->ysign = (ysign < 0) ? -1 : 1;
     return pPair;
 }
 
-void dmxConfigFreePair(DMXConfigPairPtr p)
+void
+dmxConfigFreePair(DMXConfigPairPtr p)
 {
-    if (!p) return;
-    dmxConfigFree((void *)p->comment);
+    if (!p)
+        return;
+    dmxConfigFree((void *) p->comment);
     dmxConfigFree(p);
 }
 
-DMXConfigCommentPtr dmxConfigCreateComment(int token, int line,
-                                           const char *comment)
+DMXConfigCommentPtr
+dmxConfigCreateComment(int token, int line, const char *comment)
 {
     DMXConfigCommentPtr pComment = dmxConfigAlloc(sizeof(*pComment));
 
-    pComment->token   = token;
-    pComment->line    = line;
+    pComment->token = token;
+    pComment->line = line;
     pComment->comment = comment;
     return pComment;
 }
 
-void dmxConfigFreeComment(DMXConfigCommentPtr p)
+void
+dmxConfigFreeComment(DMXConfigCommentPtr p)
 {
-    if (!p) return;
-    dmxConfigFree((void *)p->comment);
+    if (!p)
+        return;
+    dmxConfigFree((void *) p->comment);
     dmxConfigFree(p);
 }
 
-DMXConfigPartDimPtr dmxConfigCreatePartDim(DMXConfigPairPtr pDim,
-                                           DMXConfigPairPtr pOffset)
+DMXConfigPartDimPtr
+dmxConfigCreatePartDim(DMXConfigPairPtr pDim, DMXConfigPairPtr pOffset)
 {
     DMXConfigPartDimPtr pPart = dmxConfigAlloc(sizeof(*pPart));
-    pPart->dim    = pDim;
+
+    pPart->dim = pDim;
     pPart->offset = pOffset;
     return pPart;
 }
 
-void dmxConfigFreePartDim(DMXConfigPartDimPtr p)
+void
+dmxConfigFreePartDim(DMXConfigPartDimPtr p)
 {
-    if (!p) return;
+    if (!p)
+        return;
     dmxConfigFreePair(p->dim);
     dmxConfigFreePair(p->offset);
     dmxConfigFree(p);
 }
 
-DMXConfigFullDimPtr dmxConfigCreateFullDim(DMXConfigPartDimPtr pScrn,
-                                           DMXConfigPartDimPtr pRoot)
+DMXConfigFullDimPtr
+dmxConfigCreateFullDim(DMXConfigPartDimPtr pScrn, DMXConfigPartDimPtr pRoot)
 {
     DMXConfigFullDimPtr pFull = dmxConfigAlloc(sizeof(*pFull));
+
     pFull->scrn = pScrn;
     pFull->root = pRoot;
     return pFull;
 }
 
-void dmxConfigFreeFullDim(DMXConfigFullDimPtr p)
+void
+dmxConfigFreeFullDim(DMXConfigFullDimPtr p)
 {
-    if (!p) return;
+    if (!p)
+        return;
     dmxConfigFreePartDim(p->scrn);
     dmxConfigFreePartDim(p->root);
     dmxConfigFree(p);
 }
 
-DMXConfigDisplayPtr dmxConfigCreateDisplay(DMXConfigTokenPtr pStart,
-                                           DMXConfigStringPtr pName,
-                                           DMXConfigFullDimPtr pDim,
-                                           DMXConfigPairPtr pOrigin,
-                                           DMXConfigTokenPtr pEnd)
+DMXConfigDisplayPtr
+dmxConfigCreateDisplay(DMXConfigTokenPtr pStart,
+                       DMXConfigStringPtr pName,
+                       DMXConfigFullDimPtr pDim,
+                       DMXConfigPairPtr pOrigin, DMXConfigTokenPtr pEnd)
 {
     DMXConfigDisplayPtr pDisplay = dmxConfigAlloc(sizeof(*pDisplay));
 
-    pDisplay->start          = pStart;
-    pDisplay->dname          = pName;
-    pDisplay->dim            = pDim;
-    pDisplay->origin         = pOrigin;
-    pDisplay->end            = pEnd;
+    pDisplay->start = pStart;
+    pDisplay->dname = pName;
+    pDisplay->dim = pDim;
+    pDisplay->origin = pOrigin;
+    pDisplay->end = pEnd;
 
-    pDisplay->name           = pName ? pName->string : NULL;
-    pDisplay->rootXOrigin    = pOrigin ? pOrigin->x : 0;
-    pDisplay->rootYOrigin    = pOrigin ? pOrigin->y : 0;
+    pDisplay->name = pName ? pName->string : NULL;
+    pDisplay->rootXOrigin = pOrigin ? pOrigin->x : 0;
+    pDisplay->rootYOrigin = pOrigin ? pOrigin->y : 0;
 
     if (pDim && pDim->scrn && pDim->scrn->dim) {
-        pDisplay->scrnWidth  = pDim->scrn->dim->x;
+        pDisplay->scrnWidth = pDim->scrn->dim->x;
         pDisplay->scrnHeight = pDim->scrn->dim->y;
     }
     if (pDim && pDim->scrn && pDim->scrn->offset) {
-        pDisplay->scrnX      = pDim->scrn->offset->x;
-        pDisplay->scrnY      = pDim->scrn->offset->y;
-        pDisplay->scrnXSign  = pDim->scrn->offset->xsign;
-        pDisplay->scrnYSign  = pDim->scrn->offset->ysign;
+        pDisplay->scrnX = pDim->scrn->offset->x;
+        pDisplay->scrnY = pDim->scrn->offset->y;
+        pDisplay->scrnXSign = pDim->scrn->offset->xsign;
+        pDisplay->scrnYSign = pDim->scrn->offset->ysign;
     }
-    
+
     if (pDim && pDim->root) {
         if (pDim->root->dim) {
-            pDisplay->rootWidth  = pDim->root->dim->x;
+            pDisplay->rootWidth = pDim->root->dim->x;
             pDisplay->rootHeight = pDim->root->dim->y;
         }
         if (pDim->root->offset) {
-            pDisplay->rootX      = pDim->root->offset->x;
-            pDisplay->rootY      = pDim->root->offset->y;
-            pDisplay->rootXSign  = pDim->root->offset->xsign;
-            pDisplay->rootYSign  = pDim->root->offset->ysign;
+            pDisplay->rootX = pDim->root->offset->x;
+            pDisplay->rootY = pDim->root->offset->y;
+            pDisplay->rootXSign = pDim->root->offset->xsign;
+            pDisplay->rootYSign = pDim->root->offset->ysign;
         }
-    } else {                    /* If no root specification, copy width
+    }
+    else {                      /* If no root specification, copy width
                                  * and height from scrn -- leave offset
                                  * as zero, since it is relative to
                                  * scrn. */
-        pDisplay->rootWidth  = pDisplay->scrnWidth;
+        pDisplay->rootWidth = pDisplay->scrnWidth;
         pDisplay->rootHeight = pDisplay->scrnHeight;
     }
 
-
     return pDisplay;
 }
 
-void dmxConfigFreeDisplay(DMXConfigDisplayPtr p)
+void
+dmxConfigFreeDisplay(DMXConfigDisplayPtr p)
 {
-    if (!p) return;
+    if (!p)
+        return;
     dmxConfigFreeToken(p->start);
     dmxConfigFreeString(p->dname);
     dmxConfigFreeFullDim(p->dim);
@@ -302,31 +327,33 @@ void dmxConfigFreeDisplay(DMXConfigDisplayPtr p)
     dmxConfigFree(p);
 }
 
-DMXConfigWallPtr dmxConfigCreateWall(DMXConfigTokenPtr pStart,
-                                     DMXConfigPairPtr pWallDim,
-                                     DMXConfigPairPtr pDisplayDim,
-                                     DMXConfigStringPtr pNameList,
-                                     DMXConfigTokenPtr pEnd)
+DMXConfigWallPtr
+dmxConfigCreateWall(DMXConfigTokenPtr pStart,
+                    DMXConfigPairPtr pWallDim,
+                    DMXConfigPairPtr pDisplayDim,
+                    DMXConfigStringPtr pNameList, DMXConfigTokenPtr pEnd)
 {
     DMXConfigWallPtr pWall = dmxConfigAlloc(sizeof(*pWall));
 
-    pWall->start      = pStart;
-    pWall->wallDim    = pWallDim;
+    pWall->start = pStart;
+    pWall->wallDim = pWallDim;
     pWall->displayDim = pDisplayDim;
-    pWall->nameList   = pNameList;
-    pWall->end        = pEnd;
+    pWall->nameList = pNameList;
+    pWall->end = pEnd;
 
-    pWall->width      = pDisplayDim ? pDisplayDim->x : 0;
-    pWall->height     = pDisplayDim ? pDisplayDim->y : 0;
-    pWall->xwall      = pWallDim    ? pWallDim->x    : 0;
-    pWall->ywall      = pWallDim    ? pWallDim->y    : 0;
+    pWall->width = pDisplayDim ? pDisplayDim->x : 0;
+    pWall->height = pDisplayDim ? pDisplayDim->y : 0;
+    pWall->xwall = pWallDim ? pWallDim->x : 0;
+    pWall->ywall = pWallDim ? pWallDim->y : 0;
 
     return pWall;
 }
 
-void dmxConfigFreeWall(DMXConfigWallPtr p)
+void
+dmxConfigFreeWall(DMXConfigWallPtr p)
 {
-    if (!p) return;
+    if (!p)
+        return;
     dmxConfigFreeToken(p->start);
     dmxConfigFreePair(p->wallDim);
     dmxConfigFreePair(p->displayDim);
@@ -335,41 +362,46 @@ void dmxConfigFreeWall(DMXConfigWallPtr p)
     dmxConfigFree(p);
 }
 
-DMXConfigOptionPtr dmxConfigCreateOption(DMXConfigTokenPtr pStart,
-                                         DMXConfigStringPtr pOption,
-                                         DMXConfigTokenPtr pEnd)
+DMXConfigOptionPtr
+dmxConfigCreateOption(DMXConfigTokenPtr pStart,
+                      DMXConfigStringPtr pOption, DMXConfigTokenPtr pEnd)
 {
-    int                length = 0;
-    int                offset = 0;
+    int length = 0;
+    int offset = 0;
     DMXConfigStringPtr p;
     DMXConfigOptionPtr option = dmxConfigAlloc(sizeof(*option));
 
     for (p = pOption; p; p = p->next) {
-        if (p->string) length += strlen(p->string) + 1;
+        if (p->string)
+            length += strlen(p->string) + 1;
     }
 
     option->string = dmxConfigAlloc(length + 1);
-    
+
     for (p = pOption; p; p = p->next) {
         if (p->string) {
             int len = strlen(p->string);
+
             strncpy(option->string + offset, p->string, len);
             offset += len;
-            if (p->next) option->string[offset++] = ' ';
+            if (p->next)
+                option->string[offset++] = ' ';
         }
     }
     option->string[offset] = '\0';
 
-    option->start  = pStart;
+    option->start = pStart;
     option->option = pOption;
-    option->end    = pEnd;
+    option->end = pEnd;
 
     return option;
 }
 
-void dmxConfigFreeOption(DMXConfigOptionPtr p)
+void
+dmxConfigFreeOption(DMXConfigOptionPtr p)
 {
-    if (!p) return;
+    if (!p)
+        return;
     free(p->string);
     dmxConfigFreeToken(p->start);
     dmxConfigFreeString(p->option);
@@ -377,8 +409,8 @@ void dmxConfigFreeOption(DMXConfigOptionPtr p)
     dmxConfigFree(p);
 }
 
-const char **dmxConfigLookupParam(DMXConfigParamPtr p, const char *key,
-                                  int *argc)
+const char **
+dmxConfigLookupParam(DMXConfigParamPtr p, const char *key, int *argc)
 {
     DMXConfigParamPtr pt;
 
@@ -388,17 +420,17 @@ const char **dmxConfigLookupParam(DMXConfigParamPtr p, const char *key,
             return pt->argv;
         }
     }
-    *argc  = 0;
+    *argc = 0;
     return NULL;
 }
 
-DMXConfigParamPtr dmxConfigCreateParam(DMXConfigTokenPtr pStart,
-                                       DMXConfigTokenPtr pOpen,
-                                       DMXConfigStringPtr pParam,
-                                       DMXConfigTokenPtr pClose,
-                                       DMXConfigTokenPtr pEnd)
+DMXConfigParamPtr
+dmxConfigCreateParam(DMXConfigTokenPtr pStart,
+                     DMXConfigTokenPtr pOpen,
+                     DMXConfigStringPtr pParam,
+                     DMXConfigTokenPtr pClose, DMXConfigTokenPtr pEnd)
 {
-    DMXConfigParamPtr  param = dmxConfigAlloc(sizeof(*param));
+    DMXConfigParamPtr param = dmxConfigAlloc(sizeof(*param));
     DMXConfigStringPtr pt;
 
     param->argc = 0;
@@ -406,27 +438,30 @@ DMXConfigParamPtr dmxConfigCreateParam(DMXConfigTokenPtr pStart,
     for (pt = pParam; pt; pt = pt->next) {
         if (pt->string) {
             param->argv = realloc(param->argv,
-                                  (param->argc+2) * sizeof(*param->argv));
+                                  (param->argc + 2) * sizeof(*param->argv));
             param->argv[param->argc] = pt->string;
             ++param->argc;
         }
     }
-    if (param->argv) param->argv[param->argc] = NULL;
+    if (param->argv)
+        param->argv[param->argc] = NULL;
 
     param->start = pStart;
-    param->open  = pOpen;
+    param->open = pOpen;
     param->param = pParam;
     param->close = pClose;
-    param->end   = pEnd;
+    param->end = pEnd;
 
     return param;
 }
 
-void dmxConfigFreeParam(DMXConfigParamPtr p)
+void
+dmxConfigFreeParam(DMXConfigParamPtr p)
 {
     DMXConfigParamPtr next;
 
-    if (!p) return;
+    if (!p)
+        return;
     do {
         next = p->next;
         dmxConfigFreeToken(p->start);
@@ -439,37 +474,61 @@ void dmxConfigFreeParam(DMXConfigParamPtr p)
     } while ((p = next));
 }
 
-DMXConfigSubPtr dmxConfigCreateSub(DMXConfigType type,
-                                   DMXConfigCommentPtr comment,
-                                   DMXConfigDisplayPtr display,
-                                   DMXConfigWallPtr wall,
-                                   DMXConfigOptionPtr option,
-                                   DMXConfigParamPtr param)
+DMXConfigSubPtr
+dmxConfigCreateSub(DMXConfigType type,
+                   DMXConfigCommentPtr comment,
+                   DMXConfigDisplayPtr display,
+                   DMXConfigWallPtr wall,
+                   DMXConfigOptionPtr option, DMXConfigParamPtr param)
 {
     DMXConfigSubPtr pSub = dmxConfigAlloc(sizeof(*pSub));
+
     pSub->type = type;
     switch (type) {
-    case dmxConfigComment: pSub->comment = comment;                     break;
-    case dmxConfigDisplay: pSub->display = display;                     break;
-    case dmxConfigWall:    pSub->wall    = wall;                        break;
-    case dmxConfigOption:  pSub->option  = option;                      break;
-    case dmxConfigParam:   pSub->param   = param;                       break;
-    default: dmxConfigLog("Type %d not supported in subentry\n", type); break;
+    case dmxConfigComment:
+        pSub->comment = comment;
+        break;
+    case dmxConfigDisplay:
+        pSub->display = display;
+        break;
+    case dmxConfigWall:
+        pSub->wall = wall;
+        break;
+    case dmxConfigOption:
+        pSub->option = option;
+        break;
+    case dmxConfigParam:
+        pSub->param = param;
+        break;
+    default:
+        dmxConfigLog("Type %d not supported in subentry\n", type);
+        break;
     }
     return pSub;
 }
 
-void dmxConfigFreeSub(DMXConfigSubPtr sub)
+void
+dmxConfigFreeSub(DMXConfigSubPtr sub)
 {
     DMXConfigSubPtr pt;
 
     for (pt = sub; pt; pt = pt->next) {
         switch (pt->type) {
-        case dmxConfigComment: dmxConfigFreeComment(pt->comment); break;
-        case dmxConfigDisplay: dmxConfigFreeDisplay(pt->display); break;
-        case dmxConfigWall:    dmxConfigFreeWall(pt->wall);       break;
-        case dmxConfigOption:  dmxConfigFreeOption(pt->option);   break;
-        case dmxConfigParam:   dmxConfigFreeParam(pt->param);     break;
+        case dmxConfigComment:
+            dmxConfigFreeComment(pt->comment);
+            break;
+        case dmxConfigDisplay:
+            dmxConfigFreeDisplay(pt->display);
+            break;
+        case dmxConfigWall:
+            dmxConfigFreeWall(pt->wall);
+            break;
+        case dmxConfigOption:
+            dmxConfigFreeOption(pt->option);
+            break;
+        case dmxConfigParam:
+            dmxConfigFreeParam(pt->param);
+            break;
         default:
             dmxConfigLog("Type %d not supported in subentry\n", pt->type);
             break;
@@ -478,68 +537,75 @@ void dmxConfigFreeSub(DMXConfigSubPtr sub)
     dmxConfigFree(sub);
 }
 
-DMXConfigSubPtr dmxConfigSubComment(DMXConfigCommentPtr comment)
+DMXConfigSubPtr
+dmxConfigSubComment(DMXConfigCommentPtr comment)
 {
     return dmxConfigCreateSub(dmxConfigComment, comment, NULL, NULL, NULL,
                               NULL);
 }
 
-DMXConfigSubPtr dmxConfigSubDisplay(DMXConfigDisplayPtr display)
+DMXConfigSubPtr
+dmxConfigSubDisplay(DMXConfigDisplayPtr display)
 {
     return dmxConfigCreateSub(dmxConfigDisplay, NULL, display, NULL, NULL,
                               NULL);
 }
 
-DMXConfigSubPtr dmxConfigSubWall(DMXConfigWallPtr wall)
+DMXConfigSubPtr
+dmxConfigSubWall(DMXConfigWallPtr wall)
 {
     return dmxConfigCreateSub(dmxConfigWall, NULL, NULL, wall, NULL, NULL);
 }
 
-DMXConfigSubPtr dmxConfigSubOption(DMXConfigOptionPtr option)
+DMXConfigSubPtr
+dmxConfigSubOption(DMXConfigOptionPtr option)
 {
     return dmxConfigCreateSub(dmxConfigOption, NULL, NULL, NULL, option, NULL);
 }
 
-DMXConfigSubPtr dmxConfigSubParam(DMXConfigParamPtr param)
+DMXConfigSubPtr
+dmxConfigSubParam(DMXConfigParamPtr param)
 {
     return dmxConfigCreateSub(dmxConfigParam, NULL, NULL, NULL, NULL, param);
 }
 
-extern DMXConfigSubPtr dmxConfigAddSub(DMXConfigSubPtr head,
-                                       DMXConfigSubPtr sub)
+extern DMXConfigSubPtr
+dmxConfigAddSub(DMXConfigSubPtr head, DMXConfigSubPtr sub)
 {
     DMXConfigSubPtr pt;
-    
-    if (!head) return sub;
+
+    if (!head)
+        return sub;
     for (pt = head; pt->next; pt = pt->next);
     pt->next = sub;
     return head;
 }
 
-DMXConfigVirtualPtr dmxConfigCreateVirtual(DMXConfigTokenPtr pStart,
-                                           DMXConfigStringPtr pName,
-                                           DMXConfigPairPtr pDim,
-                                           DMXConfigTokenPtr pOpen,
-                                           DMXConfigSubPtr pSubentry,
-                                           DMXConfigTokenPtr pClose)
+DMXConfigVirtualPtr
+dmxConfigCreateVirtual(DMXConfigTokenPtr pStart,
+                       DMXConfigStringPtr pName,
+                       DMXConfigPairPtr pDim,
+                       DMXConfigTokenPtr pOpen,
+                       DMXConfigSubPtr pSubentry, DMXConfigTokenPtr pClose)
 {
     DMXConfigVirtualPtr pVirtual = dmxConfigAlloc(sizeof(*pVirtual));
 
-    pVirtual->start    = pStart;
-    pVirtual->vname    = pName;
-    pVirtual->dim      = pDim;
-    pVirtual->open     = pOpen;
+    pVirtual->start = pStart;
+    pVirtual->vname = pName;
+    pVirtual->dim = pDim;
+    pVirtual->open = pOpen;
     pVirtual->subentry = pSubentry;
-    pVirtual->close    = pClose;
+    pVirtual->close = pClose;
+
+    pVirtual->name = pName ? pName->string : NULL;
+    pVirtual->width = pDim ? pDim->x : 0;
+    pVirtual->height = pDim ? pDim->y : 0;
 
-    pVirtual->name     = pName ? pName->string : NULL;
-    pVirtual->width    = pDim ? pDim->x : 0;
-    pVirtual->height   = pDim ? pDim->y : 0;
-    
     return pVirtual;
 }
 
-void dmxConfigFreeVirtual(DMXConfigVirtualPtr virtual)
+void
+dmxConfigFreeVirtual(DMXConfigVirtualPtr virtual)
 {
     dmxConfigFreeToken(virtual->start);
     dmxConfigFreeString(virtual->vname);
@@ -550,28 +616,40 @@ void dmxConfigFreeVirtual(DMXConfigVirtualPtr virtual)
     dmxConfigFree(virtual);
 }
 
-DMXConfigEntryPtr dmxConfigCreateEntry(DMXConfigType type,
-                                       DMXConfigCommentPtr comment,
-                                       DMXConfigVirtualPtr virtual)
+DMXConfigEntryPtr
+dmxConfigCreateEntry(DMXConfigType type,
+                     DMXConfigCommentPtr comment, DMXConfigVirtualPtr virtual)
 {
     DMXConfigEntryPtr pEntry = dmxConfigAlloc(sizeof(*pEntry));
+
     pEntry->type = type;
     switch (type) {
-    case dmxConfigComment: pEntry->comment = comment;                break;
-    case dmxConfigVirtual: pEntry->virtual = virtual;                break;
-    default: dmxConfigLog("Type %d not supported in entry\n", type); break;
+    case dmxConfigComment:
+        pEntry->comment = comment;
+        break;
+    case dmxConfigVirtual:
+        pEntry->virtual = virtual;
+        break;
+    default:
+        dmxConfigLog("Type %d not supported in entry\n", type);
+        break;
     }
     return pEntry;
 }
 
-void dmxConfigFreeEntry(DMXConfigEntryPtr entry)
+void
+dmxConfigFreeEntry(DMXConfigEntryPtr entry)
 {
     DMXConfigEntryPtr pt;
 
     for (pt = entry; pt; pt = pt->next) {
         switch (pt->type) {
-        case dmxConfigComment: dmxConfigFreeComment(pt->comment); break;
-        case dmxConfigVirtual: dmxConfigFreeVirtual(pt->virtual); break;
+        case dmxConfigComment:
+            dmxConfigFreeComment(pt->comment);
+            break;
+        case dmxConfigVirtual:
+            dmxConfigFreeVirtual(pt->virtual);
+            break;
         default:
             dmxConfigLog("Type %d not supported in entry\n", pt->type);
             break;
@@ -580,15 +658,16 @@ void dmxConfigFreeEntry(DMXConfigEntryPtr entry)
     dmxConfigFree(entry);
 }
 
-DMXConfigEntryPtr dmxConfigAddEntry(DMXConfigEntryPtr head,
-                                    DMXConfigType type,
-                                    DMXConfigCommentPtr comment,
-                                    DMXConfigVirtualPtr virtual)
+DMXConfigEntryPtr
+dmxConfigAddEntry(DMXConfigEntryPtr head,
+                  DMXConfigType type,
+                  DMXConfigCommentPtr comment, DMXConfigVirtualPtr virtual)
 {
     DMXConfigEntryPtr child = dmxConfigCreateEntry(type, comment, virtual);
     DMXConfigEntryPtr pt;
 
-    if (!head) return child;
+    if (!head)
+        return child;
 
     for (pt = head; pt->next; pt = pt->next);
     pt->next = child;
@@ -596,12 +675,14 @@ DMXConfigEntryPtr dmxConfigAddEntry(DMXConfigEntryPtr head,
     return head;
 }
 
-DMXConfigEntryPtr dmxConfigEntryComment(DMXConfigCommentPtr comment)
+DMXConfigEntryPtr
+dmxConfigEntryComment(DMXConfigCommentPtr comment)
 {
     return dmxConfigCreateEntry(dmxConfigComment, comment, NULL);
 }
 
-DMXConfigEntryPtr dmxConfigEntryVirtual(DMXConfigVirtualPtr virtual)
+DMXConfigEntryPtr
+dmxConfigEntryVirtual(DMXConfigVirtualPtr virtual)
 {
     return dmxConfigCreateEntry(dmxConfigVirtual, NULL, virtual);
 }