assembler.cpp

Ollydbg环境下的一款插件源代码

        );
        goto Exit0;
    }

    unTokenNameSize = strTokenName.GetLength() + 1;

    nRetCode = IsMnemonic(unTokenNameSize, strTokenName);
    if (nRetCode)
    {
        Error(
            ERR_IDISAKEYWORDCANTBEALABEL,
            strTokenName,
            fii->FileName,
            fii->LineNum
        );
        FatalError();
        goto Exit0;
    }

    nRetCode = IsRegister(unTokenNameSize, strTokenName);
    if (nRetCode)
    {
        Error(
            ERR_IDISAKEYWORDCANTBEALABEL,
            strTokenName,
            fii->FileName,
            fii->LineNum
        );
        FatalError();
        goto Exit0;
    }

    nRetCode = FindLabelName(unTokenNameSize, strTokenName, &li, &nLblIdx);
    if (0 == nRetCode)
    {
        Error(ERR_NOID, strTokenName, fii->FileName, fii->LineNum);
        goto Exit0;
    }

    SetLabelRef(unTokenNameSize, strTokenName);

    Add1LCode(li.Addr);

    nRetCode = GetEnd(fii, MneType);
    OM_PROCESS_ERROR(nRetCode);

    nRetResult = 1;
Exit0:
    return nRetResult;
}

int CAssembler::IC(
    /* [in][out] */     FILEINFO *fii,
    /* [in] */          const MNEMONICTYPE MneType
)
{
    ASSERT(fii);

    int nRetResult = 0;
    int nRetCode;

    CString strTokenName;
    TOKENTYPE tt;
    long lValue;

    AddOpcode(MneType);

    tt = NextToken(fii, &strTokenName);
    switch (tt)
    {
    case TOK_DIGIT_DEC:
        lValue = strtoul(strTokenName, NULL, 10);
        break;
    case TOK_DIGIT_HEX:
        lValue = strtoul(strTokenName, NULL, 16);
        break;
    default:
        Error(
            ERR_ERRORONID,
            m_VM->GetMnemonicName(MneType),
            fii->FileName,
            fii->LineNum
        );
        goto Exit0;
    }

    Add1LCode(lValue);

    nRetCode = GetEnd(fii, MneType);
    OM_PROCESS_ERROR(nRetCode);

    nRetResult = 1;
Exit0:
    return nRetResult;
}

inline int CAssembler::C(
    /* [in] */          const long lConstant
)
{
    int nRetResult = 0;
    int nRetCode;

    Add1LCode(lConstant);

    nRetResult = 1;
Exit0:
    return nRetResult;
}

inline int CAssembler::R(
    /* [in] */          const FILEINFO *fii,
    /* [size_is][in] */ const unsigned int unRegNameSize,
    /* [in] */          const char *szRegName
)
{
    ASSERT(fii);
    ASSERT(szRegName);

    int nRetResult = 0;
    int nRetCode;

    int nRegIndex;

    OM_PROCESS_ERROR((strlen(szRegName) + 1) == unRegNameSize);

    nRetCode = m_VM->GetRegisterIndex(
        unRegNameSize,
        szRegName,
        &nRegIndex
    );
    if (0 == nRetCode)
    {
        Error(
            ERR_ERRORONID,
            m_VM->GetMnemonicName(MC_PUSH),
            fii->FileName,
            fii->LineNum
        );
        goto Exit0;
    }

    Add1LCode(nRegIndex);

    nRetResult = 1;
Exit0:
    return nRetResult;
}

inline int CAssembler::S(
    /* [size_is][in] */ const unsigned int unStringSize,
    /* [in] */          const char *szString
)
{
    ASSERT(szString);

    int nRetResult = 0;
    int nRetCode;

    OM_PROCESS_ERROR((strlen(szString) + 1) == unStringSize);

    nRetCode = CheckDataCapacity(unStringSize);
    OM_PROCESS_ERROR(nRetCode);

    strncpy(m_Data + m_unDataLen, szString, unStringSize);

    m_unDataLen += unStringSize;

    nRetResult = 1;
Exit0:
    return nRetResult;
}

inline int CAssembler::IR(
    /* [in][out] */     FILEINFO *fii,
    /* [in] */          const MNEMONICTYPE MneType
)
{
    ASSERT(fii);

    int nRetResult = 0;
    int nRetCode;

    CString strRegName;

    AddOpcode(MneType);

    nRetCode = Match(fii, TOK_REGISTER, &strRegName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = R(fii, strRegName.GetLength() + 1, strRegName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = GetEnd(fii, MneType);
    OM_PROCESS_ERROR(nRetCode);

    nRetResult = 1;
Exit0:
    return nRetResult;
}

int CAssembler::GenPush(
    /* [in][out] */     FILEINFO *fii,
    /* [in] */          const int nNeedGetEnd
)
{
    ASSERT(fii);

    int nRetResult = 0;
    int nRetCode;

    TOKENTYPE tt;
    CString strTokenName;
    long lConstant;

    AddOpcode(MC_PUSH);

    tt = NextToken(fii, &strTokenName);
    switch (tt)
    {
    case TOK_DIGIT_DEC:
        AddModRM(MR_MEM);
        lConstant = strtoul(strTokenName, NULL, 10);
        nRetCode = C(lConstant);
        OM_PROCESS_ERROR(nRetCode);
        break;

    case TOK_DIGIT_HEX:
        AddModRM(MR_MEM);
        lConstant = strtoul(strTokenName, NULL, 16);
        nRetCode = C(lConstant);
        OM_PROCESS_ERROR(nRetCode);
        break;

    case TOK_REGISTER:
        AddModRM(MR_REG);
        nRetCode = R(fii, strTokenName.GetLength() + 1, strTokenName);
        OM_PROCESS_ERROR(nRetCode);
        break;

    case TOK_DQUOTE:
        AddModRM(MR_MEM);
        // data offset:
        Add1LCode(m_unDataLen);
        nRetCode = S(strTokenName.GetLength() + 1, strTokenName);
        OM_PROCESS_ERROR(nRetCode);
        break;

    case TOK_INDEXOF:
        tt = NextToken(fii, &strTokenName);
        if (TOK_REGISTER != tt)
        {
            Error(
                ERR_ERRORONID,
                m_VM->GetMnemonicName(MC_PUSH),
                fii->FileName,
                fii->LineNum
            );
            goto Exit0;
        }
        int nRegIndex;
        nRetCode = m_VM->GetRegisterIndex(
            strTokenName.GetLength() + 1,
            strTokenName,
            &nRegIndex
        );
        strTokenName.Format("%d", nRegIndex);
        AddModRM(MR_MEM);
        lConstant = strtoul(strTokenName, NULL, 10);
        nRetCode = C(lConstant);
        OM_PROCESS_ERROR(nRetCode);
        break;

    default:
        Error(
            ERR_ERRORONID,
            m_VM->GetMnemonicName(MC_PUSH),
            fii->FileName,
            fii->LineNum
        );
        break;
    }

    if (nNeedGetEnd)
    {
        nRetCode = GetEnd(fii, MC_PUSH);
        OM_PROCESS_ERROR(nRetCode);
    }

    nRetResult = 1;
Exit0:
    return nRetResult;
}

inline int CAssembler::IRR(
    /* [in][out] */     FILEINFO *fii,
    /* [in] */          const MNEMONICTYPE MneType
)
{
    ASSERT(fii);

    int nRetResult = 0;
    int nRetCode;

    CString strTokenName;

    AddOpcode(MneType);
    AddModRM(MR_REG);

    nRetCode = Match(fii, TOK_REGISTER, &strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = R(fii, strTokenName.GetLength() + 1, strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = Match(fii, TOK_COMMA);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = Match(fii, TOK_REGISTER, &strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = R(fii, strTokenName.GetLength() + 1, strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = GetEnd(fii, MneType);
    OM_PROCESS_ERROR(nRetCode);

    nRetResult = 1;
Exit0:
    return nRetResult;
}

int CAssembler::IRC(
    /* [in][out] */     FILEINFO *fii,
    /* [in] */          const MNEMONICTYPE MneType
)
{
    ASSERT(fii);

    int nRetResult = 0;
    int nRetCode;

    CString strTokenName;
    long lConstant;
    TOKENTYPE tt;

    AddOpcode(MneType);
    AddModRM(MR_MEM);

    nRetCode = Match(fii, TOK_REGISTER, &strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = R(fii, strTokenName.GetLength() + 1, strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = Match(fii, TOK_COMMA);
    OM_PROCESS_ERROR(nRetCode);

    tt = NextToken(fii, &strTokenName);
    switch (tt)
    {
    case TOK_DIGIT_DEC:
        lConstant = strtoul(strTokenName, NULL, 10);
        break;
    case TOK_DIGIT_HEX:
        lConstant = strtoul(strTokenName, NULL, 16);
        break;
    default:
        Error(
            ERR_ERRORONID,
            m_VM->GetMnemonicName(MneType),
            fii->FileName,
            fii->LineNum
        );
        break;
    }
    nRetCode = C(lConstant);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = GetEnd(fii, MneType);
    OM_PROCESS_ERROR(nRetCode);

    nRetResult = 1;
Exit0:
    return nRetResult;
}

int CAssembler::IRS(
    /* [in][out] */     FILEINFO *fii,
    /* [in] */          const MNEMONICTYPE MneType
)
{
    ASSERT(fii);

    int nRetResult = 0;
    int nRetCode;

    CString strTokenName;

    AddOpcode(MneType);

    nRetCode = Match(fii, TOK_REGISTER, &strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = R(fii, strTokenName.GetLength() + 1, strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = Match(fii, TOK_COMMA);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = Match(fii, TOK_DQUOTE, &strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    // data offset:
    Add1LCode(m_unDataLen);

    nRetCode = S(strTokenName.GetLength() + 1, strTokenName);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = GetEnd(fii, MneType);
    OM_PROCESS_ERROR(nRetCode);

    nRetResult = 1;
Exit0:
    return nRetResult;
}

int CAssembler::GenArithmetic(
    /* [in][out] */     FILEINFO *fii,
    /* [in] */          const MNEMONICTYPE MneType
)
{
    ASSERT(fii);

    int nRetResult = 0;
    int nRetCode;

    TOKENTYPE tt;
    CString strTokenName;
    long lOrigOffset = ftell(fii->fp);

    nRetCode = Match(fii, TOK_REGISTER);
    OM_PROCESS_ERROR(nRetCode);

    nRetCode = Match(fii, TOK_COMMA);
    OM_PROCESS_ERROR(nRetCode);

    tt = NextToken(fii, &strTokenName);
    fseek(fii->fp, lOrigOffset, SEEK_SET);
    switch (tt)
    {
    case TOK_DIGIT_DEC:
    case TOK_DIGIT_HEX:
        nRetCode = IRC(fii, MneType);
        OM_PROCESS_ERROR(nRetCode);
        break;
    case TOK_REGISTER:
        nRetCode = IRR(fii, MneType);
        OM_PROCESS_ERROR(nRetCode);
        break;
    default:
        goto Exit0;
    }

    nRetResult = 1;
Exit0:
    if (0 == nRetResult)
    {
        Error(
            ERR_ERRORONID,
            m_VM->GetMnemonicName(MneType),
            fii->FileName,
            fii->LineNum
        );
    }
    return nRetResult;
}