parse.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

//
//*************************************************************************
void UnassembleOneLineDown(void)
{
    ULONG addr,addrorg;

    DPRINT((0,"UnassembleOneLineDown()\n"));

    addrorg = addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);

    DPRINT((0,"UnassembleOneLineDown(): addr = %.8X\n",addr));

    tempCmd[0]=0;
	Disasm(&addr,tempCmd);

    DPRINT((0,"UnassembleOneLineDown(): addr after = %.8X\n",addr));

    ulOldDisasmOffset += (addr - addrorg);
    RepaintSource();
}

//*************************************************************************
// UnassembleOnePageDown()
//
//*************************************************************************
void UnassembleOnePageDown(ULONG page)
{
    ULONG addr,addrorg,i;

    DPRINT((0,"UnassembleOnePageDown()\n"));

    addrorg = addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);

    DPRINT((0,"UnassembleOnePageDown(): addr = %.8X\n",addr));

    tempCmd[0]=0;
    for(i=0;i<page;i++)
	    Disasm(&addr,tempCmd);

    DPRINT((0,"UnassembleOnePageDown(): addr after = %.8X\n",addr));

    ulOldDisasmOffset += (addr - addrorg);
    RepaintSource();
}

//*************************************************************************
// UnassembleOneLineUp()
//
//*************************************************************************
void UnassembleOneLineUp(void)
{
    ULONG addr,addrorg,addrbefore,start,end,addrstart;
    LONG offset;
    LPSTR pSymbol;

    DPRINT((0,"UnassembleOneLineUp()\n"));

    addrorg = addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);

    DPRINT((0,"UnassembleOneLineUp(): addrorg = %.8X\n",addr));

    offset = 1;

    if((pSymbol = FindFunctionByAddress(addrorg-offset,&start,&end)) )
    {
        offset = addrorg - start;
        DPRINT((0,"UnassembleOneLineUp(): %s @ offset = %u\n",pSymbol,offset));
    }
    else
    {
        // max instruction length is 15 bytes
        offset = 15;
    }

    addrstart = addrorg;

    // start at current address less offset
    addr = addrorg - offset;
    do
    {
        DPRINT((0,"UnassembleOneLineUp(): offset = %u addrorg %x addr %x\n",offset,addrorg,addr));
        // disassemble while not reaching current instruction
        addrbefore = addr;
        tempCmd[0]=0;
	    Disasm(&addr,tempCmd);
        DPRINT((0,"%.8X: %s\n",addrbefore,tempCmd));
    }while((addr != addrorg) && (addrbefore < addrorg));

    if((addrorg - addrstart)<=0)
        ulOldDisasmOffset--;
    else
        ulOldDisasmOffset -= (addrorg - addrbefore);

    DPRINT((0,"UnassembleOneLineUp(): new addr = %.4X:%.8X\n",usOldDisasmSegment,ulOldDisasmOffset));

    RepaintSource();
}

//*************************************************************************
// UnassembleOneLineUp()
//
//*************************************************************************
void UnassembleOnePageUp(ULONG page)
{
    ULONG addr,addrorg,addrbefore,start,end,i,addrstart;
    LONG offset;
    LPSTR pSymbol;

    DPRINT((0,"UnassembleOnePageUp()\n"));

    for(i=0;i<page;i++)
    {
        addrorg = addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);

        DPRINT((0,"UnassembleOnePageUp(): addrorg = %.8X\n",addr));

        offset = 1;

        if((pSymbol = FindFunctionByAddress(addrorg-offset,&start,&end)) )
        {
            offset = addrorg - start;
            DPRINT((0,"UnassembleOnePageUp(): %s @ offset = %u\n",pSymbol,offset));
        }
        else
        {
            // max instruction length is 15 bytes
            offset = 15;
        }

        // start at current address less offset
        addr = addrorg - offset;
        addrstart = addrorg;
        do
        {
            DPRINT((0,"UnassembleOnePageUp(): offset = %u addrorg %x addr %x\n",offset,addrorg,addr));
            addrbefore = addr;
            // disassemble while not reaching current instruction
            tempCmd[0]=0;
	        Disasm(&addr,tempCmd);
            DPRINT((0,"%.8X: %s\n",addrbefore,tempCmd));
        }while((addr != addrorg) && (addrbefore < addrorg));

        if((addrorg - addrstart)<=0)
            ulOldDisasmOffset--;
        else
            ulOldDisasmOffset -= (addrorg - addrbefore);

    }

    DPRINT((0,"UnassembleOnePageUp(): new addr = %.4X:%.8X\n",usOldDisasmSegment,ulOldDisasmOffset));

    RepaintSource();
}

//*************************************************************************
// Unassemble()
//
//*************************************************************************
COMMAND_PROTOTYPE(Unassemble)
{
    ULONG i;
    ULONG addr=0,addrorg,addrstart,ulLineNumber;
    USHORT segment=0;
    ULONG addrbefore;
    LPSTR pSymbolName;
	BOOLEAN bSWBpAtAddr;
    LPSTR pSrc,pFilename,pSrcStart,pSrcEnd;
    BOOLEAN bForceDisassembly = FALSE;

	DPRINT((0,"Unassemble: CountSwitches: %u, count: %u\n", pArgs->CountSwitches, pArgs->Count));
    if(pArgs->CountSwitches>1)
        return TRUE;

    if(pArgs->CountSwitches==1)
    {
        if(pArgs->Switch[0] == 'f')
            bForceDisassembly = TRUE;
    }

	// we have args
	if(pArgs->Count==2)
	{
		addr=pArgs->Value[1];
		segment=(USHORT)pArgs->Value[0];
		addrorg=addrstart=addr;
		addr=GetLinearAddress(segment,addr);

        usOldDisasmSegment = segment;
        ulOldDisasmOffset = addr;
	}
	else if(pArgs->Count==1)
	{
		addr=pArgs->Value[0];
		segment=CurrentCS;
		addrorg=addrstart=addr;
		addr=GetLinearAddress(segment,addr);

        usOldDisasmSegment = segment;
        ulOldDisasmOffset = addr;
	}
	else if(pArgs->Count==0)
    {
        segment = usOldDisasmSegment;
		addrorg=addrstart=addr;
        addr = GetLinearAddress(usOldDisasmSegment,ulOldDisasmOffset);
    }
    else
        return TRUE;


	DPRINT((0,"Unassemble(%0.4X:%0.8X), lastst: %x, lastend:%x\n",segment,addr,ulLastDisassStartAddress,ulLastDisassEndAddress));

 	//
	// unassemble
    //
    DisableScroll(SOURCE_WINDOW);

    // if we're inside last disassembly range we only need to move to highlight
    if(ulLastDisassStartAddress && ulLastDisassEndAddress && addr>=ulLastDisassStartAddress &&
       addr<ulLastDisassEndAddress )
	{
		addr=ulLastDisassStartAddress;
	}
	else
	{
		ulLastDisassStartAddress=ulLastDisassEndAddress=0;
	}

    SetForegroundColor(COLOR_TEXT);
	SetBackgroundColor(COLOR_CAPTION);

	ClrLine(wWindow[SOURCE_WINDOW].y-1);

    ResetColor();

    if(ScanExportsByAddress(&pSymbolName,addr))
    {
        SetForegroundColor(COLOR_TEXT);
	    SetBackgroundColor(COLOR_CAPTION);
		PICE_sprintf(tempCmd," %s ",pSymbolName);
		PutChar(tempCmd,GLOBAL_SCREEN_WIDTH-1-PICE_strlen(tempCmd),wWindow[SOURCE_WINDOW].y-1);
        ResetColor();
    }

    pCurrentMod = FindModuleFromAddress(addr);
    if(pCurrentMod)
    {
        ULONG mod_addr;
	    DPRINT((0,"Unassemble(): pCurrentMod->name = %S\n",pCurrentMod->name));
        mod_addr = (ULONG)pCurrentMod->BaseAddress;

        pCurrentSymbols = FindModuleSymbols(mod_addr);
   	    DPRINT((0,"Unassemble(): pCurrentSymbols = %x\n",(ULONG)pCurrentSymbols));
    }
	DPRINT((0,"Unassemble(): pCurrentMod = %x, showsrc: %d\n",pCurrentMod, bShowSrc));

    ulCurrentlyDisplayedLineNumber = 0;

    if(bShowSrc && bForceDisassembly == FALSE && (pSrc = FindSourceLineForAddress(addr,&ulLineNumber,&pSrcStart,&pSrcEnd,&pFilename)) )
    {
		DPRINT((0,"FoundSourceLineForAddress: file: %s line: %d\n", pFilename, ulLineNumber));
        PICE_strcpy(szCurrentFile,pFilename);

        ulCurrentlyDisplayedLineNumber = ulLineNumber;

    	Clear(SOURCE_WINDOW);

        // display file name
        SetForegroundColor(COLOR_TEXT);
	    SetBackgroundColor(COLOR_CAPTION);

        if(PICE_strlen(pFilename)<GLOBAL_SCREEN_WIDTH/2)
        {
		    PutChar(pFilename,1,wWindow[SOURCE_WINDOW].y-1);
        }
        else
        {
            LPSTR p;

            p = strrchr(pFilename,'/');
            if(!p)
            {
                p = pFilename;
            }
            else
            {
                p++;
            }

		    PutChar(p,1,wWindow[SOURCE_WINDOW].y-1);
        }

        ResetColor();

        // display the source
        if(ulLineNumber>(wWindow[SOURCE_WINDOW].cy/2) )
        {
            DisplaySourceFile(pSrcStart,pSrcEnd,ulLineNumber-(wWindow[SOURCE_WINDOW].cy/2),ulLineNumber);
        }
        else
        {
            DisplaySourceFile(pSrcStart,pSrcEnd,ulLineNumber,ulLineNumber);
        }
    }
    else
    {
        *szCurrentFile = 0;
		DPRINT((0,"Couldn't find source for file\n"));
        Home(SOURCE_WINDOW);
        // for each line in the disassembly window
	    for(i=0;i<wWindow[SOURCE_WINDOW].cy;i++)
	    {
            extern ULONG ulWindowOffset;

		    bSWBpAtAddr = FALSE;
		    // if there is a potential SW breakpoint at address
		    // we might have to put back the original opcode
		    // in order to disassemble correctly.
		    if(IsSwBpAtAddress(addr))
		    {
			    // if INT3 is there, remove it while disassembling
			    if((bSWBpAtAddr = IsSwBpAtAddressInstalled(addr)))
			    {
				    DeInstallSWBreakpoint(addr);
			    }
		    }

		    ClrLine(wWindow[SOURCE_WINDOW].y+i);

		    // invert the line that we're about to execute
		    if(addr==CurrentEIP)
		    {
                SetForegroundColor(COLOR_BACKGROUND);
                SetBackgroundColor(COLOR_FOREGROUND);
			    ulLastInvertedAddress = CurrentEIP;
		    }

		    // output segment:offset address
		    PICE_sprintf(tempCmd,"%0.4X:%0.8X ",segment,addr);
		    Print(SOURCE_WINDOW,tempCmd);

            // disassemble a line
		    addrbefore=addr;
            if(bCodeOn)
            {
                tempCmd[30]=0;
        		Disasm(&addr,&tempCmd[30]);
            }
            else
            {
                tempCmd[0]=0;
        		Disasm(&addr,tempCmd);
            }
		    addrorg+=(addr-addrbefore);

            // want to display opcode bytes
		    if(bCodeOn)
		    {
			    ULONG j;

			    for(j=0;j<15;j++)
			    {
                    if(j<addr-addrbefore)
                    {
				        if(IsAddressValid(addrbefore+j))
				        {
					        tempCmd[j*2]=HexDigit[((*(PUCHAR)(addrbefore+j)&0xF0)>>4)];
					        tempCmd[j*2+1]=HexDigit[((*(PUCHAR)(addrbefore+j)&0xF))];
				        }
				        else
				        {
					        tempCmd[j*2]='?';
					        tempCmd[j*2+1]='?';
				        }
                    }
                    else
                    {
					        tempCmd[j*2]=' ';
					        tempCmd[j*2+1]=' ';
                    }
			    }
		    }
            PICE_strcat(tempCmd,"\n");

            if(ulWindowOffset)
            {
                LONG len = PICE_strlen(tempCmd);
                if(ulWindowOffset < len)
                    PICE_memcpy(tempCmd,&tempCmd[ulWindowOffset],len-ulWindowOffset);
                else
                    tempCmd[0]='\n';
            }

		    Print(SOURCE_WINDOW,tempCmd);

            if(addrbefore==CurrentEIP)
		    {
			    ResetColor();
		    }

		    // if potential SW breakpoint, undo marked text
		    if(IsSwBpAtAddress(addrbefore))
		    {
				HatchLine(wWindow[SOURCE_WINDOW].y+i);
		    }

		    // if breakpoint was installed before disassembly, put it back
		    if(bSWBpAtAddr)
		    {
			    ReInstallSWBreakpoint(addrbefore);
		    }

	    }

        if(ulLastDisassStartAddress==0 && ulLastDisassEndAddress==0)
        {
            ulLastDisassStartAddress=addrstart;
            ulLastDisassEndAddress=addr;
        }

	    if(!IsAddressValid(addrstart))
	    {
            ulLastDisassStartAddress=0;
            ulLastDisassEndAddress=0;
	    }

    }

	EnableScroll(SOURCE_WINDOW);

	return TRUE;
}

//*************************************************************************
// ShowModules()
//
//*************************************************************************
COMMAND_PROTOTYPE(ShowModules)
{
	PDEBUG_MODULE pMod;
	DPRINT((0,"ShowModules()\n"));

	if(BuildModuleList())
    {
        pMod = pdebug_module_head;
        do
        {
			if(pMod->size)
			{
                if(pMod == pCurrentMod)
                {
				    PICE_sprintf(tempCmd,"%.8X - %.8X *%-32S\n",
						    (unsigned int)pMod->BaseAddress,
						    (unsigned int) ((unsigned int)pMod->BaseAddress+pMod->size),pMod->name);
                }
                else
                {
				    PICE_sprintf(tempCmd,"%.8X - %.8X  %-32S\n",
						    (unsigned int)pMod->BaseAddress,
						    (unsigned int) ((unsigned int)pMod->BaseAddress+pMod->size),
							pMod->name);
                }
			}
            Print(OUTPUT_WINDOW,tempCmd);
			if(WaitForKey()==FALSE)
				break;
        }while((pMod = pMod->next)!=pdebug_module_tail);
    }
	return TRUE;
}