You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
544 lines
11 KiB
544 lines
11 KiB
/* Copyright (C) Microsoft Corporation, 1998. All rights reserved. */
|
|
|
|
#include "precomp.h"
|
|
#include "macro.h"
|
|
|
|
|
|
CMacro::
|
|
CMacro
|
|
(
|
|
BOOL *pfRetCode,
|
|
LPSTR pszMacroName,
|
|
UINT cbMaxBodySize
|
|
)
|
|
:
|
|
m_ArgList(8), // default 8 arguments
|
|
m_MacroInstList(16), // default 16 instances of this macro
|
|
m_cFormalArgs(0),
|
|
m_cbBodySize(0),
|
|
m_cbMaxBodySize(cbMaxBodySize),
|
|
m_pszExpandBuffer(NULL),
|
|
m_fArgExistsInBody(FALSE),
|
|
m_fImported(FALSE)
|
|
{
|
|
m_pszMacroName = ::My_strdup(pszMacroName);
|
|
|
|
m_pszBodyBuffer = new char[m_cbMaxBodySize];
|
|
m_pszCurr = m_pszBodyBuffer;
|
|
|
|
*pfRetCode = (NULL != m_pszMacroName) &&
|
|
(NULL != m_pszBodyBuffer);
|
|
}
|
|
|
|
|
|
CMacro::
|
|
CMacro
|
|
(
|
|
BOOL *pfRetCode,
|
|
CMacro *pMacro
|
|
)
|
|
:
|
|
m_ArgList(pMacro->m_ArgList.GetCount()), // default 8 arguments
|
|
m_MacroInstList(16), // default 16 instances of this macro
|
|
m_cFormalArgs(pMacro->m_cFormalArgs),
|
|
m_cbBodySize(pMacro->m_cbBodySize),
|
|
m_cbMaxBodySize(pMacro->m_cbMaxBodySize),
|
|
m_pszExpandBuffer(NULL),
|
|
m_fArgExistsInBody(pMacro->m_fArgExistsInBody),
|
|
m_fImported(TRUE)
|
|
{
|
|
m_pszMacroName = ::My_strdup(pMacro->m_pszMacroName);
|
|
m_pszBodyBuffer = new char[m_cbMaxBodySize];
|
|
if (NULL != m_pszMacroName && NULL != m_pszBodyBuffer)
|
|
{
|
|
// copy the body
|
|
::memcpy(m_pszBodyBuffer, pMacro->m_pszBodyBuffer, pMacro->m_cbBodySize);
|
|
|
|
// adjust the current buffer pointer
|
|
m_pszCurr = m_pszBodyBuffer + m_cbBodySize;
|
|
|
|
// null terminated the body
|
|
*m_pszCurr++ = '\0';
|
|
|
|
// set up the expand buffer
|
|
m_pszExpandBuffer = m_pszCurr;
|
|
|
|
*pfRetCode = TRUE;
|
|
}
|
|
else
|
|
{
|
|
*pfRetCode = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
CMacro::
|
|
~CMacro ( void )
|
|
{
|
|
delete m_pszBodyBuffer;
|
|
|
|
Uninstance();
|
|
}
|
|
|
|
|
|
void CMacro::
|
|
Uninstance ( void )
|
|
{
|
|
m_ArgList.DeleteList();
|
|
m_MacroInstList.DeleteList();
|
|
}
|
|
|
|
|
|
BOOL CMacro::
|
|
SetBodyPart ( LPSTR pszBodyPart )
|
|
{
|
|
UINT cch = ::strlen(pszBodyPart);
|
|
ASSERT(m_pszCurr + cch + 1 < m_pszBodyBuffer + m_cbMaxBodySize);
|
|
if (m_pszCurr + cch + 1 < m_pszBodyBuffer + m_cbMaxBodySize)
|
|
{
|
|
LPSTR psz;
|
|
m_ArgList.Reset();
|
|
for (UINT i = 0; NULL != (psz = m_ArgList.Iterate()); i++)
|
|
{
|
|
if (0 == ::strcmp(pszBodyPart, psz))
|
|
{
|
|
// this is an argument
|
|
m_fArgExistsInBody = TRUE;
|
|
*m_pszCurr++ = ARG_ESCAPE_CHAR;
|
|
*m_pszCurr++ = ARG_INDEX_BASE + i;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
// this is not an argument.
|
|
::memcpy(m_pszCurr, pszBodyPart, cch);
|
|
m_pszCurr += cch;
|
|
*m_pszCurr = '\0';
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void CMacro::
|
|
EndMacro ( void )
|
|
{
|
|
// save the count of arguments
|
|
m_cFormalArgs = m_ArgList.GetCount();
|
|
|
|
// calculate the size of the body
|
|
m_cbBodySize = m_pszCurr - m_pszBodyBuffer;
|
|
|
|
// null terminated the body
|
|
*m_pszCurr++ = '\0';
|
|
|
|
// set up the expand buffer
|
|
m_pszExpandBuffer = m_pszCurr;
|
|
|
|
// free the memory
|
|
DeleteArgList();
|
|
}
|
|
|
|
|
|
BOOL CMacro::
|
|
InstantiateMacro ( void )
|
|
{
|
|
BOOL rc = FALSE; // assume failure
|
|
LPSTR pszInstName, pszSrc, pszDst;
|
|
UINT i, cch;
|
|
CMacroInstance *pInst;
|
|
|
|
if (! m_fArgExistsInBody)
|
|
{
|
|
// No need to instantiate because the body does not contain any argument.
|
|
// We can take the body as the instance.
|
|
rc = TRUE;
|
|
goto MyExit;
|
|
}
|
|
|
|
ASSERT(m_ArgList.GetCount() == m_cFormalArgs);
|
|
if (m_ArgList.GetCount() != m_cFormalArgs)
|
|
{
|
|
goto MyExit;
|
|
}
|
|
|
|
pszInstName = CreateInstanceName();
|
|
if (NULL == pszInstName)
|
|
{
|
|
goto MyExit;
|
|
}
|
|
|
|
m_MacroInstList.Reset();
|
|
while (NULL != (pInst = m_MacroInstList.Iterate()))
|
|
{
|
|
if (0 == ::strcmp(pszInstName, pInst->GetName()))
|
|
{
|
|
// same instance has been instantiated before.
|
|
rc = TRUE;
|
|
delete pszInstName;
|
|
goto MyExit;
|
|
}
|
|
}
|
|
|
|
// Let's instantiate a new instance...
|
|
|
|
pszSrc = m_pszBodyBuffer;
|
|
pszDst = m_pszExpandBuffer;
|
|
|
|
// put in macro name first
|
|
::strcpy(pszDst, pszInstName);
|
|
pszDst += ::strlen(pszDst);
|
|
|
|
// put in macro body now.
|
|
while (*pszSrc != '\0')
|
|
{
|
|
if (*pszSrc == ARG_ESCAPE_CHAR)
|
|
{
|
|
pszSrc++;
|
|
i = *pszSrc++ - ARG_INDEX_BASE;
|
|
ASSERT(i < m_ArgList.GetCount());
|
|
LPSTR pszArgName = m_ArgList.GetNthItem(i);
|
|
cch = ::strlen(pszArgName);
|
|
::memcpy(pszDst, pszArgName, cch);
|
|
pszDst += cch;
|
|
}
|
|
else
|
|
{
|
|
*pszDst++ = *pszSrc++;
|
|
}
|
|
}
|
|
*pszDst++ = '\n';
|
|
*pszDst = '\0';
|
|
|
|
// create an instance
|
|
pInst = new CMacroInstance(&rc,
|
|
pszInstName,
|
|
pszDst - m_pszExpandBuffer,
|
|
m_pszExpandBuffer);
|
|
if (NULL != pInst && rc)
|
|
{
|
|
m_MacroInstList.Append(pInst);
|
|
}
|
|
|
|
MyExit:
|
|
|
|
// free up temporary argument names
|
|
m_ArgList.DeleteList();
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
BOOL CMacro::
|
|
OutputInstances ( COutput *pOutput )
|
|
{
|
|
BOOL rc = TRUE;
|
|
CMacroInstance *pInst;
|
|
if (m_fArgExistsInBody)
|
|
{
|
|
m_MacroInstList.Reset();
|
|
while (NULL != (pInst = m_MacroInstList.Iterate()))
|
|
{
|
|
rc = pOutput->Write(pInst->GetBuffer(), pInst->GetBufSize());
|
|
ASSERT(rc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rc = pOutput->Write(m_pszMacroName, ::strlen(m_pszMacroName));
|
|
ASSERT(rc);
|
|
rc = pOutput->Writeln(m_pszBodyBuffer, m_cbBodySize);
|
|
ASSERT(rc);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
|
|
LPSTR CMacro::
|
|
CreateInstanceName ( void )
|
|
{
|
|
UINT cch = ::strlen(m_pszMacroName) + 2;
|
|
UINT i;
|
|
LPSTR psz, pszArgName;
|
|
|
|
if (m_fArgExistsInBody)
|
|
{
|
|
ASSERT(m_ArgList.GetCount() == m_cFormalArgs);
|
|
m_ArgList.Reset();
|
|
while (NULL != (pszArgName = m_ArgList.Iterate()))
|
|
{
|
|
cch += ::strlen(pszArgName) + 1;
|
|
}
|
|
}
|
|
|
|
LPSTR pszInstanceName = new char[cch];
|
|
if (NULL != pszInstanceName)
|
|
{
|
|
psz = pszInstanceName;
|
|
::strcpy(psz, m_pszMacroName);
|
|
|
|
if (m_fArgExistsInBody)
|
|
{
|
|
psz += ::strlen(psz);
|
|
m_ArgList.Reset();
|
|
while (NULL != (pszArgName = m_ArgList.Iterate()))
|
|
{
|
|
*psz++ = '-';
|
|
::strcpy(psz, pszArgName);
|
|
psz += ::strlen(psz);
|
|
}
|
|
}
|
|
}
|
|
|
|
return pszInstanceName;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
CMacro * CMacroMgrList::
|
|
FindMacro
|
|
(
|
|
LPSTR pszModuleName,
|
|
LPSTR pszMacroName
|
|
)
|
|
{
|
|
CMacroMgr *pMacroMgr = FindMacroMgr(pszModuleName);
|
|
return (NULL != pMacroMgr) ? pMacroMgr->FindMacro(pszMacroName) : NULL;
|
|
}
|
|
|
|
|
|
CMacroMgr * CMacroMgrList::
|
|
FindMacroMgr ( LPSTR pszModuleName )
|
|
{
|
|
CMacroMgr *pMacroMgr;
|
|
Reset();
|
|
while (NULL != (pMacroMgr = Iterate()))
|
|
{
|
|
if (0 == ::strcmp(pszModuleName, pMacroMgr->GetModuleName()))
|
|
{
|
|
return pMacroMgr;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void CMacroMgrList::
|
|
Uninstance ( void )
|
|
{
|
|
CMacroMgr *pMacroMgr;
|
|
Reset();
|
|
while (NULL != (pMacroMgr = Iterate()))
|
|
{
|
|
pMacroMgr->Uninstance();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CMacroMgr::
|
|
CMacroMgr ( void )
|
|
:
|
|
m_MacroList(16), // default 16 macros
|
|
m_pszModuleName(NULL)
|
|
{
|
|
}
|
|
|
|
|
|
CMacroMgr::
|
|
~CMacroMgr ( void )
|
|
{
|
|
m_MacroList.DeleteList();
|
|
delete m_pszModuleName;
|
|
}
|
|
|
|
|
|
BOOL CMacroMgr::
|
|
AddModuleName ( LPSTR pszModuleName )
|
|
{
|
|
// can only be set once
|
|
ASSERT(NULL == m_pszModuleName);
|
|
|
|
m_pszModuleName = ::My_strdup(pszModuleName);
|
|
ASSERT(NULL != m_pszModuleName);
|
|
|
|
return (NULL != m_pszModuleName);
|
|
}
|
|
|
|
|
|
CMacro *CMacroMgr::
|
|
FindMacro ( LPSTR pszMacroName )
|
|
{
|
|
CMacro *pMacro;
|
|
m_MacroList.Reset();
|
|
while (NULL != (pMacro = m_MacroList.Iterate()))
|
|
{
|
|
if (0 == ::strcmp(pszMacroName, pMacro->GetName()))
|
|
{
|
|
return pMacro;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
BOOL CMacroMgr::
|
|
OutputImportedMacros ( COutput *pOutput )
|
|
{
|
|
BOOL rc = TRUE;
|
|
CMacro *pMacro;
|
|
|
|
rc = pOutput->Write("\n\n", 2);
|
|
|
|
m_MacroList.Reset();
|
|
while (NULL != (pMacro = m_MacroList.Iterate()))
|
|
{
|
|
if (pMacro->IsImported())
|
|
{
|
|
rc = pMacro->OutputInstances(pOutput);
|
|
if (! rc)
|
|
{
|
|
ASSERT(0);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
|
|
void CMacroMgr::
|
|
Uninstance ( void )
|
|
{
|
|
CMacro *pMacro;
|
|
m_MacroList.Reset();
|
|
while (NULL != (pMacro = m_MacroList.Iterate()))
|
|
{
|
|
pMacro->Uninstance();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CMacroInstance::
|
|
CMacroInstance
|
|
(
|
|
BOOL *pfRetCode,
|
|
LPSTR pszInstanceName,
|
|
UINT cbBufSize,
|
|
LPSTR pszInstBuf
|
|
)
|
|
:
|
|
m_pszInstanceName(pszInstanceName),
|
|
m_cbBufSize(cbBufSize)
|
|
{
|
|
m_pszInstanceBuffer = new char[m_cbBufSize];
|
|
if (NULL != m_pszInstanceBuffer)
|
|
{
|
|
::memcpy(m_pszInstanceBuffer, pszInstBuf, m_cbBufSize);
|
|
}
|
|
|
|
*pfRetCode = (NULL != m_pszInstanceName) && (NULL != m_pszInstanceBuffer);
|
|
}
|
|
|
|
|
|
CMacroInstance::
|
|
~CMacroInstance ( void )
|
|
{
|
|
delete m_pszInstanceName;
|
|
delete m_pszInstanceBuffer;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void CMacroInstList::
|
|
DeleteList ( void )
|
|
{
|
|
CMacroInstance *pInst;
|
|
while (NULL != (pInst = Get()))
|
|
{
|
|
delete pInst;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMacroList::
|
|
DeleteList ( void )
|
|
{
|
|
CMacro *pMacro;
|
|
while (NULL != (pMacro = Get()))
|
|
{
|
|
delete pMacro;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CMacroMgrList::
|
|
DeleteList ( void )
|
|
{
|
|
CMacroMgr *pMacroMgr;
|
|
while (NULL != (pMacroMgr = Get()))
|
|
{
|
|
delete pMacroMgr;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL CNameList::
|
|
AddName ( LPSTR pszName )
|
|
{
|
|
pszName = ::My_strdup(pszName);
|
|
if (NULL != pszName)
|
|
{
|
|
Append(pszName);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
LPSTR CNameList::
|
|
GetNthItem ( UINT nth )
|
|
{
|
|
LPSTR psz;
|
|
if (nth < GetCount())
|
|
{
|
|
Reset();
|
|
do
|
|
{
|
|
psz = Iterate();
|
|
}
|
|
while (nth--);
|
|
}
|
|
else
|
|
{
|
|
psz = NULL;
|
|
}
|
|
return psz;
|
|
}
|
|
|
|
|
|
void CNameList::
|
|
DeleteList ( void )
|
|
{
|
|
LPSTR psz;
|
|
while (NULL != (psz = Get()))
|
|
{
|
|
delete psz;
|
|
}
|
|
}
|
|
|