Return to symbol.c CVS log

Up to [OS/2 SDKs] / pmsdk / samples / spy

Annotation of pmsdk/samples/spy/symbol.c, revision 1.1

1.1     ! root        1: /***************************************************************************\
        !             2: 
        !             3: Module Name: SYMBOL.C
        !             4: 
        !             5: This module contains the code for displaying symbols for a specified address.
        !             6: 
        !             7: \***************************************************************************/
        !             8: 
        !             9: #define INCL_DOSPROCESS
        !            10: #define        INCL_GPILCIDS
        !            11: #define        INCL_WINDIALOGS
        !            12: #define        INCL_WINFRAMEMGR
        !            13: #define        INCL_WINHEAP                    /* needed for spy.h */
        !            14: #define        INCL_WININPUT
        !            15: #define        INCL_WINLISTBOXES
        !            16: #define        INCL_WINMENUS
        !            17: #define        INCL_WINMESSAGEMGR
        !            18: #define        INCL_WINPOINTERS                /* needed for spy.h */
        !            19: #define        INCL_WINWINDOWMGR
        !            20: #include <os2.h>
        !            21: #include <stdio.h>
        !            22: #include <string.h>
        !            23: #include "spy.h"
        !            24: #include <spyhook.h>
        !            25: #include "symbol.h"
        !            26: 
        !            27: WHOISINFO whoIs;
        !            28: MAPDEF mapdef;
        !            29: MAPEND mapend;
        !            30: SEGDEF segdef;
        !            31: SYMDEF symdef;
        !            32: 
        !            33: extern VOID lstrcat(PSZ, PSZ);
        !            34: extern void OutputString(char [], SHORT);       /* Output string to output devices */
        !            35: extern  BOOL FValidPointer (CHAR FAR *pVoid, SHORT cbStruct);
        !            36: extern  BOOL FGuessValidPointer (CHAR FAR *pVoid, SHORT cbStruct);
        !            37: 
        !            38: 
        !            39: extern HWND     hwndSpyFrame;
        !            40: extern HAB      hab;
        !            41: 
        !            42: /* Function prototypes */
        !            43: HWND HwndFrameFromPID(PID);
        !            44: VOID GetSymbolInformation(PID, char far *, char *);
        !            45: VOID NEAR ProcessLNOkButton(HWND);
        !            46: MRESULT NEAR FormatLNDialog(HWND, PSWP, PRECTL);
        !            47: VOID NEAR EndLNDialog(HWND);
        !            48: MRESULT CALLBACK ListNearDlgProc(HWND, USHORT, MPARAM, MPARAM);
        !            49: 
        !            50: 
        !            51: /***************************************************************************\
        !            52: * hwnd HwndFrameFromPID(pid)
        !            53: *
        !            54: * This function attempts to locate a frame window that was
        !            55: * created by the specified PID. It returns NULL if none are found.
        !            56: \***************************************************************************/
        !            57: HWND HwndFrameFromPID(pid)
        !            58: PID             pid;
        !            59: {
        !            60:     HENUM       henum;
        !            61:     HWND        hwnd;
        !            62:     PID         pidWindow;
        !            63:     TID         tidWindow;
        !            64:     char        szClassName[50];    /* Class name of window */
        !            65:     CLASSINFO   classinfo;          /* Information about class */
        !            66: 
        !            67:     henum = WinBeginEnumWindows(HWND_DESKTOP);
        !            68:     if (henum == NULL)
        !            69:         return (NULL);
        !            70: 
        !            71:     while ((hwnd = WinGetNextWindow(henum)) != NULL) {
        !            72:         WinQueryWindowProcess(hwnd, &pidWindow, &tidWindow);
        !            73:         WinLockWindow(hwnd, FALSE);
        !            74:         if (pid == pidWindow) {
        !            75:             /* See if a frame window */
        !            76:             WinQueryClassName(hwnd, sizeof(szClassName),
        !            77:                 (PSZ)szClassName);
        !            78:             if (WinQueryClassInfo(hab, (PSZ)szClassName, &classinfo) &&
        !            79:                     (classinfo.flClassStyle & CS_FRAME))
        !            80:                 break;  /* We have our frame */
        !            81:         }
        !            82:     }
        !            83: 
        !            84:     WinEndEnumWindows(henum);
        !            85:     return (hwnd);
        !            86: }
        !            87: 
        !            88: 
        !            89: 
        !            90: /***************************************************************************\
        !            91: * int IdentifyCodeSegment(lpSegInfo, pid, selector)
        !            92: *
        !            93: *         Identifies the code selector for the specified process.
        !            94: *          NOTE: The process is currently ignored, but later will somehow
        !            95: *          return information in the context of the specified process ID.
        !            96: \***************************************************************************/
        !            97: int
        !            98: pascal near IdentifyCodeSegment( pSegInfo, pid, selector )
        !            99: PSEGINFO   pSegInfo;
        !           100: PID         pid;
        !           101: USHORT      selector;
        !           102: {
        !           103:     char far *lp;
        !           104:     char    *np;
        !           105:     int     n;
        !           106:     BYTE    c;
        !           107:     USHORT  segnum;
        !           108:     USHORT  seg_ptr;
        !           109:     USHORT  uTemp;
        !           110:     int     rc;
        !           111:     PIDINFO pidinfo;
        !           112:     HWND    hwndPIDFrame;
        !           113: 
        !           114:     /* If new selector matches the current one, then nothing to do */
        !           115:     if ((pSegInfo->pid == pid) && (pSegInfo->selector == selector))
        !           116:         return 0;
        !           117: 
        !           118:     /*
        !           119:      * Try to identify the code selector.  We will first try in the context
        !           120:      * of our process.  If this fails, or if we find that the segment is
        !           121:      * associated with our program and it is not our PID, we will attempt
        !           122:      * to get the symbol in the specified PID context, with the help of
        !           123:      * our hooks.
        !           124:      */
        !           125:     DosGetPID(&pidinfo);
        !           126:     rc = IdentifyCodeSelector( selector, (PWHOISINFO)&whoIs );
        !           127:     if ((pid != pidinfo.pid) && (rc == 0)) {
        !           128:         /*
        !           129:          * User asked for a different context, and symbol was found.
        !           130:          * If the symbol was in our .exe we will ignore what we found,
        !           131:          * and try again.
        !           132:          */
        !           133:         /* First get past the module name */
        !           134:         np = whoIs.names;
        !           135:         while (*np++)
        !           136:             ;
        !           137:         /* Now go through the pathname */
        !           138:         while (*np) {
        !           139:             if (*np++ == '.') {
        !           140:                 if (strcmp(np,"EXE") == 0) {
        !           141:                     rc = 1;     /* It is in our exe, so set errr condition */
        !           142:                     break;  /* no need to go on */
        !           143:                 }
        !           144:             }
        !           145:         }
        !           146:     }
        !           147: 
        !           148:     if (rc) {
        !           149:         /*
        !           150:          * We need to try in other PID context
        !           151:          */
        !           152:         if ((pid == pidinfo.pid) ||
        !           153:                 ((hwndPIDFrame = HwndFrameFromPID(pid)) == NULL))
        !           154:             return (rc);    /* segment not found or no way to find segment */
        !           155: 
        !           156:         /* Lets use the hook */
        !           157:         SpySetLNSymbolPID(pid, selector);
        !           158: 
        !           159:         /* HACK: Send message to frame known to send another message */
        !           160:         WinSendMsg(hwndPIDFrame, WM_QUERYTASKFOCUS, 0L, 0L);
        !           161: 
        !           162:         if (SpyGetLNSymbolSelector(&whoIs) != 0)
        !           163:             return (1);     /* Still did not find the symbol */
        !           164: 
        !           165:     }
        !           166: 
        !           167: 
        !           168:     /* It is a valid code selector, make it the new current selector */
        !           169:     pSegInfo->selector = selector;
        !           170:     pSegInfo->pid = pid;
        !           171: 
        !           172:     /* Is the new selector in the same module? */
        !           173:     if (pSegInfo->lpSegName && pSegInfo->whoIs.mte == whoIs.mte)
        !           174:         pSegInfo->whoIs.segNum = whoIs.segNum;     /* Yes, just copy seg# */
        !           175:     else {
        !           176: 
        !           177:         /* New module, get segment #, mte handle, module name and pathstring */
        !           178:         pSegInfo->whoIs    = whoIs;
        !           179: 
        !           180:         /* Generate separate pointers to module name and pathstring */
        !           181:         lp = &pSegInfo->whoIs.names[0];
        !           182:         pSegInfo->lpModName = lp;
        !           183:         while (*lp++)
        !           184:             ;
        !           185:         pSegInfo->lpPathName = lp;
        !           186: 
        !           187:         /* Change pathstring extension to be .SYM */
        !           188:         while (*lp)
        !           189:             if (*lp++ == '.') {
        !           190:                 *lp++ = 'S';
        !           191:                 *lp++ = 'Y';
        !           192:                 *lp++ = 'M';
        !           193:                 }
        !           194:         lp++;
        !           195: 
        !           196:         /*
        !           197:          * No current segment name or symbol name, so make them point to
        !           198:          * null string
        !           199:          */
        !           200:         *lp = 0;
        !           201:         pSegInfo->lpSegName = lp;
        !           202:         pSegInfo->lpSymName = 0L;
        !           203: 
        !           204:         /* Close any currently open .SYM file and then open the new .SYM file */
        !           205:         if (pSegInfo->symfh != -1)
        !           206:             pSegInfo->symfh = DosClose((HFILE)pSegInfo->symfh );
        !           207: 
        !           208:         if (DosOpen(pSegInfo->lpPathName, (PHFILE)&pSegInfo->symfh,
        !           209:                 (PUSHORT)&uTemp,
        !           210:                 0L, 0, 1, 0x00c0, 0L) == 0) {
        !           211: 
        !           212:             /* Read in .SYM file header and save segment count and pointer */
        !           213: 
        !           214:             DebugFileRead( pSegInfo->symfh, (PSZ)&mapdef, sizeof( mapdef ) );
        !           215:             pSegInfo->segcnt = mapdef.seg_cnt;
        !           216:             pSegInfo->segptr = mapdef.seg_ptr;
        !           217: 
        !           218:             /* Read version of MAPSYM that produced this file.
        !           219:                If not a version 4 file then ignore the file */
        !           220: 
        !           221:             DebugFileSeek( pSegInfo->symfh, (long)-sizeof( mapend ), 2 );
        !           222:             DebugFileRead( pSegInfo->symfh, (PSZ)&mapend, sizeof( mapend ) );
        !           223:             if (mapend.ver != 4)
        !           224:                 pSegInfo->symfh = DosClose( (HFILE)pSegInfo->symfh );
        !           225:             }
        !           226:         }
        !           227: 
        !           228: /* Point to segment name buffer and make it a null string for now */
        !           229: 
        !           230:     lp = pSegInfo->lpSegName;
        !           231:     *lp = 0;
        !           232: 
        !           233: /* If we have an open .SYM file, search for segment definition record */
        !           234: 
        !           235:     if (pSegInfo->symfh != -1 && pSegInfo->whoIs.segNum < pSegInfo->segcnt) {
        !           236: 
        !           237:     /* Start with first segment definition and read segNum definitions */
        !           238: 
        !           239:         seg_ptr = pSegInfo->segptr;
        !           240:         n = pSegInfo->whoIs.segNum;
        !           241:         while (n--) {
        !           242:             DebugFileSeek( pSegInfo->symfh, (long)seg_ptr, 4 );
        !           243:             DebugFileRead( pSegInfo->symfh, (PSZ)&segdef, sizeof( segdef ) );
        !           244:             seg_ptr = (USHORT)segdef.nxt_seg;
        !           245:         }
        !           246: 
        !           247:     /* Now read in the segment name string associated with this segment
        !           248:        and make it a null terminated string */
        !           249: 
        !           250:         DebugFileRead( pSegInfo->symfh, (PSZ)(lp),
        !           251:                        (int)((BYTE)segdef.nam_len) );
        !           252:         lp += segdef.nam_len;
        !           253:         *lp++ = 0;
        !           254: 
        !           255:     /* Remember the count of symbols for this segment */
        !           256: 
        !           257:         pSegInfo->symcnt = segdef.sym_cnt;
        !           258: 
        !           259: 
        !           260:     /* Remember the file offset of the symbols for this segment, which is
        !           261:        immediately after the segment definition record and name we just read */
        !           262: 
        !           263:         pSegInfo->symFPos = DebugFileSeek( pSegInfo->symfh, 0L, 1 );
        !           264:         }
        !           265:     else {
        !           266:     /* If no .SYM file or segment number too big, then make the segnemt name
        !           267:        be the hex representation of its number */
        !           268: 
        !           269:         pSegInfo->symcnt = 0;
        !           270: 
        !           271:         segnum = pSegInfo->whoIs.segNum;
        !           272:         n = 4;
        !           273:         lp += n;
        !           274:         while (n--) {
        !           275:             c = (char)(segnum & (USHORT)0xF);
        !           276:             segnum >>= 4;
        !           277:             if (c > 9)
        !           278:                 c += 'A' - 10;
        !           279:             else
        !           280:                 c += '0';
        !           281:             *--lp = c;
        !           282:             *lp++ = 0;
        !           283:         }
        !           284: 
        !           285:     /* Null terminate the segment name string */
        !           286: 
        !           287:         lp += 4;
        !           288:         *lp++ = 0;
        !           289:     }
        !           290: 
        !           291: /* Initialize the symbol name pointer to point to a null string, immediately
        !           292:    after the segment name string just created above. */
        !           293: 
        !           294:     pSegInfo->lpSymName = lp;
        !           295:     *lp = 0;
        !           296: 
        !           297:     return 0;
        !           298: }
        !           299: 
        !           300: 
        !           301: USHORT
        !           302: pascal near FindSymbol( pSegInfo, offset )
        !           303: PSEGINFO pSegInfo;
        !           304: USHORT offset;
        !           305: {
        !           306:     USHORT i;
        !           307:     long symPos;
        !           308:     char far *lp;
        !           309: 
        !           310: /* If no .SYM file then return failure */
        !           311: 
        !           312:     if (pSegInfo->symfh == -1)
        !           313:         return 0xFFFF;
        !           314: 
        !           315: /* No symbol found yet, so make it a null string */
        !           316: 
        !           317:     lp = pSegInfo->lpSymName;
        !           318:     *lp = 0;
        !           319: 
        !           320: /* Now do a linear search of the symbol definitions for this segment, looking
        !           321:    for the closest match.  The definitions are stored in sorted order */
        !           322: 
        !           323:     symPos = DebugFileSeek( pSegInfo->symfh, (long)pSegInfo->symFPos, 0 );
        !           324:     i = (USHORT)pSegInfo->symcnt;
        !           325:     while (i--) {
        !           326:         DebugFileRead( pSegInfo->symfh, (PSZ)&symdef, sizeof( symdef ) );
        !           327: 
        !           328:     /* If this is not our symbol then just remember its offset */
        !           329: 
        !           330:         if ((USHORT)symdef.sym_val <= offset) {
        !           331:             symPos = DebugFileSeek( pSegInfo->symfh, 0L, 1 ) -
        !           332:                      sizeof( symdef );
        !           333: 
        !           334:         /* If exact match, exit this loop */
        !           335: 
        !           336:             if ((USHORT)symdef.sym_val == offset)
        !           337:                 break;
        !           338:             }
        !           339:         else
        !           340:         /* If we went past then exit this loop */
        !           341: 
        !           342:             break;
        !           343: 
        !           344:     /* Still looking, so seek past this symbols name string to next symbol
        !           345:        definition */
        !           346: 
        !           347:         DebugFileSeek( pSegInfo->symfh, (long)symdef.nam_len, 1 );
        !           348:         }
        !           349: 
        !           350: /* Seek to found symdebol definition and read it in, along with the name */
        !           351: 
        !           352:     DebugFileSeek( pSegInfo->symfh, (long)symPos, 0 );
        !           353:     DebugFileRead( pSegInfo->symfh, (PSZ)&symdef,
        !           354:                    sizeof( symdef ) );
        !           355:     DebugFileRead( pSegInfo->symfh, (PSZ)lp,
        !           356:                    (int)((BYTE)symdef.nam_len) );
        !           357: 
        !           358: /* Make the name a null terminated string */
        !           359: 
        !           360:     lp += symdef.nam_len;
        !           361:     *lp++ = 0;
        !           362: 
        !           363: /* Return the distance of the passed offset from the value of the symbol */
        !           364: 
        !           365:     return offset - symdef.sym_val;
        !           366: }
        !           367: 
        !           368: 
        !           369: 
        !           370: /*************************************************************************
        !           371:  *
        !           372:  * GetSymbolInformation(pid, pvoidInfo, pszInfo)
        !           373:  *
        !           374:  * Purpose: To get information about the supplied address
        !           375:  */
        !           376: VOID GetSymbolInformation(pid, pvoidInfo, pszInfo)
        !           377: PID             pid;
        !           378: char far        *pvoidInfo;
        !           379: char            *pszInfo;
        !           380: {
        !           381:     SEGINFO     seginfo;
        !           382:     char        szTemp[256];
        !           383:     USHORT      uOffsetFromSym;
        !           384: 
        !           385: 
        !           386:     /*
        !           387:      * First try to find the segment in the segment table.
        !           388:      */
        !           389:     if (IdentifyCodeSegment(&seginfo, pid, SELECTOROF(pvoidInfo)) != 0) {
        !           390: 
        !           391:         /*
        !           392:          * It failed to find the segment, ie it was invalid, so
        !           393:          * Simply return INVALID to caller
        !           394:          */
        !           395:         sprintf(pszInfo,"PID:%d %04x:%04x - INVALID", (SHORT)pid,
        !           396:                 SELECTOROF(pvoidInfo), OFFSETOF(pvoidInfo));
        !           397:         return;
        !           398:     }
        !           399: 
        !           400: 
        !           401:     sprintf(pszInfo,"PID:%d %04x:%04x - %Fs ! ", (SHORT)pid,
        !           402:             SELECTOROF(pvoidInfo), OFFSETOF(pvoidInfo),
        !           403:             seginfo.lpModName);
        !           404: 
        !           405:     if (seginfo.symfh == -1) {
        !           406:         sprintf(szTemp,"%04x", seginfo.whoIs.segNum);
        !           407:         strcat(pszInfo, szTemp);
        !           408:     } else {
        !           409:         lstrcat((PSZ)pszInfo, seginfo.lpSegName);
        !           410:     }
        !           411: 
        !           412:     uOffsetFromSym = FindSymbol(&seginfo, OFFSETOF(pvoidInfo));
        !           413:     if (uOffsetFromSym != 0xffff) {
        !           414:         strcat(pszInfo, ":");
        !           415: 
        !           416:         lstrcat((PSZ)pszInfo, seginfo.lpSymName);
        !           417:         if (uOffsetFromSym != 0) {
        !           418:             sprintf(szTemp, "+%x", uOffsetFromSym);
        !           419:             strcat(pszInfo, szTemp);
        !           420:         }
        !           421:     }
        !           422: }
        !           423: 
        !           424: 
        !           425: /***************************************************************************\
        !           426: * VOID NEAR ProcessLNOkButton(hwndDlg)
        !           427: *
        !           428: * Process the Ok Button for the List Near Dlg proc
        !           429: \***************************************************************************/
        !           430: VOID NEAR ProcessLNOkButton(hwndDlg)
        !           431: HWND hwndDlg;
        !           432: {
        !           433:     char        szTemp[100];
        !           434:     char far    *pVoid;
        !           435:     PID         pid;
        !           436:     SHORT       item;
        !           437: 
        !           438:     /*
        !           439:      * For now try using sscanf to convert the string into a
        !           440:      * pointer.
        !           441:      */
        !           442:     WinQueryDlgItemShort(hwndDlg, DID_PID, &pid, FALSE);
        !           443:     WinQueryDlgItemText(hwndDlg, DID_ADDR, sizeof(szTemp), szTemp);
        !           444:     if ((strchr(szTemp,':') != NULL) && (sscanf(szTemp,"%p", &pVoid)) > 0) {
        !           445:         /* It translated, so try to get info about pointer */
        !           446:         GetSymbolInformation(pid, pVoid, szTemp);
        !           447: 
        !           448:         /* For now simply output to output areas */
        !           449:         item = (SHORT)WinSendDlgItemMsg(hwndDlg, DID_SYMLIST,
        !           450:                 LM_INSERTITEM, (MPARAM)LIT_END, (MPARAM)(PSZ)szTemp);
        !           451: 
        !           452:         WinSendDlgItemMsg(hwndDlg, DID_SYMLIST, LM_SETTOPINDEX,
        !           453:                 (MPARAM)item, 0L);
        !           454:     }
        !           455: 
        !           456:     /*
        !           457:      * Now clear the text out of the ADDR field, and set the focus
        !           458:      * back to the window
        !           459:      */
        !           460:     WinSetDlgItemText(hwndDlg, DID_ADDR, "");
        !           461:     WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwndDlg, DID_ADDR));
        !           462: }
        !           463: 
        !           464: /***************************************************************************\
        !           465: * MRESULT NEAR FormatLNDialog(hwndDlg, paswp, prectl)
        !           466: *
        !           467: * Process the WM_SIZE message in the List Near Dialog
        !           468: \***************************************************************************/
        !           469: MRESULT NEAR FormatLNDialog(hwndDlg, paswp, prclClientX)
        !           470: HWND                hwndDlg;
        !           471: PSWP                paswp;
        !           472: PRECTL              prclClientX;
        !           473: {
        !           474:     USHORT          cy;
        !           475:     USHORT          cswp;
        !           476:     HPS             hps;
        !           477:     SHORT           dy;
        !           478:     register HWND   hwndT;
        !           479:     FONTMETRICS     fm;
        !           480:     PSWP            pswpT;
        !           481:     RECTL           rclClient;
        !           482:     SWP             swpOk;
        !           483:     SHORT           y;
        !           484: 
        !           485:     /*
        !           486:      * First let the default frame processing set up the position of
        !           487:      * all of the standard controls.  Then we will position the list box
        !           488:      * and the two entry fields to fill in the remainder of the space.
        !           489:      */
        !           490: 
        !           491: #define PSWPLN(x) (paswp + cswp + x - DID_SYMLIST)
        !           492: 
        !           493: 
        !           494:     cswp = (USHORT)WinDefDlgProc(hwndDlg, WM_FORMATFRAME, (MPARAM)paswp,
        !           495:             (MPARAM)(PRECTL)&rclClient);
        !           496:     if (prclClientX != NULL)
        !           497:         *prclClientX = rclClient;   /* Give caller info */
        !           498: 
        !           499: 
        !           500:     /*
        !           501:      * Now Add our controls to the SWP list - Verify that the first one
        !           502:      * exists. If not, we probably are initializing the dialog, so
        !           503:      * Simply return what the default Dlg Proc returned.
        !           504:      */
        !           505:     hwndT = WinWindowFromID(hwndDlg, DID_OK);
        !           506:     if (hwndT == NULL)
        !           507:         return (cswp);
        !           508: 
        !           509:     /*
        !           510:      * We need to get a PS, such that we can find out the size of the
        !           511:      * font, to adjust our edit fields such that they wont keep moving
        !           512:      * in.
        !           513:      */
        !           514:     hps = WinGetPS(hwndDlg);
        !           515:     GpiQueryFontMetrics(hps, (LONG)sizeof(fm), &fm);
        !           516:     WinReleasePS(hps);
        !           517: 
        !           518:     WinQueryWindowPos(hwndT, &swpOk);
        !           519: 
        !           520:     pswpT=PSWPLN(DID_SYMLIST);
        !           521:     WinQueryWindowPos(hwndT = WinWindowFromID(hwndDlg, DID_SYMLIST), pswpT);
        !           522:     dy = pswpT->y - (swpOk.y + swpOk.cy);
        !           523:     pswpT->fs = SWP_SIZE;
        !           524:     pswpT->cx = (SHORT)rclClient.xRight - (SHORT)rclClient.xLeft - pswpT->x;
        !           525: 
        !           526:     /* First position the top line, just below titlebar */
        !           527:     pswpT=PSWPLN(DID_PIDLABEL);
        !           528:     WinQueryWindowPos(hwndT = WinWindowFromID(hwndDlg, DID_PIDLABEL), pswpT);
        !           529:     pswpT->fs = SWP_MOVE;
        !           530:     cy = pswpT->cy;
        !           531:     y = pswpT->y = (SHORT)rclClient.yTop - (SHORT)rclClient.yBottom -
        !           532:             cy - dy;
        !           533: 
        !           534:     pswpT=PSWPLN(DID_PID);
        !           535:     WinQueryWindowPos(hwndT = WinWindowFromID(hwndDlg, DID_PID), pswpT);
        !           536:     pswpT->fs = SWP_MOVE;
        !           537:     pswpT->x += (SHORT)fm.lAveCharWidth / 2; /* Take care of margin */
        !           538:     pswpT->y = y;
        !           539: 
        !           540:     /* Since Edit control is bigger Setup Start Y for the next row */
        !           541:     y += (cy - pswpT->cy);
        !           542: 
        !           543: 
        !           544:     /* Now position Addr line below PID line */
        !           545:     pswpT=PSWPLN(DID_ADDRLABEL);
        !           546:     WinQueryWindowPos(hwndT = WinWindowFromID(hwndDlg, DID_ADDRLABEL), pswpT);
        !           547:     pswpT->fs = SWP_MOVE;
        !           548:     y = (pswpT->y = y - pswpT->cy - dy);
        !           549: 
        !           550:     pswpT=PSWPLN(DID_ADDR);
        !           551:     WinQueryWindowPos(hwndT = WinWindowFromID(hwndDlg, DID_ADDR), pswpT);
        !           552:     pswpT->fs = SWP_MOVE;
        !           553:     pswpT->x += (SHORT)fm.lAveCharWidth / 2; /* Take care of margin */
        !           554:     pswpT->y = y;
        !           555: 
        !           556:     /* Now set size of listbox */
        !           557:     y += (cy - pswpT->cy);
        !           558: 
        !           559:     pswpT=PSWPLN(DID_SYMLIST);
        !           560:     pswpT->cy = y - dy - pswpT->y;
        !           561: 
        !           562: 
        !           563:     /*
        !           564:      * Return the count of swps
        !           565:      */
        !           566:     return ((MRESULT)(cswp + (DID_PID-DID_SYMLIST+1)));
        !           567: }
        !           568: 
        !           569: 
        !           570: 
        !           571: 
        !           572: /***************************************************************************\
        !           573: * VOID NEAR EndLNDialog(hwndDlg)
        !           574: *
        !           575: * End processing for the List Near Dialog
        !           576: \***************************************************************************/
        !           577: VOID NEAR EndLNDialog(hwndDlg)
        !           578: HWND hwndDlg;
        !           579: {
        !           580:     /* First Dismiss the dialog and destroy the windows */
        !           581:     WinDismissDlg(hwndDlg, 0);
        !           582:     WinDestroyWindow(hwndDlg);
        !           583: 
        !           584:     /* And re-enable the menu item */
        !           585:     WinSendMsg(WinWindowFromID(hwndSpyFrame, FID_MENU),
        !           586:         MM_SETITEMATTR, MPFROM2SHORT(CMD_LISTNEAR, TRUE),
        !           587:         MPFROM2SHORT(MIA_DISABLED, 0));
        !           588: 
        !           589: }
        !           590: 
        !           591: 
        !           592: 
        !           593: /***************************************************************************\
        !           594: * MRESULT CALLBACK ListNearDlgProc(hwnd, msg, mp1, mp2)
        !           595: *
        !           596: * Will locate the symbol near the specified address.
        !           597: \***************************************************************************/
        !           598: MRESULT CALLBACK ListNearDlgProc(hwnd, msg, mp1, mp2)
        !           599: HWND            hwnd;
        !           600: USHORT          msg;
        !           601: MPARAM          mp1;
        !           602: MPARAM          mp2;
        !           603: {
        !           604:     PIDINFO     pidinfo;
        !           605: 
        !           606:     switch (msg) {
        !           607: 
        !           608:     case WM_INITDLG:
        !           609:         /* Initialize the dialog items */
        !           610:         WinSetDlgItemText(hwnd, DID_ADDR, "");
        !           611:         DosGetPID(&pidinfo);
        !           612:         WinSetDlgItemShort(hwnd, DID_PID, (USHORT)pidinfo.pid, FALSE);
        !           613:         break;
        !           614: 
        !           615:     case WM_SYSCOMMAND:
        !           616:         if (SHORT1FROMMP(mp1) == SC_CLOSE) {
        !           617:             /* End processing the dialog */
        !           618:             EndLNDialog(hwnd);
        !           619:             break;
        !           620:         } else
        !           621:             return(WinDefDlgProc(hwnd, msg, mp1, mp2));
        !           622: 
        !           623: 
        !           624:     case WM_COMMAND:
        !           625:         switch (SHORT1FROMMP(mp1)) {
        !           626:         case DID_OK:
        !           627: 
        !           628:             /*
        !           629:              * Process The Ok Button, by caling ProcessLNOkButton, which
        !           630:              * will add the information to the listbox in our dialog.
        !           631:              */
        !           632:             ProcessLNOkButton(hwnd);
        !           633:             break;
        !           634: 
        !           635:         case DID_CANCEL:
        !           636:             /* End processing the dialog */
        !           637:             EndLNDialog(hwnd);
        !           638:             break;
        !           639:         }
        !           640: 
        !           641:         break;
        !           642: 
        !           643:     /*
        !           644:      * We want to add our controls into the formating of the frame, so
        !           645:      * we need to add some room onto the SWP list
        !           646:      */
        !           647:     case WM_QUERYFRAMECTLCOUNT:
        !           648:         return((MRESULT)((SHORT)WinDefDlgProc(hwnd, msg, mp1, mp2) +
        !           649:                 (SHORT)(DID_PID-DID_SYMLIST+1)));
        !           650:         break;
        !           651: 
        !           652:     /*
        !           653:      * Call FormatLNDialog, to format the dialog
        !           654:      */
        !           655:     case WM_FORMATFRAME:
        !           656:         return (FormatLNDialog(hwnd, (PSWP)mp1, (PRECTL)mp2));
        !           657: 
        !           658:     default:
        !           659:         return(WinDefDlgProc(hwnd, msg, mp1, mp2));
        !           660:     }
        !           661: 
        !           662:     return (0L);
        !           663: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.