dix: canonical walkScreen variable on screen list iterations

When iterating screen lists, consistently use the same variable name
`walkScreen` for holding current screen pointer everywhere.

Signed-off-by: Enrico Weigelt, metux IT consult <info@metux.net>

dix/cursor.c

@@ -106,11 +106,8 @@ int
 FreeCursor(void *value, XID cid)
 {
     CursorPtr pCurs = (CursorPtr) value;
-
-    ScreenPtr pscr;
     DeviceIntPtr pDev = NULL;   /* unused anyway */
 
-
     UnrefCursor(pCurs);
     if (CursorRefCount(pCurs) != 0)
         return Success;
@@ -118,8 +115,8 @@ FreeCursor(void *value, XID cid)
     BUG_WARN(CursorRefCount(pCurs) < 0);
 
     for (int nscr = 0; nscr < screenInfo.numScreens; nscr++) {
-        pscr = screenInfo.screens[nscr];
-        (void) (*pscr->UnrealizeCursor) (pDev, pscr, pCurs);
+        ScreenPtr walkScreen = screenInfo.screens[nscr];
+        (void) (*walkScreen->UnrealizeCursor) (pDev, walkScreen, pCurs);
     }
     FreeCursorBits(pCurs->bits);
     dixFiniPrivates(pCurs, PRIVATE_CURSOR);
@@ -184,14 +181,12 @@ CheckForEmptyMask(CursorBitsPtr bits)
 static int
 RealizeCursorAllScreens(CursorPtr pCurs)
 {
-    ScreenPtr pscr;
-
     for (int nscr = 0; nscr < screenInfo.numScreens; nscr++) {
-        pscr = screenInfo.screens[nscr];
+        ScreenPtr walkScreen = screenInfo.screens[nscr];
         for (DeviceIntPtr pDev = inputInfo.devices; pDev; pDev = pDev->next) {
             if (DevHasCursor(pDev)) {
-                if (!(*pscr->RealizeCursor) (pDev, pscr, pCurs)) {
-                    /* Realize failed for device pDev on screen pscr.
+                if (!(*walkScreen->RealizeCursor) (pDev, walkScreen, pCurs)) {
+                    /* Realize failed for device pDev on screen walkScreen.
                      * We have to assume that for all devices before, realize
                      * worked. We need to rollback all devices so far on the
                      * current screen and then all devices on previous
@@ -201,19 +196,19 @@ RealizeCursorAllScreens(CursorPtr pCurs)
 
                     while (pDevIt && pDevIt != pDev) {
                         if (DevHasCursor(pDevIt))
-                            (*pscr->UnrealizeCursor) (pDevIt, pscr, pCurs);
+                            (*walkScreen->UnrealizeCursor) (pDevIt, walkScreen, pCurs);
                         pDevIt = pDevIt->next;
                     }
                     while (--nscr >= 0) {
-                        pscr = screenInfo.screens[nscr];
+                        walkScreen = screenInfo.screens[nscr];
                         /* now unrealize all devices on previous screens */
                         pDevIt = inputInfo.devices;
                         while (pDevIt) {
                             if (DevHasCursor(pDevIt))
-                                (*pscr->UnrealizeCursor) (pDevIt, pscr, pCurs);
+                                (*walkScreen->UnrealizeCursor) (pDevIt, walkScreen, pCurs);
                             pDevIt = pDevIt->next;
                         }
-                        (*pscr->UnrealizeCursor) (pDev, pscr, pCurs);
+                        (*walkScreen->UnrealizeCursor) (pDev, walkScreen, pCurs);
                     }
                     return BadAlloc;
                 }

dix/dispatch.c

@@ -651,33 +651,32 @@ CreateConnectionBlock(void)
     memset(&depth, 0, sizeof(xDepth));
     memset(&visual, 0, sizeof(xVisualType));
     for (int i = 0; i < screenInfo.numScreens; i++) {
-        ScreenPtr pScreen;
         DepthPtr pDepth;
         VisualPtr pVisual;
+        ScreenPtr walkScreen = screenInfo.screens[i];
 
-        pScreen = screenInfo.screens[i];
-        root.windowId = pScreen->root->drawable.id;
-        root.defaultColormap = pScreen->defColormap;
-        root.whitePixel = pScreen->whitePixel;
-        root.blackPixel = pScreen->blackPixel;
+        root.windowId = walkScreen->root->drawable.id;
+        root.defaultColormap = walkScreen->defColormap;
+        root.whitePixel = walkScreen->whitePixel;
+        root.blackPixel = walkScreen->blackPixel;
         root.currentInputMask = 0;      /* filled in when sent */
-        root.pixWidth = pScreen->width;
-        root.pixHeight = pScreen->height;
-        root.mmWidth = pScreen->mmWidth;
-        root.mmHeight = pScreen->mmHeight;
-        root.minInstalledMaps = pScreen->minInstalledCmaps;
-        root.maxInstalledMaps = pScreen->maxInstalledCmaps;
-        root.rootVisualID = pScreen->rootVisual;
-        root.backingStore = pScreen->backingStoreSupport;
+        root.pixWidth = walkScreen->width;
+        root.pixHeight = walkScreen->height;
+        root.mmWidth = walkScreen->mmWidth;
+        root.mmHeight = walkScreen->mmHeight;
+        root.minInstalledMaps = walkScreen->minInstalledCmaps;
+        root.maxInstalledMaps = walkScreen->maxInstalledCmaps;
+        root.rootVisualID = walkScreen->rootVisual;
+        root.backingStore = walkScreen->backingStoreSupport;
         root.saveUnders = FALSE;
-        root.rootDepth = pScreen->rootDepth;
-        root.nDepths = pScreen->numDepths;
+        root.rootDepth = walkScreen->rootDepth;
+        root.nDepths = walkScreen->numDepths;
         memcpy(pBuf, &root, sizeof(xWindowRoot));
         sizesofar += sizeof(xWindowRoot);
         pBuf += sizeof(xWindowRoot);
 
-        pDepth = pScreen->allowedDepths;
-        for (int j = 0; j < pScreen->numDepths; j++, pDepth++) {
+        pDepth = walkScreen->allowedDepths;
+        for (int j = 0; j < walkScreen->numDepths; j++, pDepth++) {
             lenofblock += sizeof(xDepth) +
                 (pDepth->numVids * sizeof(xVisualType));
             pBuf = (char *) realloc(ConnectionInfo, lenofblock);
@@ -694,7 +693,7 @@ CreateConnectionBlock(void)
             sizesofar += sizeof(xDepth);
             for (int k = 0; k < pDepth->numVids; k++) {
                 vid = pDepth->vids[k];
-                for (pVisual = pScreen->visuals;
+                for (pVisual = walkScreen->visuals;
                      pVisual->vid != vid; pVisual++);
                 visual.visualID = vid;
                 visual.class = pVisual->class;
@@ -3225,14 +3224,14 @@ ProcQueryBestSize(ClientPtr client)
 int
 ProcSetScreenSaver(ClientPtr client)
 {
-    int rc, blankingOption, exposureOption;
+    int blankingOption, exposureOption;
 
     REQUEST(xSetScreenSaverReq);
     REQUEST_SIZE_MATCH(xSetScreenSaverReq);
 
     for (int i = 0; i < screenInfo.numScreens; i++) {
-        rc = XaceHookScreensaverAccess(client, screenInfo.screens[i],
-                      DixSetAttrAccess);
+        ScreenPtr walkScreen = screenInfo.screens[i];
+        int rc = XaceHookScreensaverAccess(client, walkScreen, DixSetAttrAccess);
         if (rc != Success)
             return rc;
     }
@@ -3285,13 +3284,11 @@ ProcSetScreenSaver(ClientPtr client)
 int
 ProcGetScreenSaver(ClientPtr client)
 {
-    int rc;
-
     REQUEST_SIZE_MATCH(xReq);
 
     for (int i = 0; i < screenInfo.numScreens; i++) {
-        rc = XaceHookScreensaverAccess(client, screenInfo.screens[i],
-                      DixGetAttrAccess);
+        ScreenPtr walkScreen = screenInfo.screens[i];
+        int rc = XaceHookScreensaverAccess(client, walkScreen, DixGetAttrAccess);
         if (rc != Success)
             return rc;
     }
@@ -3814,8 +3811,9 @@ SendConnSetup(ClientPtr client, const char *reason)
 #endif /* XINERAMA */
 
     for (int i = 0; i < numScreens; i++) {
+        ScreenPtr walkScreen = screenInfo.screens[i];
         xDepth *pDepth;
-        WindowPtr pRoot = screenInfo.screens[i]->root;
+        WindowPtr pRoot = walkScreen->root;
 
         root->currentInputMask = pRoot->eventMask | wOtherEventMasks(pRoot);
         pDepth = (xDepth *) (root + 1);

dix/dixfonts.c

@@ -237,7 +237,6 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
 {
     FontPtr pfont = NullFont;
     FontPathElementPtr fpe = NULL;
-    ScreenPtr pScr;
     int err = Successful;
     char *alias, *newname;
     int newlen;
@@ -340,9 +339,9 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
     if (pfont->refcnt == 1) {
         UseFPE(pfont->fpe);
         for (int i = 0; i < screenInfo.numScreens; i++) {
-            pScr = screenInfo.screens[i];
-            if (pScr->RealizeFont) {
-                if (!(*pScr->RealizeFont) (pScr, pfont)) {
+            ScreenPtr walkScreen = screenInfo.screens[i];
+            if (walkScreen->RealizeFont) {
+                if (!(*walkScreen->RealizeFont) (walkScreen, pfont)) {
                     CloseFont(pfont, (Font) 0);
                     err = AllocError;
                     goto bail;

dix/dixutils.c

@@ -343,11 +343,17 @@ BlockHandler(void *pTimeout)
         if (!handlers[i].deleted)
             (*handlers[i].BlockHandler) (handlers[i].blockData, pTimeout);
 
-    for (int i = 0; i < screenInfo.numGPUScreens; i++)
-        (*screenInfo.gpuscreens[i]->BlockHandler) (screenInfo.gpuscreens[i], pTimeout);
+    for (int i = 0; i < screenInfo.numGPUScreens; i++) {
+        ScreenPtr walkScreen = screenInfo.gpuscreens[i];
+        if (walkScreen->BlockHandler)
+            walkScreen->BlockHandler(walkScreen, pTimeout);
+    }
 
-    for (int i = 0; i < screenInfo.numScreens; i++)
-        (*screenInfo.screens[i]->BlockHandler) (screenInfo.screens[i], pTimeout);
+    for (int i = 0; i < screenInfo.numScreens; i++) {
+        ScreenPtr walkScreen = screenInfo.screens[i];
+        if (walkScreen->BlockHandler)
+            walkScreen->BlockHandler(walkScreen, pTimeout);
+    }
 
     if (handlerDeleted) {
         for (int i = 0; i < numHandlers;)
@@ -372,10 +378,17 @@ void
 WakeupHandler(int result)
 {
     ++inHandler;
-    for (int i = 0; i < screenInfo.numScreens; i++)
-        (*screenInfo.screens[i]->WakeupHandler) (screenInfo.screens[i], result);
-    for (int i = 0; i < screenInfo.numGPUScreens; i++)
-        (*screenInfo.gpuscreens[i]->WakeupHandler) (screenInfo.gpuscreens[i], result);
+    for (int i = 0; i < screenInfo.numScreens; i++) {
+        ScreenPtr walkScreen = screenInfo.screens[i];
+        if (walkScreen->WakeupHandler)
+            walkScreen->WakeupHandler(walkScreen, result);
+    }
+    for (int i = 0; i < screenInfo.numGPUScreens; i++) {
+        ScreenPtr walkScreen = screenInfo.gpuscreens[i];
+        if (walkScreen->WakeupHandler)
+            walkScreen->WakeupHandler(walkScreen, result);
+    }
+
     for (int i = numHandlers - 1; i >= 0; i--)
         if (!handlers[i].deleted)
             (*handlers[i].WakeupHandler) (handlers[i].blockData, result);

dix/enterleave.c

@@ -1233,7 +1233,6 @@ CoreFocusPointerRootNoneSwitch(DeviceIntPtr dev,
                                WindowPtr B,     /* NoneWin or PointerRootWin */
                                int mode)
 {
-    WindowPtr root;
     int nscreens = screenInfo.numScreens;
 
 #ifdef XINERAMA
@@ -1242,7 +1241,8 @@ CoreFocusPointerRootNoneSwitch(DeviceIntPtr dev,
 #endif /* XINERAMA */
 
     for (int i = 0; i < nscreens; i++) {
-        root = screenInfo.screens[i]->root;
+        ScreenPtr walkScreen = screenInfo.screens[i];
+        WindowPtr root = walkScreen->root;
         if (!HasOtherPointer(root, GetMaster(dev, POINTER_OR_FLOAT)) &&
             !FirstFocusChild(root)) {
             /* If pointer was on PointerRootWin and changes to NoneWin, and
@@ -1276,7 +1276,6 @@ CoreFocusToPointerRootOrNone(DeviceIntPtr dev, WindowPtr A,
                              WindowPtr B,        /* PointerRootWin or NoneWin */
                              int mode)
 {
-    WindowPtr root;
     int nscreens = screenInfo.numScreens;
 
 #ifdef XINERAMA
@@ -1303,7 +1302,8 @@ CoreFocusToPointerRootOrNone(DeviceIntPtr dev, WindowPtr A,
     CoreFocusOutEvents(dev, A, NullWindow, mode, NotifyNonlinearVirtual);
 
     for (int i = 0; i < nscreens; i++) {
-        root = screenInfo.screens[i]->root;
+        ScreenPtr walkScreen = screenInfo.screens[i];
+        WindowPtr root = walkScreen->root;
         if (!HasFocus(root) && !FirstFocusChild(root)) {
             CoreFocusEvent(dev, FocusIn, mode,
                            B ? NotifyPointerRoot : NotifyDetailNone, root);
@@ -1322,7 +1322,6 @@ CoreFocusFromPointerRootOrNone(DeviceIntPtr dev,
                                WindowPtr A,   /* PointerRootWin or NoneWin */
                                WindowPtr B, int mode)
 {
-    WindowPtr root;
     int nscreens = screenInfo.numScreens;
 
 #ifdef XINERAMA
@@ -1331,7 +1330,8 @@ CoreFocusFromPointerRootOrNone(DeviceIntPtr dev,
 #endif /* XINERAMA */
 
     for (int i = 0; i < nscreens; i++) {
-        root = screenInfo.screens[i]->root;
+        ScreenPtr walkScreen = screenInfo.screens[i];
+        WindowPtr root = walkScreen->root;
         if (!HasFocus(root) && !FirstFocusChild(root)) {
             /* If pointer was on PointerRootWin and changes to NoneWin, and
              * the pointer paired with dev is below the current root window,
@@ -1349,7 +1349,7 @@ CoreFocusFromPointerRootOrNone(DeviceIntPtr dev,
         }
     }
 
-    root = B;                   /* get B's root window */
+    WindowPtr root = B;                   /* get B's root window */
     while (root->parent)
         root = root->parent;
 
@@ -1429,9 +1429,10 @@ DeviceFocusEvents(DeviceIntPtr dev, WindowPtr from, WindowPtr to, int mode)
                                      NotifyPointer);
             }
             /* Notify all the roots */
-            for (int i = 0; i < nscreens; i++)
-                DeviceFocusEvent(dev, XI_FocusOut, mode, out,
-                                 screenInfo.screens[i]->root);
+            for (int i = 0; i < nscreens; i++) {
+                ScreenPtr walkScreen = screenInfo.screens[i];
+                DeviceFocusEvent(dev, XI_FocusOut, mode, out, walkScreen->root);
+            }
         }
         else {
             if (WindowIsParent(from, sprite->win)) {
@@ -1446,9 +1447,10 @@ DeviceFocusEvents(DeviceIntPtr dev, WindowPtr from, WindowPtr to, int mode)
                                  NotifyNonlinearVirtual);
         }
         /* Notify all the roots */
-        for (int i = 0; i < nscreens; i++)
-            DeviceFocusEvent(dev, XI_FocusIn, mode, in,
-                             screenInfo.screens[i]->root);
+        for (int i = 0; i < nscreens; i++) {
+            ScreenPtr walkScreen = screenInfo.screens[i];
+            DeviceFocusEvent(dev, XI_FocusIn, mode, in, walkScreen->root);
+        }
         if (to == PointerRootWin) {
             DeviceFocusInEvents(dev, InputDevCurrentRootWindow(dev), sprite->win,
                                 mode, NotifyPointer);
@@ -1464,9 +1466,10 @@ DeviceFocusEvents(DeviceIntPtr dev, WindowPtr from, WindowPtr to, int mode)
                                      InputDevCurrentRootWindow(dev), mode,
                                      NotifyPointer);
             }
-            for (int i = 0; i < nscreens; i++)
-                DeviceFocusEvent(dev, XI_FocusOut, mode, out,
-                                 screenInfo.screens[i]->root);
+            for (int i = 0; i < nscreens; i++) {
+                ScreenPtr walkScreen = screenInfo.screens[i];
+                DeviceFocusEvent(dev, XI_FocusOut, mode, out, walkScreen->root);
+            }
             if (to->parent != NullWindow)
                 DeviceFocusInEvents(dev, InputDevCurrentRootWindow(dev), to, mode,
                                     NotifyNonlinearVirtual);

dix/events.c

@@ -545,10 +545,11 @@ XineramaSetCursorPosition(DeviceIntPtr pDev, int x, int y, Bool generateEvent)
 
     if (!point_on_screen(pScreen, x, y)) {
         FOR_NSCREENS_BACKWARD(i) {
+            ScreenPtr walkScreen = screenInfo.screens[i];
             if (i == pScreen->myNum)
                 continue;
-            if (point_on_screen(screenInfo.screens[i], x, y)) {
-                pScreen = screenInfo.screens[i];
+            if (point_on_screen(walkScreen, x, y)) {
+                pScreen = walkScreen;
                 break;
             }
         }
@@ -593,8 +594,10 @@ XineramaSetWindowPntrs(DeviceIntPtr pDev, WindowPtr pWin)
     if (pWin == screenInfo.screens[0]->root) {
         int i;
 
-        FOR_NSCREENS_BACKWARD(i)
-            pSprite->windows[i] = screenInfo.screens[i]->root;
+        FOR_NSCREENS_BACKWARD(i) {
+            ScreenPtr walkScreen = screenInfo.screens[i];
+            pSprite->windows[i] = walkScreen->root;
+        }
     }
     else {
         PanoramiXRes *win;
@@ -631,12 +634,14 @@ XineramaConfineCursorToWindow(DeviceIntPtr pDev,
     i = PanoramiXNumScreens - 1;
 
     RegionCopy(&pSprite->Reg1, &pSprite->windows[i]->borderSize);
-    off_x = screenInfo.screens[i]->x;
-    off_y = screenInfo.screens[i]->y;
+    ScreenPtr walkScreen = screenInfo.screens[i];
+    off_x = walkScreen->x;
+    off_y = walkScreen->y;
 
     while (i--) {
-        x = off_x - screenInfo.screens[i]->x;
-        y = off_y - screenInfo.screens[i]->y;
+        walkScreen = screenInfo.screens[i];
+        x = off_x - walkScreen->x;
+        y = off_y - walkScreen->y;
 
         if (x || y)
             RegionTranslate(&pSprite->Reg1, x, y);
@@ -644,8 +649,8 @@ XineramaConfineCursorToWindow(DeviceIntPtr pDev,
         RegionUnion(&pSprite->Reg1, &pSprite->Reg1,
                     &pSprite->windows[i]->borderSize);
 
-        off_x = screenInfo.screens[i]->x;
-        off_y = screenInfo.screens[i]->y;
+        off_x = walkScreen->x;
+        off_y = walkScreen->y;
     }
 
     pSprite->hotLimits = *RegionExtents(&pSprite->Reg1);
@@ -835,12 +840,14 @@ CheckVirtualMotion(DeviceIntPtr pDev, QdEventPtr qe, WindowPtr pWin)
             i = PanoramiXNumScreens - 1;
 
             RegionCopy(&pSprite->Reg2, &pSprite->windows[i]->borderSize);
-            off_x = screenInfo.screens[i]->x;
-            off_y = screenInfo.screens[i]->y;
+            ScreenPtr walkScreen = screenInfo.screens[i];
+            off_x = walkScreen->x;
+            off_y = walkScreen->y;
 
             while (i--) {
-                x = off_x - screenInfo.screens[i]->x;
-                y = off_y - screenInfo.screens[i]->y;
+                walkScreen = screenInfo.screens[i];
+                x = off_x - walkScreen->x;
+                y = off_y - walkScreen->y;
 
                 if (x || y)
                     RegionTranslate(&pSprite->Reg2, x, y);
@@ -848,8 +855,8 @@ CheckVirtualMotion(DeviceIntPtr pDev, QdEventPtr qe, WindowPtr pWin)
                 RegionUnion(&pSprite->Reg2, &pSprite->Reg2,
                             &pSprite->windows[i]->borderSize);
 
-                off_x = screenInfo.screens[i]->x;
-                off_y = screenInfo.screens[i]->y;
+                off_x = walkScreen->x;
+                off_y = walkScreen->y;
             }
         }
         else
@@ -2479,10 +2486,10 @@ DeliverRawEvent(RawDeviceEvent *ev, DeviceIntPtr device)
     filter = GetEventFilter(device, xi);
 
     for (int i = 0; i < screenInfo.numScreens; i++) {
-        WindowPtr root;
+        ScreenPtr walkScreen = screenInfo.screens[i];
         InputClients *inputclients;
 
-        root = screenInfo.screens[i]->root;
+        WindowPtr root = walkScreen->root;
         if (!GetClientsForDelivery(device, root, xi, filter, &inputclients))
             continue;
 
@@ -3013,13 +3020,14 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
         int i;
 
         FOR_NSCREENS_FORWARD(i) {
+            ScreenPtr walkScreen = screenInfo.screens[i];
             if (!i)
                 continue; /* skip screen #0 */
             if (RegionContainsPoint(&pSprite->windows[i]->borderSize,
                                     x + screenInfo.screens[0]->x -
-                                    screenInfo.screens[i]->x,
+                                    walkScreen->x,
                                     y + screenInfo.screens[0]->y -
-                                    screenInfo.screens[i]->y, &box))
+                                    walkScreen->y, &box))
                 return TRUE;
         }
     }
@@ -3532,12 +3540,14 @@ XineramaPointInWindowIsVisible(WindowPtr pWin, int x, int y)
     yoff = y + screenInfo.screens[0]->y;
 
     FOR_NSCREENS_FORWARD(i) {
+        ScreenPtr walkScreen = screenInfo.screens[i];
         if (!i)
             continue; /* skip screen #0 */
+
         pWin = inputInfo.pointer->spriteInfo->sprite->windows[i];
 
-        x = xoff - screenInfo.screens[i]->x;
-        y = yoff - screenInfo.screens[i]->y;
+        x = xoff - walkScreen->x;
+        y = yoff - walkScreen->y;
 
         if (RegionContainsPoint(&pWin->borderClip, x, y, &box)
             && (!wInputShape(pWin) ||
@@ -5989,7 +5999,6 @@ ProcRecolorCursor(ClientPtr client)
 {
     CursorPtr pCursor;
     int rc;
-    ScreenPtr pscr;
     Bool displayed;
     SpritePtr pSprite = PickPointer(client)->spriteInfo->sprite;
 
@@ -6012,14 +6021,14 @@ ProcRecolorCursor(ClientPtr client)
     pCursor->backBlue = stuff->backBlue;
 
     for (int nscr = 0; nscr < screenInfo.numScreens; nscr++) {
-        pscr = screenInfo.screens[nscr];
+        ScreenPtr walkScreen = screenInfo.screens[nscr];
 #ifdef XINERAMA
         if (!noPanoramiXExtension)
-            displayed = (pscr == pSprite->screen);
+            displayed = (walkScreen == pSprite->screen);
         else
 #endif /* XINERAMA */
-            displayed = (pscr == pSprite->hotPhys.pScreen);
-        (*pscr->RecolorCursor) (PickPointer(client), pscr, pCursor,
+            displayed = (walkScreen == pSprite->hotPhys.pScreen);
+        (*walkScreen->RecolorCursor) (PickPointer(client), walkScreen, pCursor,
                                 (pCursor == pSprite->current) && displayed);
     }
     return Success;

dix/inpututils.c

@@ -843,12 +843,12 @@ update_desktop_dimensions(void)
     int x2 = INT_MIN, y2 = INT_MIN;     /* bottom-right */
 
     for (int i = 0; i < screenInfo.numScreens; i++) {
-        ScreenPtr screen = screenInfo.screens[i];
+        ScreenPtr walkScreen = screenInfo.screens[i];
 
-        x1 = min(x1, screen->x);
-        y1 = min(y1, screen->y);
-        x2 = max(x2, screen->x + screen->width);
-        y2 = max(y2, screen->y + screen->height);
+        x1 = min(x1, walkScreen->x);
+        y1 = min(y1, walkScreen->y);
+        x2 = max(x2, walkScreen->x + walkScreen->width);
+        y2 = max(y2, walkScreen->y + walkScreen->height);
     }
 
     screenInfo.x = x1;

dix/main.c

@@ -202,27 +202,27 @@ dix_main(int argc, char *argv[], char *envp[])
         LogMessageVerb(X_INFO, 1, "Extensions initialized\n");
 
         for (int i = 0; i < screenInfo.numGPUScreens; i++) {
-            ScreenPtr pScreen = screenInfo.gpuscreens[i];
-            if (!PixmapScreenInit(pScreen))
+            ScreenPtr walkScreen = screenInfo.gpuscreens[i];
+            if (!PixmapScreenInit(walkScreen))
                 FatalError("failed to create screen pixmap properties");
-            if (!dixScreenRaiseCreateResources(pScreen))
+            if (!dixScreenRaiseCreateResources(walkScreen))
                 FatalError("failed to create screen resources");
         }
 
         for (int i = 0; i < screenInfo.numScreens; i++) {
-            ScreenPtr pScreen = screenInfo.screens[i];
+            ScreenPtr walkScreen = screenInfo.screens[i];
 
-            if (!PixmapScreenInit(pScreen))
+            if (!PixmapScreenInit(walkScreen))
                 FatalError("failed to create screen pixmap properties");
-            if (!dixScreenRaiseCreateResources(pScreen))
+            if (!dixScreenRaiseCreateResources(walkScreen))
                 FatalError("failed to create screen resources");
-            if (!CreateGCperDepth(pScreen))
+            if (!CreateGCperDepth(walkScreen))
                 FatalError("failed to create scratch GCs");
-            if (!CreateDefaultStipple(pScreen))
+            if (!CreateDefaultStipple(walkScreen))
                 FatalError("failed to create default stipple");
-            if (!CreateRootWindow(pScreen))
+            if (!CreateRootWindow(walkScreen))
                 FatalError("failed to create root window");
-            CallCallbacks(&RootWindowFinalizeCallback, pScreen);
+            CallCallbacks(&RootWindowFinalizeCallback, walkScreen);
         }
 
         if (SetDefaultFontPath(defaultFontPath) != Success) {
@@ -248,8 +248,9 @@ dix_main(int argc, char *argv[], char *envp[])
 #endif /* XINERAMA */
 
         for (int i = 0; i < screenInfo.numScreens; i++) {
-            InitRootWindow(screenInfo.screens[i]->root);
-            CallCallbacks(&PostInitRootWindowCallback, screenInfo.screens[i]);
+            ScreenPtr walkScreen = screenInfo.screens[i];
+            InitRootWindow(walkScreen->root);
+            CallCallbacks(&PostInitRootWindowCallback, walkScreen);
         }
 
         LogMessageVerb(X_INFO, 1, "Screen(s) initialized\n");
@@ -312,21 +313,25 @@ dix_main(int argc, char *argv[], char *envp[])
 
         InputThreadFini();
 
-        for (int i = 0; i < screenInfo.numScreens; i++)
-            screenInfo.screens[i]->root = NullWindow;
+        for (int i = 0; i < screenInfo.numScreens; i++) {
+            ScreenPtr walkScreen = screenInfo.screens[i];
+            walkScreen->root = NullWindow;
+        }
 
         CloseDownDevices();
 
         CloseDownEvents();
 
         for (int i = screenInfo.numGPUScreens - 1; i >= 0; i--) {
-            dixFreeScreen(screenInfo.gpuscreens[i]);
+            ScreenPtr walkScreen = screenInfo.gpuscreens[i];
+            dixFreeScreen(walkScreen);
             screenInfo.numGPUScreens = i;
         }
         memset(&screenInfo.gpuscreens, 0, sizeof(screenInfo.gpuscreens));
 
         for (int i = screenInfo.numScreens - 1; i >= 0; i--) {
-            dixFreeScreen(screenInfo.screens[i]);
+            ScreenPtr walkScreen = screenInfo.screens[i];
+            dixFreeScreen(walkScreen);
             screenInfo.numScreens = i;
         }
         memset(&screenInfo.screens, 0, sizeof(screenInfo.screens));

dix/privates.c

@@ -211,13 +211,16 @@ fixupOneScreen(ScreenPtr pScreen, FixupFunc fixup, unsigned bytes)
 static Bool
 fixupScreens(FixupFunc fixup, unsigned bytes)
 {
-    for (int s = 0; s < screenInfo.numScreens; s++)
-        if (!fixupOneScreen (screenInfo.screens[s], fixup, bytes))
+    for (int s = 0; s < screenInfo.numScreens; s++) {
+        ScreenPtr walkScreen = screenInfo.screens[s];
+        if (!fixupOneScreen (walkScreen, fixup, bytes))
             return FALSE;
-
-    for (int s = 0; s < screenInfo.numGPUScreens; s++)
-        if (!fixupOneScreen (screenInfo.gpuscreens[s], fixup, bytes))
+    }
+    for (int s = 0; s < screenInfo.numGPUScreens; s++) {
+        ScreenPtr walkScreen = screenInfo.gpuscreens[s];
+        if (!fixupOneScreen (walkScreen, fixup, bytes))
             return FALSE;
+    }
     return TRUE;
 }
 
@@ -247,13 +250,13 @@ static Bool
 fixupDefaultColormaps(FixupFunc fixup, unsigned bytes)
 {
     for (int s = 0; s < screenInfo.numScreens; s++) {
+        ScreenPtr walkScreen = screenInfo.screens[s];
         ColormapPtr cmap;
-
         dixLookupResourceByType((void **) &cmap,
-                                screenInfo.screens[s]->defColormap, X11_RESTYPE_COLORMAP,
+                                walkScreen->defColormap, X11_RESTYPE_COLORMAP,
                                 serverClient, DixCreateAccess);
         if (cmap &&
-            !fixup(&cmap->devPrivates, screenInfo.screens[s]->screenSpecificPrivates[PRIVATE_COLORMAP].offset, bytes))
+            !fixup(&cmap->devPrivates, walkScreen->screenSpecificPrivates[PRIVATE_COLORMAP].offset, bytes))
             return FALSE;
     }
     return TRUE;
@@ -298,14 +301,12 @@ grow_screen_specific_set(DevPrivateType type, unsigned bytes)
 {
     /* Update offsets for all screen-specific keys */
     for (int s = 0; s < screenInfo.numScreens; s++) {
-        ScreenPtr       pScreen = screenInfo.screens[s];
-
-        grow_private_set(&pScreen->screenSpecificPrivates[type], bytes);
+        ScreenPtr walkScreen = screenInfo.screens[s];
+        grow_private_set(&walkScreen->screenSpecificPrivates[type], bytes);
     }
     for (int s = 0; s < screenInfo.numGPUScreens; s++) {
-        ScreenPtr       pScreen = screenInfo.gpuscreens[s];
-
-        grow_private_set(&pScreen->screenSpecificPrivates[type], bytes);
+        ScreenPtr walkScreen = screenInfo.gpuscreens[s];
+        grow_private_set(&walkScreen->screenSpecificPrivates[type], bytes);
     }
 }
 

dix/window.c

@@ -394,14 +394,13 @@ void
 PrintWindowTree(void)
 {
     int depth;
-    ScreenPtr pScreen;
     WindowPtr pWin;
 
     for (int scrnum = 0; scrnum < screenInfo.numScreens; scrnum++) {
-        pScreen = screenInfo.screens[scrnum];
+        ScreenPtr walkScreen = screenInfo.screens[scrnum];
         ErrorF("[dix] Dumping windows for screen %d (pixmap %x):\n", scrnum,
-               (unsigned) pScreen->GetScreenPixmap(pScreen)->drawable.id);
-        pWin = pScreen->root;
+               (unsigned) walkScreen->GetScreenPixmap(walkScreen)->drawable.id);
+        pWin = walkScreen->root;
         depth = 1;
         while (pWin) {
             log_window_info(pWin, depth);
@@ -3070,7 +3069,7 @@ SendVisibilityNotify(WindowPtr pWin)
 int
 dixSaveScreens(ClientPtr client, int on, int mode)
 {
-    int rc, what, type;
+    int what, type;
     XID vlist[2];
 
     if (on == SCREEN_SAVER_FORCER) {
@@ -3088,36 +3087,37 @@ dixSaveScreens(ClientPtr client, int on, int mode)
     }
 
     for (int i = 0; i < screenInfo.numScreens; i++) {
-        rc = XaceHookScreensaverAccess(client, screenInfo.screens[i],
+        ScreenPtr walkScreen = screenInfo.screens[i];
+        int rc = XaceHookScreensaverAccess(client, walkScreen,
                       DixShowAccess | DixHideAccess);
         if (rc != Success)
             return rc;
     }
     for (int i = 0; i < screenInfo.numScreens; i++) {
-        ScreenPtr pScreen = screenInfo.screens[i];
+        ScreenPtr walkScreen = screenInfo.screens[i];
 
         if (on == SCREEN_SAVER_FORCER)
-            (*pScreen->SaveScreen) (pScreen, on);
-        if (pScreen->screensaver.ExternalScreenSaver) {
-            if ((*pScreen->screensaver.ExternalScreenSaver)
-                (pScreen, type, on == SCREEN_SAVER_FORCER))
+            walkScreen->SaveScreen(walkScreen, on);
+        if (walkScreen->screensaver.ExternalScreenSaver) {
+            if (walkScreen->screensaver.ExternalScreenSaver
+                (walkScreen, type, on == SCREEN_SAVER_FORCER))
                 continue;
         }
         if (type == screenIsSaved)
             continue;
         switch (type) {
         case SCREEN_SAVER_OFF:
-            if (pScreen->screensaver.blanked == SCREEN_IS_BLANKED) {
-                (*pScreen->SaveScreen) (pScreen, what);
+            if (walkScreen->screensaver.blanked == SCREEN_IS_BLANKED) {
+                walkScreen->SaveScreen(walkScreen, what);
             }
-            else if (HasSaverWindow(pScreen)) {
-                pScreen->screensaver.pWindow = NullWindow;
-                FreeResource(pScreen->screensaver.wid, X11_RESTYPE_NONE);
+            else if (HasSaverWindow(walkScreen)) {
+                walkScreen->screensaver.pWindow = NullWindow;
+                FreeResource(walkScreen->screensaver.wid, X11_RESTYPE_NONE);
             }
             break;
         case SCREEN_SAVER_CYCLE:
-            if (pScreen->screensaver.blanked == SCREEN_IS_TILED) {
-                WindowPtr pWin = pScreen->screensaver.pWindow;
+            if (walkScreen->screensaver.blanked == SCREEN_IS_TILED) {
+                WindowPtr pWin = walkScreen->screensaver.pWindow;
 
                 /* make it look like screen saver is off, so that
                  * NotClippedByChildren will compute a clip list
@@ -3135,28 +3135,28 @@ dixSaveScreens(ClientPtr client, int on, int mode)
              * Call the DDX saver in case it wants to do something
              * at cycle time
              */
-            else if (pScreen->screensaver.blanked == SCREEN_IS_BLANKED) {
-                (*pScreen->SaveScreen) (pScreen, type);
+            else if (walkScreen->screensaver.blanked == SCREEN_IS_BLANKED) {
+                walkScreen->SaveScreen(walkScreen, type);
             }
             break;
         case SCREEN_SAVER_ON:
             if (ScreenSaverBlanking != DontPreferBlanking) {
-                if ((*pScreen->SaveScreen) (pScreen, what)) {
-                    pScreen->screensaver.blanked = SCREEN_IS_BLANKED;
+                if (walkScreen->SaveScreen(walkScreen, what)) {
+                    walkScreen->screensaver.blanked = SCREEN_IS_BLANKED;
                     continue;
                 }
                 if ((ScreenSaverAllowExposures != DontAllowExposures) &&
-                    TileScreenSaver(pScreen, SCREEN_IS_BLACK)) {
-                    pScreen->screensaver.blanked = SCREEN_IS_BLACK;
+                    TileScreenSaver(walkScreen, SCREEN_IS_BLACK)) {
+                    walkScreen->screensaver.blanked = SCREEN_IS_BLACK;
                     continue;
                 }
             }
             if ((ScreenSaverAllowExposures != DontAllowExposures) &&
-                TileScreenSaver(pScreen, SCREEN_IS_TILED)) {
-                pScreen->screensaver.blanked = SCREEN_IS_TILED;
+                TileScreenSaver(walkScreen, SCREEN_IS_TILED)) {
+                walkScreen->screensaver.blanked = SCREEN_IS_TILED;
             }
             else
-                pScreen->screensaver.blanked = SCREEN_ISNT_SAVED;
+                walkScreen->screensaver.blanked = SCREEN_ISNT_SAVED;
             break;
         }
     }