Changeset 9187 for trunk/src


Ignore:
Timestamp:
Sep 1, 2002, 4:28:46 PM (23 years ago)
Author:
bird
Message:

Backup checking - more structures.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/win32k/kKrnlLib/tools/pmdfrexx/pm.cmd

    r9182 r9187  
    1212 * Globals
    1313 */
    14 sGlobals = '';
     14sGlobals = 'ulHandleTable sGlobals';
     15ulHandleTable = 0;
     16
     17
     18/*
     19 * Args
     20 */
     21parse arg sCmd sArgs
     22sCmd = lowercase(sCmd);
     23sArg = lowercase(sArgs);
     24say '';
    1525
    1626/*
    1727 * Operation
    1828 */
    19 parse arg sCmd sArgs
    20 
    2129select
    22     when (sCmd = 'checksems') then
     30    /*
     31     * pmsems
     32     */
     33    when (sCmd = 'pmsemcheck') then
    2334        return pmsemCheck(sArgs);
    24 /*
    25     when (sCmd = '') then
    26             return
    27 */
     35    when (sCmd = 'pmsemdump') then
     36        return pmsemDump(sArgs);
     37
     38    /*
     39     * Windows Structures.
     40     */
     41    when (sCmd = 'wnddump') then
     42        return wndDump(sArgs);
     43
     44    /*
     45     * Window handles.
     46     */
     47    when (sCmd = 'hwnd') then
     48        return hwnd2PWND(sArgs);
     49
     50    /*
     51     * Generic dump
     52     */
     53    when (sCmd = 'dump' | sCmd = '.d') then
     54    do
     55        parse var sArgs sStruct sDumperArgs
     56        select
     57            when (sStruct = 'mq') then
     58                return MqDump(sDumperArgs);
     59            when (sStruct = 'wnd') then
     60                return WndDump(sDumperArgs);
     61            when (sStruct = 'pmsem') then
     62                return pmsemDump(sDumperArgs);
     63
     64            otherwise
     65                say 'syntax error: no or invalid structure name.';
     66        return syntax(sArgs);
     67        end
     68    end
     69
     70
     71    /*
     72     * Help and syntax error.
     73     */
    2874    when (sCmd = '?' | sCmd = 'help' | sCmd = '-?' | sCmd = '/?' | sCmd = '-h' | sCmd = '/h' | sCmd = '--help') then
    2975        return syntax(sArgs);
    … …  
    4692return -1;
    4793
    48 
    49 
    50 /**
    51  * Check if any of the PM sems are taken or have bogus state.
    52  * @returns 0 on success. -1 on error.
    53  */
    54 pmsemCheck: procedure
    55     sMem = dfReadMem('pmsemaphores', 35*8*4)
    56     if (sMem <> '') then
    57     do
    58         /* loop thru them all listing the taken/bogus ones */
    59         cDumps = 0;
    60         say 'info: checking pm/gre sems'
    61         do iSem = 0 to 34
    62             rc = pmsemValidate(iSem, sMem);
    63             if (rc <> 1) then
    64             do
    65                 if (cDumps = 0) then say '';
    66                 cDumps = cDumps + 1;
    67                 if rc = 0 then  sMsg = 'Taken';
    68                 else            sMsg = 'Bogus';
    69                 call pmsemDump memCopy(iSem * 32, 32, sMem), sMsg, iSem;
    70             end
    71         end
    72         if (cDumps = 0) then
    73             say 'info: pm/gre sems are all free and ok.'
    74         else
    75             say 'info: 'cDumps 'semaphores was taken or bogus.';
    76     end
    77     else
    78         say 'error: failed to read semaphore table.';
    79 return -1;
    80 
     94/* Procedure which we signals on user syntax errors. */
     95synatxerror:
     96    say 'syntax error!'
     97    call syntax;
     98return -1;
     99
     100
     101
     102/*
     103 * PMSEMS/GRESEMS
     104 * PMSEMS/GRESEMS
     105 * PMSEMS/GRESEMS
     106 * PMSEMS/GRESEMS
     107 * PMSEMS/GRESEMS
     108 * PMSEMS/GRESEMS
     109 * PMSEMS/GRESEMS
     110 * PMSEMS/GRESEMS
     111 * PMSEMS/GRESEMS
     112 */
    81113/* access functions */
    82 pmsemIdent:   procedure; parse arg iSem, sMem; return memString(iSem * 32,7,1, sMem);
    83 pmsem386:     procedure; parse arg iSem, sMem; return memByte( iSem * 32 +  7, sMem);
    84 pmsemTid:     procedure; parse arg iSem, sMem; return memWord( iSem * 32 +  8, sMem);
    85 pmsemPid:     procedure; parse arg iSem, sMem; return memWord( iSem * 32 + 10, sMem);
    86 pmsemPTid:    procedure; parse arg iSem, sMem; return memDWord(iSem * 32 +  8, sMem);
    87 pmsemNested:  procedure; parse arg iSem, sMem; return memDword(iSem * 32 + 12, sMem);
    88 pmsemWaiting: procedure; parse arg iSem, sMem; return memDword(iSem * 32 + 16, sMem);
    89 pmsemUseCount:procedure; parse arg iSem, sMem; return memDword(iSem * 32 + 20, sMem);/*debug*/
    90 pmsemHEV:     procedure; parse arg iSem, sMem; return memDword(iSem * 32 + 24, sMem);
    91 pmsemCallAddr:procedure; parse arg iSem, sMem; return memDword(iSem * 32 + 28, sMem);/*debug*/
     114pmsemSize:      procedure expose(sGlobals); return 32;
     115pmsemIdent:     procedure expose(sGlobals); parse arg iSem, sMem; return memString(iSem * 32, 7, 1, sMem);
     116pmsem386:       procedure expose(sGlobals); parse arg iSem, sMem; return memByte( iSem * 32 +  7, sMem);
     117pmsemPid:       procedure expose(sGlobals); parse arg iSem, sMem; return memWord( iSem * 32 +  8, sMem);
     118pmsemTid:       procedure expose(sGlobals); parse arg iSem, sMem; return memWord( iSem * 32 + 10, sMem);
     119pmsemPTid:      procedure expose(sGlobals); parse arg iSem, sMem; return memDWord(iSem * 32 +  8, sMem);
     120pmsemNested:    procedure expose(sGlobals); parse arg iSem, sMem; return memDword(iSem * 32 + 12, sMem);
     121pmsemWaiting:   procedure expose(sGlobals); parse arg iSem, sMem; return memDword(iSem * 32 + 16, sMem);
     122pmsemUseCount:  procedure expose(sGlobals); parse arg iSem, sMem; return memDword(iSem * 32 + 20, sMem);/*debug*/
     123pmsemHEV:       procedure expose(sGlobals); parse arg iSem, sMem; return memDword(iSem * 32 + 24, sMem);
     124pmsemCallAddr:  procedure expose(sGlobals); parse arg iSem, sMem; return memDword(iSem * 32 + 28, sMem);/*debug*/
    92125
    93126
    … …  
    98131 * @param   iSem        The sem we're dumping. (optional)
    99132 */
    100 pmsemDump: procedure;
     133pmsemDump1: procedure expose(sGlobals)
    101134parse arg sSemMem, sMsg, iSem
    102135    if (iSem <> '') then
    … …  
    116149
    117150
     151
     152
     153
     154/**
     155 * Check if any of the PM sems are taken or have bogus state.
     156 * @returns 0 on success. -1 on error.
     157 */
     158PmsemCheck: procedure expose(sGlobals)
     159    sMem = dfReadMem('pmsemaphores', 35 * pmsemSize())
     160    if (sMem <> '') then
     161    do
     162        /* loop thru them all listing the taken/bogus ones */
     163        cDumps = 0;
     164        say 'info: checking pm/gre sems'
     165        do iSem = 0 to 34
     166            rc = pmsemValidate(iSem, sMem);
     167            if (rc <> 1) then
     168            do
     169                if (cDumps = 0) then say '';
     170                cDumps = cDumps + 1;
     171                if rc = 0 then  sMsg = 'Taken';
     172                else            sMsg = 'Bogus';
     173                call pmsemDump1 memCopy(iSem * pmsemSize(), pmsemSize(), sMem), sMsg, iSem;
     174            end
     175        end
     176        if (cDumps = 0) then
     177            say 'info: pm/gre sems are all free and ok.'
     178        else
     179            say 'info: 'cDumps 'semaphores was taken or bogus.';
     180    end
     181    else
     182        say 'error: failed to read semaphore table.';
     183return -1;
     184
     185
     186/**
     187 * Check if any of the PM sems are taken or have bogus state.
     188 * @returns 0 on success. -1 on error.
     189 */
     190PmsemDump: procedure expose(sGlobals)
     191parse arg sAddr  cCount
     192    /* defaults and param validation */
     193    if (cCount = '' | datatype(cCount) <> 'NUM') then
     194        cCount = 1;
     195    if (sAddr = '') then
     196        signal SyntaxError
     197
     198    /* read memory and do the dump */
     199    sMem = dfReadMem(sAddr, cCount * pmsemSize())
     200    if (sMem <> '') then
     201    do
     202        /* loop thru them all listing the taken/bogus ones */
     203        do i = 0 to cCount - 1
     204            call pmsemDump1 memCopy(i * pmsemSize(), pmsemSize(), sMem);
     205        end
     206    end
     207    else
     208        say 'error: failed to read semaphore table.';
     209return -1;
     210
     211
    118212/**
    119213 * Checks a give PM sem is free and not bogus.
    … …  
    125219 *                  (If no array use iSem=0)
    126220 */
    127 pmsemValidate: procedure
     221pmsemValidate: procedure expose(sGlobals)
    128222parse arg iSem, sMem
    129223    if (pmsemPTid(iSem, sMem) <> 0) then
    … …  
    138232
    139233
    140 
    141234/**
    142235 * Gives us the name of the pmsem at a given index.
    … …  
    144237 * @param   i   Index
    145238 */
    146 pmsemGetName: procedure;
     239pmsemGetName: procedure expose(sGlobals)
    147240parse arg i
    148241    select
    … …  
    186279return 'Unknown-'i;
    187280
     281
     282
    188283/*
    189  * COMMON
    190  * COMMON
    191  * COMMON
    192  * COMMON
    193  * COMMON
    194  * COMMON
     284 * WINDOW STRUCTURE (WND)
     285 * WINDOW STRUCTURE (WND)
     286 * WINDOW STRUCTURE (WND)
     287 * WINDOW STRUCTURE (WND)
     288 * WINDOW STRUCTURE (WND)
     289 * WINDOW STRUCTURE (WND)
     290 * WINDOW STRUCTURE (WND)
     291 * WINDOW STRUCTURE (WND)
     292 * WINDOW STRUCTURE (WND)
     293 * WINDOW STRUCTURE (WND)
     294 */
     295/* size and access functions */
     296wndSize:            procedure expose(sGlobals); return 144; /* guesswork! */
     297
     298wndNext:            procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('00'), sMem);
     299wndParent:          procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('04'), sMem);
     300wndChild:           procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('08'), sMem);
     301wndOwner:           procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('0c'), sMem);
     302wndRecs:            procedure expose(sGlobals); parse arg iWord,sMem;return memWord( x2d('10') + iWord*2, sMem);
     303wndStyle:           procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('18'), sMem);
     304wndId:              procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('1c'), sMem);
     305wndMsgQueue:        procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('28'), sMem);
     306wndHWND:            procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('2c'), sMem);
     307wndModel:           procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('30'), sMem);
     308wndProc:            procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('34'), sMem);
     309wndThunkProc:       procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('38'), sMem);
     310wndPresParams:      procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('40'), sMem);
     311wndFocus:           procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('44'), sMem);
     312wndWPSULong:        procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('48'), sMem);
     313wndInstData:        procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('50'), sMem);
     314wndOpen32:          procedure expose(sGlobals); parse arg sMem;      return memDword(x2d('58'), sMem);
     315/*
     316wndWord:            procedure expose(sGlobals); parse arg iWord,sMem;return memDword(96 + iWord*4, sMem);
     317*/
     318/** dump one wnd structure */
     319wndDump1: procedure expose(sGlobals)
     320parse arg sMem, sMsg
     321    if (sMsg <> '') then
     322        say sMsg
     323    say '      pwndNext:' d2x(wndNext(sMem),8);
     324    say '    pwndParent:' d2x(wndParent(sMem),8);
     325    say '     pwndChild:' d2x(wndChild(sMem),8);
     326    say '     pwndOwner:' d2x(wndOwner(sMem),8);
     327    say '     rcsWindow: xl='wndRecs(0, sMem)',yl='wndRecs(1, sMem),
     328                        'xr='wndRecs(2, sMem)',yr='wndRecs(3, sMem) '(decimal)'
     329    say '       ulStyle:' d2x(wndStyle(sMem),8);
     330    say '            id:' d2x(wndId(sMem),8);
     331    say '   pmqMsgQueue:' d2x(wndMsgQueue(sMem),8);
     332    say '          hwnd:' d2x(wndHWND(sMem),8);
     333    say '   fModel16bit:' d2x(wndModel(sMem),8);
     334    say '    pfnWinProc:' d2x(wndProc(sMem),8)  '('dfNear('%'d2x(wndProc(sMem),8))')'
     335    if (wndThunkProc(sMem) = 0) then
     336        say '  pfnThunkProc:' d2x(wndThunkProc(sMem),8)
     337    else
     338        say '  pfnThunkProc:' d2x(wndThunkProc(sMem),8) ' ('dfNear('%'d2x(wndThunkProc(sMem),8))')'
     339    say '   ppresParams:' d2x(wndPresParams(sMem),8);
     340    say '     pwndFocus:' d2x(wndFocus(sMem),8);
     341    say '         ulWPS:' d2x(wndWPSULong(sMem),8);
     342    say '     pInstData:' d2x(wndInstData(sMem),8);
     343    say '            ??:' d2x(memDword(x2d('54'), sMem),8);
     344    say '       pOpen32:' d2x(wndOpen32(sMem),8);
     345/*  This aint right!
     346    i = 0;
     347    do while (i < 12)
     348        say ' aulWin['d2x(i,2)'-'d2x(i+3,2)']: '||,
     349                             d2x(wndWord(i+0, sMem), 8) d2x(wndWord(i+1, sMem), 8),
     350                             d2x(wndWord(i+2, sMem), 8) d2x(wndWord(i+3, sMem), 8)
     351        i = i + 4;
     352    end
     353*/
     354return 0;
     355
     356
     357/**
     358 * Dump window structures.
     359 */
     360WndDump: procedure expose(sGlobals)
     361parse arg sAddr cCount
     362    /*defaults and param validation */
     363    if (cCount = '' | datatype(cCount) <> 'NUM') then
     364        cCount = 1;
     365    if (sAddr = '') then
     366        signal SyntaxError
     367    if (hwndIsHandle(sAddr)) then
     368    do
     369        ulPWND = hwnd2PWND(sAddr);
     370        if (ulPWND > 0) then
     371            sAddr = '%'d2x(ulPWND);
     372    end
     373
     374    /* read memory */
     375    sMem = dfReadMem(sAddr, cCount * wndSize())
     376    if (sMem <> '') then
     377    do
     378        /* loop thru them all listing the taken/bogus ones */
     379        do i = 0 to cCount - 1
     380            call wndDump1 memCopy(i * wndSize(), wndSize(), sMem);
     381        end
     382    end
     383    else
     384        say 'error: failed to read window structure at '''sAddr'''.';
     385return 0;
     386
     387
     388
     389
     390/*
     391 * WINDOW HANDLE (HWND)
     392 * WINDOW HANDLE (HWND)
     393 * WINDOW HANDLE (HWND)
     394 * WINDOW HANDLE (HWND)
     395 * WINDOW HANDLE (HWND)
     396 * WINDOW HANDLE (HWND)
     397 * WINDOW HANDLE (HWND)
     398 * WINDOW HANDLE (HWND)
     399 */
     400hwnd2PWND: procedure expose(sGlobals)
     401parse arg sHwnd sDummy
     402    ulIndex = x2d(right(sHwnd, 4));
     403    ulBase = hwndpHandleTable();
     404    if (ulBase = 0) then
     405        return 0;
     406
     407    ulHandleEntry = ulBase + ulIndex * 8 + 32;
     408return dfReadDword('%'d2x(ulHandleEntry, 8), 4);
     409
     410
     411/**
     412 * Checks if a value is a hwnd.
     413 * @returns true/false.
     414 * @param   sValue  Value in question.
     415 */
     416hwndIsHandle: procedure expose(sGlobals)
     417parse arg sValue sDummy
     418
     419    /* Paranoid check if this is a number or hex value or whatever*/
     420    sValue = strip(sValue);
     421    if (sValue = '') then
     422        return 0;
     423    if (datatype(sValue) <> 'NUM') then
     424    do  /* assumes kind of hexx */
     425        sValue = translate(sValue);
     426        if (left(sValue, 2) = '0X') then
     427            sValue = substr(sValue, 3);
     428        if (right(sValue,1) = 'H') then
     429            sValue = substr(sValue, 1, length(sValue) - 1);
     430        if (sValue = '') then
     431            return 0;
     432        if (strip(translate(sValue, '', '123456767ABCDEF')) <> '') then
     433            return 0;
     434        ulValue = x2d(sValue);
     435    end
     436    else
     437    do  /* check if decimal value, if not try hex */
     438        if (sValue >= x2d('80000001') & sValue < x2d('8000ffff')) then
     439            return 1;
     440         ulValue = x2d(sValue);
     441    end
     442
     443    /* Check for valid handle range. */
     444return ulValue >= x2d('80000001') & ulValue < x2d('8000ffff');
     445
     446
     447/**
     448 * Gets the pointer to the handle table.
     449 */
     450hwndpHandleTable: procedure expose(sGlobals)
     451    if (ulHandleTable > 0) then
     452        return ulHandleTable;
     453
     454    ulHandleTable = dfReadDword('pHandleTable', 4);
     455    if (ulHandleTable > 0) then
     456        return ulHandleTable
     457    say 'error-hwndpHandleTable: failed to read pHandleTable';
     458return 0;
     459
     460
     461
     462/*
     463 * MESSAGE QUEUE STRUCTURE (MQ)
     464 * MESSAGE QUEUE STRUCTURE (MQ)
     465 * MESSAGE QUEUE STRUCTURE (MQ)
     466 * MESSAGE QUEUE STRUCTURE (MQ)
     467 * MESSAGE QUEUE STRUCTURE (MQ)
     468 * MESSAGE QUEUE STRUCTURE (MQ)
     469 * MESSAGE QUEUE STRUCTURE (MQ)
     470 * MESSAGE QUEUE STRUCTURE (MQ)
     471 * MESSAGE QUEUE STRUCTURE (MQ)
     472 */
     473mqSize:             procedure expose(sGlobals);  return x2d('b0');
     474mqNext:             procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('00'), sMem);
     475mqEntrySize:        procedure expose(sGlobals);  parse arg sMem;     return memWord(x2d('04'), sMem);
     476/*mqQueue:            procedure expose(sGlobals);  parse arg sMem;     return memWord(x2d('06'), sMem);*/
     477mqMessages:         procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('08'), sMem);
     478/* ?? */
     479mqMaxMessages:      procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('0c'), sMem);
     480mqTid:              procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('18'), sMem);
     481mqPid:              procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('1c'), sMem);
     482mqFirstMsg:         procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('20'), sMem);
     483mqLastMsg:          procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('24'), sMem);
     484mqSGid:             procedure expose(sGlobals);  parse arg sMem;     return memWord(x2d('28'), sMem);
     485mqHev:              procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('2c'), sMem);
     486mqSent:             procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('3c'), sMem);
     487mqCurrent:          procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('40'), sMem);
     488
     489mqBadPwnd:          procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('68'), sMem);
     490mqBadQueue:         procedure expose(sGlobals);  parse arg sMem;     return memByte(x2d('6c'), sMem);
     491mqCountTimers:      procedure expose(sGlobals);  parse arg sMem;     return memByte(x2d('6d'), sMem);
     492mqHeap:             procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('70'), sMem);
     493mqHAccel:           procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('74'), sMem);
     494
     495mqShutdown:         procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('90'), sMem);
     496
     497mqRcvdSMSList:      procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('98'), sMem);
     498mqSlot:             procedure expose(sGlobals);  parse arg sMem;     return memDword(x2d('a0'), sMem);
     499
     500/** dump one mq structure */
     501mqDump1: procedure expose(sGlobals)
     502parse arg sMem;
     503    say '     pmqNext:' d2x(mqNext(sMem), 8);
     504    say '     cbEntry:' d2x(mqEntrySize(sMem), 8);
     505    say '   cMessages:' d2x(mqMessages(sMem), 8);
     506    say 'cMaxMessages:' d2x(mqMaxMessages(sMem), 8);
     507    say '         Tid:' d2x(mqTid(sMem), 8);
     508    say '         Pid:' d2x(mqPid(sMem), 8);
     509    say 'psmsFirstMsg:' d2x(mqFirstMsg(sMem), 8);
     510    say ' psmsLastMsg:' d2x(mqLastMsg(sMem), 8);
     511    say '        SGId:' d2x(mqSGid(sMem), 8);
     512    say '         hev:' d2x(mqHev(sMem), 8);
     513    say '    psmsSent:' d2x(mqSent(sMem), 8);
     514    say ' psmsCurrent:' d2x(mqCurrent(sMem), 8);
     515    say '     pwndBad:' d2x(mqBadPWND(sMem), 8);
     516    say '   fBadQueue:' d2x(mqBadQueue(sMem), 2);
     517    say '     cTimers:' d2x(mqCountTimers(sMem), 2);
     518    say '       pHeap:' d2x(mqHeap(sMem), 8);
     519    say '      HACCEL:' d2x(mqHAccel(sMem), 8);
     520    say ' fchShutdown:' d2x(mqShutdown(sMem), 2);
     521    say ' RcvdSMSList:' d2x(mqRcvdSMSList(sMem), 8);
     522    say '        Slot:' d2x(mqSlot(sMem), 4);
     523return 0;
     524
     525
     526/**
     527 * Message queue dumper.
     528 * @param   sAddr   Address expression of a MQ struct, or a window
     529 *                  which message queue you wanna dump.
     530 * @returns 0
     531 */
     532mqDump: procedure expose(sGlobals)
     533parse arg sAddr cCount
     534    /*defaults and param validation */
     535    if (cCount = '' | datatype(cCount) <> 'NUM') then
     536        cCount = 1;
     537    if (sAddr = '') then
     538        signal SyntaxError
     539
     540    /*
     541     * The user might have passed in an window handle.
     542     * If so we'll dump it's queue.
     543     */
     544    if (hwndIsHandle(sAddr)) then
     545    do  /* input is a hwnd, we will try dump it's queue */
     546        ulPWND = hwnd2PWND(sAddr);
     547        if (ulPWND > 0) then
     548        do
     549            sMem = dfReadMem('%'d2x(ulPWND), wndSize());
     550            if (sMem <> '') then
     551            do
     552                ulMQ = wndMsgQueue(sMem);
     553                if (ulMq > 0) then
     554                    sAddr = '%'d2x(ulPWND);
     555            end
     556            drop sMem;
     557        end
     558    end
     559
     560    /* read memory */
     561    sMem = dfReadMem(sAddr, cCount * mqSize())
     562    if (sMem <> '') then
     563    do
     564        /* loop thru them all listing the taken/bogus ones */
     565        do i = 0 to cCount - 1
     566            call mqDump1 memCopy(i * mqSize(), mqSize(), sMem);
     567        end
     568    end
     569    else
     570        say 'error: failed to read window structure at '''sAddr'''.';
     571return 0;
     572
     573
     574
     575
     576/*
     577 * PMDF WORKERS
     578 * PMDF WORKERS
     579 * PMDF WORKERS
     580 * PMDF WORKERS
     581 * PMDF WORKERS
     582 * PMDF WORKERS
     583 * PMDF WORKERS
     584 * PMDF WORKERS
     585 * PMDF WORKERS
     586 * PMDF WORKERS
     587 * PMDF WORKERS
     588 * PMDF WORKERS
    195589 */
    196590
    … …  
    203597 * @returns The memory we have read. (internal format!)
    204598 */
    205 dfReadMem: procedure
     599dfReadMem: procedure expose(sGlobals)
    206600parse arg sStartExpr, cbLength
    207601
    … …  
    209603    if ((cbLength // 4) = 0) then
    210604    do  /* optimized read */
    211         say 'df: dd' sStartExpr 'L'cbLength/4'T'
     605        /*say 'dbg-df: dd' sStartExpr 'L'cbLength/4'T'*/
    212606        Address df 'CMD' 'asOut' 'dd' sStartExpr 'L'cbLength/4'T'
    213         say 'df: rc='rc' asOut.0='asOut.0;
     607        /*say 'dbg-df: rc='rc' asOut.0='asOut.0;*/
    214608        if (rc = 0) then
    215609        do
    … …  
    232626                end
    233627            end
    234             return d2x(j,8)||sMem;
     628            if (j <> 0) then
     629                return d2x(j,8)||sMem;
    235630        end
    236631
    … …  
    238633    else
    239634    do  /* slower (more output) byte by byte read */
    240         say 'df: db' sStartExpr 'L'cbLength'T'
     635        /*say 'dbg-df: db' sStartExpr 'L'cbLength'T'*/
    241636        Address df 'CMD' 'asOut' 'db' sStartExpr 'L'cbLength'T'
    242         say 'df: rc='rc' asOut.0='asOut.0;
     637        /*say 'dbg-df: rc='rc' asOut.0='asOut.0;*/
    243638        if (rc = 0) then
    244639        do
    … …  
    261656                end
    262657            end
    263             return right(d2x(j), 8, '0')||sMem;
    264         end
     658            if (j <> 0) then
     659                return d2x(j,8)||sMem;
     660        end
     661    end
     662return '';
     663
     664
     665/**
     666 * Reads a DWord at a given address.
     667 * @param   sAddr   Address expression.
     668 * @return  The value of the dword at given address.
     669 *          -1 on error.
     670 */
     671dfReadByte: procedure expose(sGlobals)
     672parse arg sAddr
     673    sMem = dfReadMem(sAddr, 4);
     674    if (sMem <> '') then
     675        return memByte(0, sMem);
     676return -1;
     677
     678
     679/**
     680 * Reads a Word at a given address.
     681 * @param   sAddr   Address expression.
     682 * @return  The value of the dword at given address.
     683 *          -1 on error.
     684 */
     685dfReadWord: procedure expose(sGlobals)
     686parse arg sAddr
     687    sMem = dfReadMem(sAddr, W);
     688    if (sMem <> '') then
     689        return memWord(0, sMem);
     690return -1;
     691
     692
     693/**
     694 * Reads a DWord at a given address.
     695 * @param   sAddr   Address expression.
     696 * @return  The value of the dword at given address.
     697 *          -1 on error.
     698 */
     699dfReadDWord: procedure expose(sGlobals)
     700parse arg sAddr
     701    sMem = dfReadMem(sAddr, 4);
     702    if (sMem <> '') then
     703        return memDword(0, sMem);
     704return -1;
     705
     706
     707/**
     708 * Get near symbol.
     709 * @param   sAddr   Address expression.
     710 * @return  Near output.
     711 *          '' on error.
     712 */
     713dfNear: procedure expose(sGlobals)
     714parse arg sAddr
     715    Address df 'CMD' 'asOut' 'ln' sAddr
     716    if (rc = 0 & asOut.0 > 0) then
     717    do
     718        parse var asOut.1 .' 'sRet;
     719        return strip(sRet);
    265720    end
    266721return '';
    … …  
    271726 * @param   iIndex      Byte offset into the array.
    272727 */
    273 memByte: procedure
     728memByte: procedure expose(sGlobals)
    274729parse arg iIndex, sMem
    275730    cb = memSize(sMem);
    … …  
    278733        return x2d(substr(sMem, (iIndex * 2) + 9 + 0, 2));
    279734    end
    280     say 'error-memByte: access out of range.'
     735    say 'error-memByte: access out of range. cb='cb ' iIndex='iIndex;
    281736return -1;
    282737
    … …  
    286741 * @param   iIndex      Byte offset into the array.
    287742 */
    288 memWord: procedure
     743memWord: procedure expose(sGlobals)
    289744parse arg iIndex, sMem
    290745    cb = memSize(sMem);
    … …  
    294749                   substr(sMem, (iIndex * 2) + 9 + 0, 2));
    295750    end
    296     say 'error-memWord: access out of range.'
     751    say 'error-memWord: access out of range. cb='cb ' iIndex='iIndex;
    297752return -1;
    298753
    … …  
    304759 * @remark  note problems with signed!
    305760 */
    306 memDword: procedure
     761memDword: procedure expose(sGlobals)
    307762parse arg iIndex, sMem
    308763    cb = memSize(sMem);
    … …  
    315770                     substr(sMem, iIndex + 0, 2));
    316771    end
    317     say 'error-memDword: access out of range.'
     772    say 'error-memDword: access out of range. cb='cb ' iIndex='iIndex;
    318773return -1;
    319774
    … …  
    328783 *                          Default is to fetch cchLength if cchLength is specifed.
    329784 */
    330 memString: procedure
     785memString: procedure expose(sGlobals)
    331786parse arg iIndex, cchLength, fStoppAtNull, sMem
    332787    cb = memSize(sMem);
    … …  
    353808        return sStr;
    354809    end
    355     say 'error-memWord: access out of range.'
     810    say 'error-memWord: access out of range. cb='cb ' cbLength='cbLength;
    356811return '';
    357812
    … …  
    364819 * @paran   sMem        Memory block.
    365820 */
    366 memDumpByte: procedure
     821memDumpByte: procedure expose(sGlobals)
    367822parse arg iIndex, cbLength, sMem
    368823    cb = memSize(sMem);
    … …  
    401856        return 0;
    402857    end
    403     say 'error-memDumpByte: access out of range.'
     858    say 'error-memDumpByte: access out of range. cb='cb 'iIndex='iIndex 'cbLength='cbLength;
    404859return -1;
    405860
    … …  
    412867 * @paran   sMem        Memory block.
    413868 */
    414 memDumpWord: procedure
     869memDumpWord: procedure expose(sGlobals)
    415870parse arg iIndex, cbLength, sMem
    416871    cb = memSize(sMem);
    … …  
    435890        return 0;
    436891    end
    437     say 'error-memDumpWord: access out of range.'
     892    say 'error-memDumpWord: access out of range. cb='cb ' cbLength='cbLength;
    438893return -1;
    439894
    … …  
    446901 * @paran   sMem        Memory block.
    447902 */
    448 memDumpDword: procedure
     903memDumpDword: procedure expose(sGlobals)
    449904parse arg iIndex, cbLength, sMem
    450905    cb = memSize(sMem);
    … …  
    469924        return 0;
    470925    end
    471     say 'error-memDumpDword: access out of range.'
     926    say 'error-memDumpDword: access out of range. cb='cb ' cbLength='cbLength;
    472927return -1;
    473928
    … …  
    479934 * @param   sMem        Source block.
    480935 */
    481 memCopy: procedure;
     936memCopy: procedure expose(sGlobals)
    482937parse arg iIndex, cbLength, sMem
    483938    cb = memSize(sMem);
    … …  
    485940    do
    486941        sCopy = d2x(cbLength,8)||substr(sMem, 9 + iIndex * 2, cbLength * 2);
    487         say 'dbg-memCopy: 'left(sCopy,8);
    488942        return sCopy
    489943    end
    490     say 'error-memCopy: access out of range.';
     944    say 'error-memCopy: access out of range. cb='cb ' cbLength='cbLength;
    491945return -1;
    492946
    … …  
    496950 * @param   sMem    The memory block in question.
    497951 */
    498 memSize: procedure;
     952memSize: procedure expose(sGlobals)
    499953parse arg sMem
    500954/* debug assertions - start - comment out when stable! */
    … …  
    517971exit(16);
    518972
     973
     974/**
     975 * Lowercases a string.
     976 * @param   sString     String to fold down.
     977 * @returns Lowercase version of sString.
     978 */
     979lowercase: procedure expose(sGlobals)
     980parse arg sString
     981return translate(sString,,
     982                 'abcdefghijklmnopqrstuvwxyz',,
     983                 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
Note: See TracChangeset for help on using the changeset viewer.