621 lines
17 KiB
C++
621 lines
17 KiB
C++
// --------------------------------------------------------------------------------
|
|
// Strparse.cpp
|
|
// Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
|
|
// --------------------------------------------------------------------------------
|
|
#include "pch.hxx"
|
|
#include "strparse.h"
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// FGROWNEEDED - Determines if we need to call _HrGrowDestination
|
|
// --------------------------------------------------------------------------------
|
|
#define FGROWNEEDED(_cbWrite) (m_cchDest + _cbWrite + 1 > m_cbDestMax)
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::CStringParser
|
|
// --------------------------------------------------------------------------------
|
|
CStringParser::CStringParser(void)
|
|
{
|
|
m_cRef = 1;
|
|
m_codepage = CP_ACP;
|
|
m_pszSource = NULL;
|
|
m_cchSource = 0;
|
|
m_iSource = 0;
|
|
m_pszDest = NULL;
|
|
m_cchDest = 0;
|
|
m_cbDestMax = 0;
|
|
m_dwFlags = 0;
|
|
m_pszTokens = NULL;
|
|
m_cCommentNest = 0;
|
|
ZeroMemory(m_rgbTokTable, sizeof(m_rgbTokTable));
|
|
ZeroMemory(&m_rLiteral, sizeof(m_rLiteral));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::~CStringParser
|
|
// --------------------------------------------------------------------------------
|
|
CStringParser::~CStringParser(void)
|
|
{
|
|
if (m_pszDest && m_pszDest != m_szScratch)
|
|
g_pMalloc->Free(m_pszDest);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::AddRef
|
|
// --------------------------------------------------------------------------------
|
|
ULONG CStringParser::AddRef(void)
|
|
{
|
|
return ++m_cRef;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::AddRef
|
|
// --------------------------------------------------------------------------------
|
|
ULONG CStringParser::Release(void)
|
|
{
|
|
if (0 != --m_cRef)
|
|
return m_cRef;
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::Init
|
|
// --------------------------------------------------------------------------------
|
|
void CStringParser::Init(LPCSTR pszParseMe, ULONG cchParseMe, DWORD dwFlags)
|
|
{
|
|
// Invalid Args
|
|
Assert(NULL == m_pszSource && NULL == m_pszDest && pszParseMe && '\0' == pszParseMe[cchParseMe]);
|
|
|
|
// Save Parse Flags
|
|
m_dwFlags = dwFlags;
|
|
|
|
// Safe the String
|
|
m_pszSource = pszParseMe;
|
|
m_cchSource = cchParseMe;
|
|
|
|
// Setup Dest
|
|
m_pszDest = m_szScratch;
|
|
m_cbDestMax = sizeof(m_szScratch);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::SetTokens
|
|
// --------------------------------------------------------------------------------
|
|
void CStringParser::SetTokens(LPCSTR pszTokens)
|
|
{
|
|
// Locals
|
|
LPSTR psz;
|
|
|
|
// Enable the tokens in the table
|
|
if (m_pszTokens)
|
|
for (psz=(LPSTR)m_pszTokens; *psz != '\0'; psz++)
|
|
m_rgbTokTable[(UCHAR)(*psz)] = 0x00;
|
|
|
|
// New Tokens
|
|
if (pszTokens)
|
|
for (psz=(LPSTR)pszTokens; *psz != '\0'; psz++)
|
|
m_rgbTokTable[(UCHAR)(*psz)] = 0xff;
|
|
|
|
// Save new tokens
|
|
m_pszTokens = pszTokens;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::_HrGrowDestination
|
|
// --------------------------------------------------------------------------------
|
|
HRESULT CStringParser::_HrGrowDestination(ULONG cbWrite)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
ULONG cbAlloc;
|
|
|
|
// We should need to grow, should have called FGROWNEEDED
|
|
Assert(FGROWNEEDED(cbWrite));
|
|
|
|
// Is this the first realloc
|
|
if (m_pszDest == m_szScratch)
|
|
{
|
|
// Validate Current Size
|
|
Assert(m_cbDestMax == sizeof(m_szScratch));
|
|
|
|
// Compute New Size
|
|
cbAlloc = max(m_cchSource + 1, m_cchDest + 256 + cbWrite);
|
|
|
|
// Init pszValue
|
|
CHECKALLOC(m_pszDest = (LPSTR)g_pMalloc->Alloc(cbAlloc));
|
|
|
|
// Copy Current Value
|
|
CopyMemory(m_pszDest, m_szScratch, m_cchDest);
|
|
|
|
// Set Max Val
|
|
m_cbDestMax = cbAlloc;
|
|
}
|
|
|
|
// Otherwise, need to realloc
|
|
else
|
|
{
|
|
// Locals
|
|
LPBYTE pbTemp;
|
|
|
|
// Should already be bigger than m_cchSource + 1
|
|
Assert(m_cbDestMax >= m_cchSource + 1);
|
|
|
|
// Compute New Size
|
|
cbAlloc = m_cbDestMax + 256 + cbWrite;
|
|
|
|
// Realloc
|
|
CHECKALLOC(pbTemp = (LPBYTE)g_pMalloc->Realloc((LPBYTE)m_pszDest, cbAlloc));
|
|
|
|
// Save new pointer
|
|
m_pszDest = (LPSTR)pbTemp;
|
|
|
|
// Save new Size
|
|
m_cbDestMax = cbAlloc;
|
|
}
|
|
|
|
exit:
|
|
// Done
|
|
return hr;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::FIsParseSpace
|
|
// --------------------------------------------------------------------------------
|
|
BOOL CStringParser::FIsParseSpace(CHAR ch, BOOL *pfCommentChar)
|
|
{
|
|
// Locals
|
|
WORD wType;
|
|
|
|
// Should not be DBCS
|
|
Assert(ISFLAGSET(m_dwFlags, PSF_DBCS) ? !IsDBCSLeadByteEx(m_codepage, ch) : TRUE);
|
|
|
|
// Comment Char
|
|
*pfCommentChar = FALSE;
|
|
|
|
// NoComments
|
|
if (ISFLAGSET(m_dwFlags, PSF_NOCOMMENTS))
|
|
{
|
|
// Comment Start ?
|
|
if ('(' == ch)
|
|
{
|
|
// Increment Nested Count
|
|
m_cCommentNest++;
|
|
|
|
// Comment Char
|
|
*pfCommentChar = TRUE;
|
|
|
|
// Treat it as a space
|
|
return TRUE;
|
|
}
|
|
|
|
// Comment End ?
|
|
else if (')' == ch && m_cCommentNest)
|
|
{
|
|
// Decrement Nested Count
|
|
m_cCommentNest--;
|
|
|
|
// Comment Char
|
|
*pfCommentChar = TRUE;
|
|
|
|
// Treat it as a space
|
|
return TRUE;
|
|
}
|
|
|
|
// Inside a Comment ?
|
|
else if (m_cCommentNest)
|
|
{
|
|
// Comment Char
|
|
*pfCommentChar = TRUE;
|
|
|
|
// Treat it as a space
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
// Get StringType
|
|
if (' ' == ch || '\t' == ch || '\r' == ch || '\n' == ch)
|
|
return(TRUE);
|
|
|
|
// Not a space
|
|
return(FALSE);
|
|
|
|
#if 0
|
|
if (0 == GetStringTypeExA(LOCALE_USER_DEFAULT, CT_CTYPE1, &ch, 1, &wType))
|
|
wType = 0;
|
|
|
|
// Return IsSpace
|
|
return(ISFLAGSET(wType, C1_SPACE));
|
|
#endif
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::ChSkip - Returns TRUE if done parsing
|
|
// --------------------------------------------------------------------------------
|
|
CHAR CStringParser::ChSkipWhite(void)
|
|
{
|
|
// Locals
|
|
CHAR ch=0;
|
|
BOOL fCommentChar;
|
|
|
|
// Loop
|
|
while (1)
|
|
{
|
|
// Get Current Character
|
|
ch = *(m_pszSource + m_iSource);
|
|
|
|
// Are we done
|
|
if ('\0' == ch)
|
|
break;
|
|
|
|
// Better not be done
|
|
Assert(m_iSource < m_cchSource);
|
|
|
|
// Look for DBCS characters
|
|
if (ISFLAGSET(m_dwFlags, PSF_DBCS) && IsDBCSLeadByteEx(m_codepage, ch))
|
|
break;
|
|
|
|
// Not a space
|
|
if (!FIsParseSpace(ch, &fCommentChar))
|
|
break;
|
|
|
|
// Goto Next Char
|
|
m_iSource++;
|
|
}
|
|
|
|
// Done
|
|
return ch;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::ChSkip - Returns TRUE if done parsing
|
|
// --------------------------------------------------------------------------------
|
|
CHAR CStringParser::ChSkip(void)
|
|
{
|
|
// Locals
|
|
CHAR ch = 0;
|
|
|
|
// Loop
|
|
while (1)
|
|
{
|
|
// Get Current Character
|
|
ch = *(m_pszSource + m_iSource);
|
|
|
|
// Are we done
|
|
if ('\0' == ch)
|
|
break;
|
|
|
|
// Better not be done
|
|
Assert(m_iSource < m_cchSource);
|
|
|
|
// Look for DBCS characters
|
|
if (ISFLAGSET(m_dwFlags, PSF_DBCS) && IsDBCSLeadByteEx(m_codepage, ch))
|
|
break;
|
|
|
|
// Compare for a token
|
|
if (0x00 == m_rgbTokTable[(UCHAR)ch])
|
|
break;
|
|
|
|
// Goto Next Char
|
|
m_iSource++;
|
|
}
|
|
|
|
// Done
|
|
return ch;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::ChPeekNext
|
|
// --------------------------------------------------------------------------------
|
|
CHAR CStringParser::ChPeekNext(ULONG cchFromCurrent)
|
|
{
|
|
// Locals
|
|
CHAR ch=0;
|
|
BOOL fCommentChar;
|
|
|
|
// Past the end of the source
|
|
if (m_iSource + cchFromCurrent >= m_cchSource)
|
|
return '\0';
|
|
|
|
// Return the character
|
|
return *(m_pszSource + m_iSource + cchFromCurrent);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::_HrDoubleByteIncrement
|
|
// --------------------------------------------------------------------------------
|
|
HRESULT CStringParser::_HrDoubleByteIncrement(BOOL fEscape)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
|
|
// Can I copy two more bytes to pszValue
|
|
if (FGROWNEEDED(2))
|
|
{
|
|
// Otherwise, grow the buffer
|
|
CHECKHR(hr = _HrGrowDestination(2));
|
|
}
|
|
|
|
// If Not an Escape Character or the last character is an escape character, then step over it
|
|
if (FALSE == fEscape || m_iSource + 1 > m_cchSource)
|
|
m_pszDest[m_cchDest++] = m_pszSource[m_iSource];
|
|
|
|
// Next Character
|
|
m_iSource++;
|
|
|
|
// Copy Next Character
|
|
if (m_iSource < m_cchSource)
|
|
m_pszDest[m_cchDest++] = m_pszSource[m_iSource++];
|
|
|
|
exit:
|
|
// Done
|
|
return hr;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::ChParse
|
|
// --------------------------------------------------------------------------------
|
|
CHAR CStringParser::ChParse(LPCSTR pszTokens, DWORD dwFlags)
|
|
{
|
|
// Save Flags
|
|
DWORD dwCurrFlags=m_dwFlags;
|
|
|
|
// Reset Flags
|
|
m_dwFlags = dwFlags;
|
|
|
|
// Set Parsing Tokens
|
|
SetTokens(pszTokens);
|
|
|
|
// Parse
|
|
CHAR chToken = ChParse();
|
|
|
|
// Set Flags
|
|
m_dwFlags = dwCurrFlags;
|
|
|
|
// Return the Token
|
|
return chToken;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::ChParse
|
|
// --------------------------------------------------------------------------------
|
|
CHAR CStringParser::ChParse(CHAR chStart, CHAR chEnd, DWORD dwFlags)
|
|
{
|
|
// We really should have finished the last literal
|
|
Assert(FALSE == m_rLiteral.fInside);
|
|
|
|
// Save Flags
|
|
DWORD dwCurrFlags = m_dwFlags;
|
|
|
|
// Reset Flags
|
|
m_dwFlags = dwFlags;
|
|
|
|
// Set Parsing Tokens
|
|
SetTokens(NULL);
|
|
|
|
// Save Literal Info
|
|
m_rLiteral.fInside = TRUE;
|
|
m_rLiteral.chStart = chStart;
|
|
m_rLiteral.chEnd = chEnd;
|
|
m_rLiteral.cNested = 0;
|
|
|
|
// Quoted String
|
|
Assert('\"' == chStart ? '\"' == chEnd : TRUE);
|
|
|
|
// Parse
|
|
CHAR chToken = ChParse();
|
|
|
|
// Not in a literal
|
|
m_rLiteral.fInside = FALSE;
|
|
|
|
// Reset Flags
|
|
m_dwFlags = dwCurrFlags;
|
|
|
|
// Return the Token
|
|
return chToken;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::HrAppendValue
|
|
// --------------------------------------------------------------------------------
|
|
HRESULT CStringParser::HrAppendValue(CHAR ch)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
|
|
// Just copy this character
|
|
if (FGROWNEEDED(1))
|
|
{
|
|
// Otherwise, grow the buffer
|
|
CHECKHR(hr = _HrGrowDestination(1));
|
|
}
|
|
|
|
// Insert the Character
|
|
m_pszDest[m_cchDest++] = ch;
|
|
|
|
// There is always room for a Null, look at FGROWNEEDED and _HrGrowDestination
|
|
m_pszDest[m_cchDest] = '\0';
|
|
|
|
exit:
|
|
// Done
|
|
return hr;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// CStringParser::ChParse
|
|
// --------------------------------------------------------------------------------
|
|
CHAR CStringParser::ChParse(void)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
CHAR ch;
|
|
ULONG iStart=m_iSource;
|
|
LONG iLastSpace=-1;
|
|
CHAR chToken;
|
|
BOOL fCommentChar;
|
|
BOOL fIsSpace;
|
|
|
|
// Invalid Arg
|
|
Assert(m_iSource <= m_cchSource && m_pszDest);
|
|
|
|
// Init chToken
|
|
chToken = '\0';
|
|
|
|
// No Reset
|
|
if (!ISFLAGSET(m_dwFlags, PSF_NORESET))
|
|
{
|
|
m_pszDest[0] = '\0';
|
|
m_cchDest = 0;
|
|
}
|
|
|
|
// Skip Forward Whitespace
|
|
if (ISFLAGSET(m_dwFlags, PSF_NOFRONTWS) && FALSE == m_rLiteral.fInside && '\0' == ChSkipWhite())
|
|
goto TokenFound;
|
|
|
|
// Save Starting Position
|
|
while(1)
|
|
{
|
|
// Get the Next Character
|
|
ch = *(m_pszSource + m_iSource);
|
|
|
|
// Done
|
|
if ('\0' == ch)
|
|
{
|
|
chToken = '\0';
|
|
goto TokenFound;
|
|
}
|
|
|
|
// Better not be done
|
|
Assert(m_iSource < m_cchSource);
|
|
|
|
// If this is a DBCS lead byte
|
|
if ((ISFLAGSET(m_dwFlags, PSF_DBCS) && IsDBCSLeadByteEx(m_codepage, ch)))
|
|
{
|
|
// _HrDoubleByteIncrement
|
|
CHECKHR(hr = _HrDoubleByteIncrement(FALSE));
|
|
iLastSpace = -1; // reset space counter
|
|
|
|
// Goto Next Character
|
|
continue;
|
|
}
|
|
|
|
// Check for escaped characters
|
|
if (ISFLAGSET(m_dwFlags, PSF_ESCAPED) && '\\' == ch)
|
|
{
|
|
// _HrDoubleByteIncrement
|
|
CHECKHR(hr = _HrDoubleByteIncrement(TRUE));
|
|
iLastSpace = -1; // reset space counter
|
|
|
|
// Goto Next Character
|
|
continue;
|
|
}
|
|
|
|
// If not inside of a comment
|
|
if (0 == m_cCommentNest)
|
|
{
|
|
if (m_rLiteral.fInside)
|
|
{
|
|
// End of quoted string
|
|
if (ch == m_rLiteral.chEnd)
|
|
{
|
|
// No nested ?
|
|
if (0 == m_rLiteral.cNested)
|
|
{
|
|
// We found a token
|
|
chToken = ch;
|
|
|
|
// Walk over this item in the string
|
|
m_iSource++;
|
|
|
|
// Ya-hoo, we found a token
|
|
hr = S_OK;
|
|
|
|
// Done
|
|
goto TokenFound;
|
|
}
|
|
|
|
// Otherwise, decrement nest
|
|
else
|
|
m_rLiteral.cNested--;
|
|
}
|
|
|
|
// Otherwise, check for nesting
|
|
else if (m_rLiteral.chStart != m_rLiteral.chEnd && ch == m_rLiteral.chStart)
|
|
m_rLiteral.cNested++;
|
|
}
|
|
|
|
// Compare for a token - m_cCommentNest is only set if PSF_NOCOMMENTS is set
|
|
else if (0xff == m_rgbTokTable[(UCHAR)ch])
|
|
{
|
|
// We found a token
|
|
chToken = ch;
|
|
|
|
// Walk over this item in the string
|
|
m_iSource++;
|
|
|
|
// Ya-hoo, we found a token
|
|
hr = S_OK;
|
|
|
|
// Done
|
|
goto TokenFound;
|
|
}
|
|
}
|
|
|
|
// Always Call
|
|
fIsSpace = FIsParseSpace(ch, &fCommentChar);
|
|
|
|
// Detect Spaces...
|
|
if (ISFLAGSET(m_dwFlags, PSF_NOTRAILWS))
|
|
{
|
|
// If not a space, then kill iLastSpace
|
|
if (!fIsSpace)
|
|
iLastSpace = -1;
|
|
|
|
// Otherwise, if not a consecutive space
|
|
else if (-1 == iLastSpace)
|
|
iLastSpace = m_cchDest;
|
|
}
|
|
|
|
// Copy the next character
|
|
if (!fCommentChar)
|
|
{
|
|
// Make sure we have space
|
|
if (FGROWNEEDED(1))
|
|
{
|
|
// Otherwise, grow the buffer
|
|
CHECKHR(hr = _HrGrowDestination(1));
|
|
}
|
|
|
|
// Copy the character
|
|
m_pszDest[m_cchDest++] = ch;
|
|
}
|
|
|
|
// Goto next char
|
|
m_iSource++;
|
|
}
|
|
|
|
TokenFound:
|
|
// Determine correct end of string
|
|
if (S_OK == hr && ISFLAGSET(m_dwFlags, PSF_NOTRAILWS) && FALSE == m_rLiteral.fInside)
|
|
m_cchDest = (-1 == iLastSpace) ? m_cchDest : iLastSpace;
|
|
|
|
// Otherwise, just insert a null
|
|
Assert(m_cchDest < m_cbDestMax);
|
|
|
|
// There is always room for a Null, look at FGROWNEEDED and _HrGrowDestination
|
|
m_pszDest[m_cchDest] = '\0';
|
|
|
|
exit:
|
|
// Failure Resets the parse to initial state
|
|
if (FAILED(hr))
|
|
{
|
|
m_iSource = iStart;
|
|
chToken = '\0';
|
|
}
|
|
|
|
// Validate Paren Nesting
|
|
// AssertSz(m_cCommentNest == 0, "A string was parsed that has an un-balanced paren nesting.");
|
|
|
|
// Done
|
|
return chToken;
|
|
}
|