//
// Copyright (c) 1996 Microsoft Corporation
//
//
// SYM.C -- Implemtation for Classes:
// CInfSymbolTable
// CInfSymbol
//
// History:
// 05/21/96 JosephJ Created
//
//
#include "common.h"
///////////////////////////////////////////////////////////////////////////
// CLASS CInfSymbol
///////////////////////////////////////////////////////////////////////////
CInfSymbol::CInfSymbol
(
const TCHAR rgchName[],
UINT cchName,
DWORD dwChecksum,
const CInfSymbol * pNext
)
: m_rgchText(rgchName),
m_cchText(cchName),
m_dwChecksum(dwChecksum),
m_pNext(pNext),
m_pPropList(NULL)
{
}
CInfSymbol::~CInfSymbol()
{
// BUGBUG -- delete all the InfSymbols allocated!
}
// Return the text associated with this symbol as a null-terminated
// string
const TCHAR * CInfSymbol::GetText(void) const
{
return (this) ? m_rgchText : TEXT("");
}
// Return the length of the text associated with this symbol
UINT CInfSymbol::GetTextLength() const
{
return (this) ? m_cchText : 0;
}
// Release (decrement ref-count) of this symbol
void CInfSymbol::Release(void) const
{
}
// Dump state
void CInfSymbol::Dump(void) const
{
printf("Symbol(0x%08lx) = [%s]\n", this, (this) ? m_rgchText : TEXT(""));
}
// --------------- SetProp ------------------
// Not really const -- it modifies the property list
BOOL
CInfSymbol::SetProp(const CInfSymbol *pSymPropName, void *pvProp)
const
// TODO
{
#if 0
CInfSymProp * pPropRec = (CInfSymProp *) m_pPropList;
DWORD dwSig = pSymPropName->Checksum();
BOOL fRet=FALSE;
// Search for property
while(pPropRec)
{
const CInfSymbol *pSym = pPropRec->pSymPropName;
if (dwChecksum == pSym->Checksum())
{
if (!lstrcmp(pSymPropName->GetText(), pSym->GetText()))
{
// currently we don't allow you to set an already set prop.
ASSERT(FALSE);
goto end;
}
}
pPropRec = pPropRec->m_pNext;
}
// Insert property
pPropRec = new CInfSymProp
(
pSymPropName,
pvProp,
(CInfSymProp *) m_pPropList
);
m_pPropList = (void *) pPropRec;
end:
return fRet;
#endif // 0
return FALSE;
}
// --------------- GetProp ------------------
// TODO
BOOL
CInfSymbol::GetProp(const CInfSymbol *pSymPropName, void **ppvProp)
const
{
return FALSE;
}
// --------------- DelProp ------------------
// Not really const -- it modifies the property list
// TODO
BOOL
CInfSymbol::DelProp(const CInfSymbol *pSymPropName)
const
{
return FALSE;
}
// --------------- GetOrCreatePropLoc --------------
// Not really const -- it could modify the property list
// TODO
BOOL
CInfSymbol::GetOrCreatePropLoc(
const CInfSymbol *pSymPropName,
void ***ppvProp,
BOOL *pfExists
)
const
{
static void *pv;
*pfExists=FALSE;
*ppvProp = &pv;
return TRUE;
}
///////////////////////////////////////////////////////////////////////////
// CLASS CInfSymbolTable
///////////////////////////////////////////////////////////////////////////
CInfSymbolTable::CInfSymbolTable(void)
{
FillMemory((void*)m_rgpSym, sizeof(m_rgpSym), 0);
m_cSymbols=0;
m_pchFree = m_rgchTextStore;
m_pchLastFree = m_pchFree +
sizeof(m_rgchTextStore)/sizeof(*m_rgchTextStore)-1;
}
CInfSymbolTable::~CInfSymbolTable()
{
mfn_EnterCrit();
// Free resources
}
// Look up and return the symbol with the specified text.
// If symbol is not prestent, return NULL if (!fInsert), else
// insert new symbol and return it.
// This symbol MUST be released by calling its Release function
// when it is no longer needed.
// NULL is returned for the empty string ("")
const CInfSymbol * CInfSymbolTable::Lookup(const TCHAR rgchName[], BOOL fInsert)
{
const TCHAR *pch = rgchName;
const CInfSymbol *pSym = NULL;
const UINT cchName = lstrlen(rgchName);
const DWORD dwChecksum = ::Checksum
(
(BYTE *) rgchName,
cchName*sizeof(TCHAR)
);
const UINT u = dwChecksum % SYMTABSIZE; // we use checksum to compute hash.
if (!cchName) { goto end; }
mfn_EnterCrit();
// Look for it
for (pSym = m_rgpSym[u]; pSym; pSym = pSym->Next())
{
// may as well use the checksum as a quick check...
if (dwChecksum==pSym->Checksum())
{
if (!lstrcmp(rgchName, pSym->GetText())) goto end;
printf
(
"WARNING: CS(%s) == CS(%s) = 0x%08lx\n",
rgchName,
pSym->GetText(),
dwChecksum
);
}
}
// Didn't find it -- insert if necessary
ASSERT(pSym==NULL);
if (fInsert)
{
if ( (m_pchFree+cchName) < m_pchLastFree)
{
CopyMemory (
(void *) m_pchFree,
(const void *) rgchName,
(cchName+1)*sizeof(*rgchName) // incl. null term.
);
pSym = new CInfSymbol(m_pchFree, cchName, dwChecksum, m_rgpSym[u]);
if (pSym)
{
printf("Inserting. %s @ 0x%08lx..\n", m_pchFree, (DWORD) pSym);
m_pchFree += (cchName+1);
ASSERT(m_pchFree<=m_pchLastFree);
m_rgpSym[u] = pSym;
}
}
}
mfn_LeaveCrit();
end:
return pSym;
}
// Dump state
void CInfSymbolTable::Dump(void) const
{
mfn_EnterCrit();
printf("[BEGIN SYMBOL TABLE DUMP]\n");
for (UINT u=0; u<SYMTABSIZE; u++)
{
const CInfSymbol *pSym = m_rgpSym[u];
if (pSym)
{
printf("---- Location 0x%08lx -----\n", u);
for (; pSym ; pSym = pSym->Next())
{
pSym->Dump();
}
}
}
printf("[End symbol table dump]\n");
mfn_LeaveCrit();
}
///////////////////////////////////////////////////////////////////////////
// CLASS CInfSymbolList
///////////////////////////////////////////////////////////////////////////
// --------------------------- Find -----------------------------
// Looks for the specified symbol, returns the list element with that symbol.
// If ppListPrev is non-NULL, sets it to the previous list element
// (if no previous element, sets it to NULL). If the symbol is not found,
// *ppListPrev is not touched.
//
const CInfSymbolList *
CInfSymbolList::Find
(
const CInfSymbolList *pList,
const CInfSymbol *pSym,
const CInfSymbolList **ppListPrev
)
{
DWORD dwChecksum = pSym->Checksum();
const CInfSymbolList *pListPrev=NULL;
while(pList)
{
const CInfSymbol *pSym1 = pList->m_pSym;
if (dwChecksum == pSym1->Checksum())
{
if (!lstrcmp(pSym->GetText(), pSym1->GetText()))
{
// Found it ...
if (ppListPrev)
{
// Note, if we find the 1st element, *ppListPrev is set
// to NULL.
*ppListPrev = pListPrev;
}
goto end;
}
}
pListPrev = pList;
pList = pList->Next();
}
end:
return pList;
}
