Microsoft/WindowsXP-SP1
Microsoft
/
WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
WindowsXP-SP1/enduser/troubleshoot/tshoot/apgtshtiread.cpp

1457 lines
42 KiB
C++
Raw Permalink Blame History

//
// MODULE: APGTSHTIREAD.CPP
//
// PURPOSE: HTI template file reading classes
//
// COMPANY: Saltmine Creative, Inc. (206)-284-7511 support@saltmine.com
//
// AUTHOR: Oleg Kalosha
//
// ORIGINAL DATE: 8-27-98
//
// NOTES:
// 1. HTI is loosely modeled on a Microsoft format called HTX. It's a template for an
// HTML file. Most of it is HTML, but certain pseudo-comments of the form
// <!GTS whatever> are intended to be interpreted as conditionals, places to
// insert text, etc.
//
// Variables are limited to the values
// $ProblemAsk
// $Recommendations
// $States
// $Questions
// $Success (introduced 9/24/98)
// $StartForm
// See class CHTMLFragmentsTS for more details.
// Commands are if/else/endif, forany/endfor, display
// There is also a notion of a "resource", basically an include file.
//
// EXAMPLE 1
// <!GTS forany $States >
// <!GTS display $States >
// <!GTS endfor>
//
// EXAMPLE 2
// <!GTS if $ProblemAsk >
// lots of HTML or nested calls to more GTS stuff could go here
// <!GTS else >
// lots of other HTML or nested calls to other GTS stuff could go here
// <!GTS endif >
//
// each <!GTS...> command must fit on a single line.
//
// Version Date By Comments
//--------------------------------------------------------------------
// V3.0 08-04-98 OK
//
#pragma warning(disable:4786)
#include "stdafx.h"
#include "apgtshtiread.h"
#include "event.h"
#include "CharConv.h"
#include "apgtsMFC.h"
#ifdef LOCAL_TROUBLESHOOTER
#include "htmlfraglocal.h"
#endif
namespace
{
CString k_strHTMLtag= _T("/HTML");
}
///////////////////////////////////////////////////////////////////////////////////////////
// CAPGTSHTIReader
///////////////////////////////////////////////////////////////////////////////////////////
CAPGTSHTIReader::CAPGTSHTIReader(CPhysicalFileReader * pPhysicalFileReader, LPCTSTR szDefaultContents /* NULL */)
: CTemplateReader(pPhysicalFileReader, szDefaultContents),
m_pFragments(NULL)
{
}
CAPGTSHTIReader::~CAPGTSHTIReader()
{
}
void CAPGTSHTIReader::Parse()
{
#ifdef LOCAL_TROUBLESHOOTER
// OVERVIEW: For the Local Troubleshooter, search for a <!GTS resource $Previous.script>
// token in the stream. If one is not found, then insert one for backwards
// compatibility.
try
{
// Load the stream into a vector while searching for a "Previous.script" token and also
// determining the position of the last closing HTML tag location in order to know where
// to insert the generated_previous() function.
CString str;
vector<CString> str_arr;
long indexLastHTML = -1;
// Place the content of m_StreamData, line by line, into str_arr
SetPos( m_StreamData, 0 );
while (GetLine( m_StreamData, str ))
{
// Determine whether or not this line contains the "Previous.script" token.
CString strCommand;
if (GetCommand( str, strCommand))
{
// Check if the command is the right type.
if (strCommand == COMMAND_RESOURCESTR)
{
CString strVariable;
if (GetVariable( str, strVariable ))
{
// Check if the variable is the right type.
if (strVariable == VAR_PREVIOUS_SCRIPT)
{
// We found what we were looking for.
// Reset the stream position and exit function.
SetPos( m_StreamData, 0 );
return;
}
}
}
}
// Add this line to the vector.
str_arr.push_back( str );
// Look for an HTML closing tag in this line.
if (str.Find( k_strHTMLtag ) != -1)
{
// Mark the location of the last \HTML tag found.
indexLastHTML= str_arr.size() - 1;
}
}
// Rebuild the input stream from the vector and insert the "Previous.script" token
// in the location determined above.
vector<CString>::iterator iLastElement = str_arr.end();
iLastElement--;
m_StreamData.clear();
CString strResult;
long index = 0;
for (vector<CString>::iterator i = str_arr.begin(); i < str_arr.end(); i++, index++)
{
if (index == indexLastHTML)
{
// Add the required token to the string.
strResult+= COMMAND_STARTSTR;
strResult+= _T(" ");
strResult+= COMMAND_RESOURCESTR;
strResult+= _T(" ");
strResult+= COMMAND_STARTVARSTR;
strResult+= VAR_PREVIOUS_SCRIPT;
strResult+= COMMAND_ENDSTR;
strResult+= _T("\r\n");
}
strResult += *i;
if (i != iLastElement)
strResult+= _T("\r\n");
}
m_StreamData.str( (LPCTSTR) strResult );
SetPos( m_StreamData, 0 );
}
catch (exception& x)
{
CString str;
// Note STL exception in event log.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
CCharConversion::ConvertACharToString(x.what(), str),
_T(""),
EV_GTS_STL_EXCEPTION );
}
#endif
}
// JSM V3.2 adapted from CreatePage()
// builds list of all Network props in this HTI file which appear
// in lines like <!GTI property "fooprop">
//
// called by apgtscontext to find network properties to pass to CHTMLFragmentsTS
void CAPGTSHTIReader::ExtractNetProps(vector <CString> &arr_props)
{
LOCKOBJECT();
try
{
arr_props.clear();
// InitializeInterpreted populates m_arrInterpreted and
// performs cookie substitutions. This is correct behavior,
// because cookie substitution is supposed to happen
// before !GTS processing, and it is conceivable
// that a cookie's value could be "<!GTS property fooprop>"
InitializeInterpreted();
// we should not call Interpret(), which involves parsing <!GTS clauses
for (vector<CString>::iterator i = m_arrInterpreted.begin(); i < m_arrInterpreted.end(); i++)
{
CString command;
if (GetCommand(*i, command))
{
if (command == COMMAND_PROPERTY)
{
CString strProperty;
if (GetVariable(*i,strProperty))
arr_props.push_back(strProperty);
}
}
}
}
catch (...)
{
// Catch any other exception thrown.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
_T(""), _T(""),
EV_GTS_GEN_EXCEPTION );
}
UNLOCKOBJECT();
}
void CAPGTSHTIReader::CreatePage( const CHTMLFragments& fragments,
CString& out,
const map<CString,CString> & mapStrs,
CString strHTTPcookies/*= _T("")*/ )
{
LOCKOBJECT();
try
{
m_pFragments = &fragments;
// V3.2 Cookie related enhancement.
// Opted to use a member variable rather than modifying class interface by
// adding a parameter to virtual void method InitializeInterpreted().
m_strHTTPcookies= strHTTPcookies;
m_mapCookies= mapStrs;
InitializeInterpreted();
Interpret();
#ifdef __DEBUG_CUSTOM
SetOutputToInterpreted();
FlushOutputStreamToFile("..\\Files\\interpreted.hti");
#endif
ParseInterpreted();
SetOutputToInterpreted();
#ifdef __DEBUG_CUSTOM
FlushOutputStreamToFile("..\\Files\\result.htm");
#endif
out = m_StreamOutput.rdbuf()->str().c_str();
}
catch (...)
{
// Catch any other exception thrown.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
_T(""), _T(""),
EV_GTS_GEN_EXCEPTION );
}
UNLOCKOBJECT();
}
void CAPGTSHTIReader::InitializeInterpreted()
{
long savePos = 0;
CString str;
CString command;
bool bOldFormat = true; // this is an old format (without $Success or $StartForm)
bool bFoundFirstBlock= false;
savePos = GetPos();
bOldFormat = !Find(CString(COMMAND_STARTVARSTR)+VAR_SUCCESS) &&
!Find(CString(COMMAND_STARTVARSTR)+VAR_STARTFORM);
SetPos(0);
m_arrInterpreted.clear();
try
{
while (GetLine(str))
{
if (bOldFormat && (!bFoundFirstBlock) && (-1 != str.Find( COMMAND_STARTSTR )))
{
// Output the $StartForm block only if it is not a resource string command.
CString strCommand;
if ((GetCommand( str, strCommand )) && (strCommand != COMMAND_RESOURCESTR))
{
/*
<!GTS if $StartForm>
<!GTS display $StartForm>
<!GTS endif>
*/
ComposeCommand(COMMAND_IFSTR, VAR_STARTFORM, command);
m_arrInterpreted.push_back(command);
ComposeCommand(COMMAND_DISPLAYSTR, VAR_STARTFORM, command);
m_arrInterpreted.push_back(command);
ComposeCommand(COMMAND_ENDIFSTR, _T(""), command);
m_arrInterpreted.push_back(command);
bFoundFirstBlock = true;
}
}
if (bOldFormat && (-1 != str.Find(_T("</FORM>"))))
{
/*
<!GTS if $StartForm>
*/
ComposeCommand(COMMAND_IFSTR, VAR_STARTFORM, command);
m_arrInterpreted.push_back(command);
m_arrInterpreted.push_back(str);
/*
<!GTS endif>
*/
ComposeCommand(COMMAND_ENDIFSTR, _T(""), command);
m_arrInterpreted.push_back(command);
}
else
{
// Check if we need to populate any cookie clauses.
if (-1 != str.Find( COMMAND_COOKIE ))
SubstituteCookieValues( str );
m_arrInterpreted.push_back(str);
}
}
}
catch (exception& x)
{
CString str2;
// Note STL exception in event log.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
CCharConversion::ConvertACharToString(x.what(), str2),
_T(""),
EV_GTS_STL_EXCEPTION );
}
SetPos(savePos);
}
void CAPGTSHTIReader::Interpret()
{
long curr_index = 0;
long lLastIndex= -1; // Used to detect a HTI file with incomplete clauses.
while(true)
{
vector<CString> clause_arr;
// tries to extract clause from m_arrInterpreted starting with curr_index
// and remove it from m_arrInterpreted
if (ExtractClause(m_arrInterpreted,
&curr_index, // in - out
clause_arr))
{
// Reset the infinite loop detection counter.
lLastIndex= -1;
// Now curr_index is pointing to next element
// of m_arrInterpreted (after removed clause)
// OR OUTSIDE boundary of m_arrInterpreted.
if (InterpretClause(clause_arr))
{
vector<CString>::iterator i = m_arrInterpreted.begin();
{ // create iterator that points to m_arrInterpreted[curr_index]
// or is m_arrInterpreted.end()
long tmp_index = curr_index;
while(tmp_index--)
i++;
}
try
{
// insert interpreted clause there
for (vector<CString>::iterator j = clause_arr.begin(); j < clause_arr.end(); j++)
{
i = m_arrInterpreted.insert(i, *j); // inserts before "i"
i++;
curr_index++;
}
}
catch (exception& x)
{
CString str;
// Note STL exception in event log.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
CCharConversion::ConvertACharToString(x.what(), str),
_T(""),
EV_GTS_STL_EXCEPTION );
}
}
}
else
{
// If this condition is true, then we are in an infinite loop due to a bad HTI file.
if (lLastIndex == curr_index)
{
// Log that this HTI file does not parse correctly.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
GetPathName(), _T(""),
EV_GTS_BAD_HTI_FILE );
break;
}
// Update the infinite loop detection counter.
lLastIndex= curr_index;
if (curr_index) {
// we finished current pass of m_arrInterpreted, start new one
curr_index = 0;
continue;
}
else {
// we can not extract clause though we start from beginning -
// m_arrInterpreted is interpreted now
break;
}
}
}
}
// modified V3.2 JSM
void CAPGTSHTIReader::ParseInterpreted()
{
for (vector<CString>::iterator i = m_arrInterpreted.begin(); i < m_arrInterpreted.end(); i++)
{
CString command;
if (GetCommand(*i, command))
{
if (command == COMMAND_DISPLAYSTR ||
command == COMMAND_RESOURCESTR ||
command == COMMAND_INFORMATION
)
{
CString variable;
if (GetVariable(*i, variable))
{
CString substitution;
FragmentIDVector arr_fragment;
ParseVariable(variable, arr_fragment);
substitution = const_cast<CHTMLFragments*>(m_pFragments)->GetText(arr_fragment, (command == COMMAND_RESOURCESTR) ? CHTMLFragments::eResource : CHTMLFragments::eNotOfInterest );
SubstituteCommandBlockWith(substitution, *i);
}
else // obvious misbehaviour - "display" command should have variable
SubstituteCommandBlockWith(_T(""), *i);
}
else if (command == COMMAND_VALUE)
{
CString variable;
if (GetVariable(*i, variable))
const_cast<CHTMLFragments*>(m_pFragments)->SetValue(variable);
SubstituteCommandBlockWith(_T(""), *i);
}
// V3.2 JSM
else if (command == COMMAND_PROPERTY)
{
CString strProperty;
if (GetVariable(*i,strProperty))
{
CString substitution;
substitution = const_cast<CHTMLFragments*>(m_pFragments)->GetNetProp(strProperty);
SubstituteCommandBlockWith(substitution, *i);
}
else // obvious misbehaviour - "property" command should have variable
SubstituteCommandBlockWith(_T(""), *i);
} // end V3.2 JSM
else // obvious misbehaviour - no other commands
SubstituteCommandBlockWith(_T(""), *i);
}
}
}
void CAPGTSHTIReader::SetOutputToInterpreted()
{
vector<CString>::iterator j = m_arrInterpreted.end();
// Decrement to point to last element.
j--;
m_StreamOutput.str(_T(""));
for (vector<CString>::iterator i = m_arrInterpreted.begin(); i < m_arrInterpreted.end(); i++)
{
m_StreamOutput << (LPCTSTR)*i;
if (i != j) // not last element
m_StreamOutput << _T('\r') << _T('\n');
}
m_StreamOutput << ends;
}
// INPUT: arr_text (with clause)
// IMPUT: *pstart_index - index in arr_text
// OUTPUT: arr_text without clause
// OUTPUT: *pstart_index points to element in arr_text next to where
// clause used to be or outside arr_text
// OUTPUT: arr_clause - extracted clause
bool CAPGTSHTIReader::ExtractClause(vector<CString>& arr_text,
long* pstart_index,
vector<CString>& arr_clause)
{
if (*pstart_index > arr_text.size() - 1) // quite possible
return false;
for (long i = *pstart_index; i < arr_text.size(); i++)
{
CString str_command;
if (GetCommand(arr_text[i], str_command))
{
if (str_command == COMMAND_FORANYSTR)
{
if (ExtractClause(arr_text,
&i,
arr_clause,
COMMAND_FORANYSTR,
COMMAND_ENDFORSTR))
{
*pstart_index = i;
return true;
}
else
{
*pstart_index = i;
return false;
}
}
if (str_command == COMMAND_IFSTR)
{
if (ExtractClause(arr_text,
&i,
arr_clause,
COMMAND_IFSTR,
COMMAND_ENDIFSTR))
{
*pstart_index = i;
return true;
}
else
{
*pstart_index = i;
return false;
}
}
}
}
return false;
}
bool CAPGTSHTIReader::ExtractClause(vector<CString>& arr_text,
long* pstart_index,
vector<CString>& arr_clause,
const CString& str_start_command,
const CString& str_end_command)
{
CString str_command;
long start = *pstart_index, end = *pstart_index;
long nest_level_counter = 1;
while (++end < arr_text.size())
{
if (GetCommand(arr_text[end], str_command))
{
if (str_command == str_start_command)
{
nest_level_counter++;
}
if (str_command == str_end_command)
{
nest_level_counter--;
if (!nest_level_counter)
{
vector<CString>::iterator start_it = arr_text.begin();
vector<CString>::iterator end_it = arr_text.begin();
arr_clause.clear();
try
{
// copy clause to arr_clause
for (long j = start; j <= end; j++)
arr_clause.push_back(arr_text[j]);
}
catch (exception& x)
{
CString str;
// Note STL exception in event log.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
CCharConversion::ConvertACharToString(x.what(), str),
_T(""),
EV_GTS_STL_EXCEPTION );
}
// make iterators correspond indexes
while(start--)
start_it++;
while(end--)
end_it++;
// and, because we want to delete element pointed
// at this moment by end_it:
end_it++;
// remove clause from arr_text
arr_text.erase(start_it, end_it);
return true;
}
}
}
}
*pstart_index = --end;;
return false;
}
bool CAPGTSHTIReader::InterpretClause(vector<CString>& arr_clause)
{
CString str_command;
if (arr_clause.size() &&
GetCommand(arr_clause[0], str_command))
{
if (str_command == COMMAND_FORANYSTR)
return InterpretForanyClause(arr_clause);
if (str_command == COMMAND_IFSTR)
return InterpretIfClause(arr_clause);
return false;
}
return false;
}
bool CAPGTSHTIReader::InterpretForanyClause(vector<CString>& arr_clause)
{
long count = 0;
CString strVariable; // variable from 1-st line of arr_clause
vector<CString> arrUnfolded;
FragmentIDVector arrVariable; // array from strVariable
if (arr_clause.size() < 2) // "forany" and "endfor" commands
return false;
if (!GetVariable(arr_clause[0], strVariable))
return false;
ParseVariable(strVariable, arrVariable);
count = m_pFragments->GetCount(arrVariable);
try
{
for (long i = 0; i < count; i++)
{
for (long j = 1; j < arr_clause.size() - 1; j++)
{
CString command, variable;
if (GetCommand(arr_clause[j], command) &&
GetVariable(arr_clause[j], variable))
{
if (command == COMMAND_FORANYSTR && variable == strVariable)
{
// if it is clause "forany" with the same variable,
// there should be neither prefixing nor postfixing
}
else
{
CString line = arr_clause[j];
if (variable == strVariable)
{
PostfixVariable(i, variable);
}
else
{
FragmentIDVector parents, children;
CString strVariable_postfixed = strVariable;
PostfixVariable(i, strVariable_postfixed);
ParseVariable(strVariable_postfixed, parents);
ParseVariable(variable, children);
if (m_pFragments->IsValidSeqOfVars(parents, children))
PrefixVariable(strVariable_postfixed, variable);
}
CString command_block;
ComposeCommandBlock(command, variable, command_block);
SubstituteCommandBlockWith(command_block, line);
arrUnfolded.push_back(line);
continue;
}
}
arrUnfolded.push_back(arr_clause[j]);
}
}
}
catch (exception& x)
{
CString str;
// Note STL exception in event log.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
CCharConversion::ConvertACharToString(x.what(), str),
_T(""),
EV_GTS_STL_EXCEPTION );
}
arr_clause = arrUnfolded;
return true;
}
bool CAPGTSHTIReader::InterpretIfClause(vector<CString>& arr_clause)
{
CString strVariable; // variable from a line of arr_clause
FragmentIDVector arrVariable;
if (arr_clause.size() < 2) // "if" and "endif" commands
return false;
if (!GetVariable( arr_clause[ 0 ], strVariable ))
return false;
ParseVariable( strVariable, arrVariable );
// Scan for "if", "elseif", "else", and "endif" commands
vector<int> arrElseIfIndices;
int elseIndex = -1; // index of "else" inside arr_clause
int i = 0;
int nDepthOfNesting;
for (i= 1, nDepthOfNesting= 0; i < arr_clause.size() - 1; i++)
{
CString command;
if (GetCommand(arr_clause[i], command))
{
if (command == COMMAND_IFSTR)
{
nDepthOfNesting++;
}
else if (command == COMMAND_ENDIFSTR)
{
nDepthOfNesting--;
}
else if (command == COMMAND_ELSEIFSTR)
{
// V3.2 - Check if this elseif clause is at the level we are looking for.
if (nDepthOfNesting == 0)
arrElseIfIndices.push_back( i );
}
else if (command == COMMAND_ELSESTR)
{
// Check if this else clause is at the level we are looking for.
if (nDepthOfNesting == 0)
{
elseIndex = i;
break;
}
}
}
}
vector<CString> arrBody; // intermediate array
try
{
CString strName; // name of strVariable associated through CHTMLFragments
strName = const_cast<CHTMLFragments*>(m_pFragments)->GetText(arrVariable);
if (strName.GetLength())
{
// Standard processing of what is inside if ... else (or endif)
int nEndOfClause= (arrElseIfIndices.size()) ? arrElseIfIndices[ 0 ] : elseIndex;
for (i = 1; i < (nEndOfClause == -1 ? arr_clause.size() - 1 : nEndOfClause); i++)
arrBody.push_back(arr_clause[i]);
}
else
{
// Process any elseif or else clauses.
bool bDoneProcessing= false;
for (int nElseIf= 0; nElseIf < arrElseIfIndices.size(); nElseIf++)
{
if (!GetVariable( arr_clause[ arrElseIfIndices[ nElseIf ] ], strVariable ))
return false;
ParseVariable( strVariable, arrVariable );
strName = const_cast<CHTMLFragments*>(m_pFragments)->GetText(arrVariable);
if (strName.GetLength())
{
// Determine the ending point of this elseif clause and extract all clauses within.
int nEndOfClause= ((nElseIf + 1) < arrElseIfIndices.size())
? arrElseIfIndices[ nElseIf + 1 ] : elseIndex;
for (i= arrElseIfIndices[ nElseIf ] + 1; i < nEndOfClause; i++)
arrBody.push_back( arr_clause[ i ] );
bDoneProcessing= true;
break;
}
}
if ((!bDoneProcessing) && (elseIndex != -1))
{
// All of the clauses failed, output all clauses following the "else".
for (i = elseIndex + 1; i < arr_clause.size() - 1; i++)
arrBody.push_back(arr_clause[i]);
}
}
}
catch (exception& x)
{
CString str;
// Note STL exception in event log.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
CCharConversion::ConvertACharToString(x.what(), str),
_T(""),
EV_GTS_STL_EXCEPTION );
}
arr_clause = arrBody;
return true;
}
bool CAPGTSHTIReader::GetCommand(const CString& line, CString& command)
{
CString control_block;
CString variable;
if (GetControlBlockFromLine(line, control_block))
if (GetCommandVariableFromControlBlock(control_block, command, variable))
return true;
return false;
}
bool CAPGTSHTIReader::ComposeCommand(const CString& oper, const CString& variable, CString& command)
{
command = _T("");
LPCTSTR ws = _T(" ");
command += COMMAND_STARTSTR;
command += ws;
command += oper;
if (variable.GetLength()) {
command += ws;
command += COMMAND_STARTVARSTR;
command += variable;
}
command += COMMAND_ENDSTR;
return true;
}
bool CAPGTSHTIReader::GetVariable(const CString& line, CString& arg_variable)
{
CString control_block;
CString command, variable;
if (GetControlBlockFromLine(line, control_block))
if (GetCommandVariableFromControlBlock(control_block, command, variable))
if (variable.GetLength()) {
arg_variable = variable;
return true;
}
return false;
}
void CAPGTSHTIReader::ParseVariable(const CString& variable, FragmentIDVector& out)
{
vector<CString> arrStr;
int start_index = 0;
int end_index = -1;
try
{
// arrStr contains strings between delimiter "_"
while(-1 != (end_index = CString((LPCTSTR)variable + start_index).Find(DELIMITER_PREFIX)))
{
// end_index here is from "(LPCTSTR)variable + start_index" string
// so we can use it as length (2nd argument) in CString::Mid function
arrStr.push_back(((CString&)variable).Mid(start_index, end_index));
start_index = start_index + end_index + _tcslen(DELIMITER_PREFIX);
}
// pull the "tail" - after last (if any) "_"
arrStr.push_back(((CString&)variable).Right(variable.GetLength() - start_index));
out.clear();
for (vector<CString>::iterator i = arrStr.begin(); i < arrStr.end(); i++)
{
FragmentID fragmentID;
int curr = (*i).Find(DELIMITER_POSTFIX);
if (-1 != curr)
{
fragmentID.VarName = (*i).Left(curr);
curr += _tcslen(DELIMITER_POSTFIX); // skip delimiter
CString strIndex = (LPCTSTR)(*i) + curr;
strIndex.TrimLeft();
strIndex.TrimRight();
if (strIndex == _T("0"))
fragmentID.Index = 0;
else
fragmentID.Index = _ttol((LPCTSTR)strIndex) == 0
? fragmentID.Index // error occur
: _ttol((LPCTSTR)strIndex);
}
else
fragmentID.VarName = *i;
out.push_back(fragmentID);
}
}
catch (exception& x)
{
CString str;
// Note STL exception in event log.
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
CCharConversion::ConvertACharToString(x.what(), str),
_T(""),
EV_GTS_STL_EXCEPTION );
}
}
void CAPGTSHTIReader::ComposeVariable(const FragmentIDVector& arr_fragment, CString& variable)
{
variable = _T("");
for (FragmentIDVector::const_iterator i = arr_fragment.begin(); i < arr_fragment.end(); i++)
{
if (i != arr_fragment.begin())
variable += DELIMITER_PREFIX;
variable += (*i).VarName;
if ((*i).Index != -1)
{
TCHAR buf[128] = {0};
variable += DELIMITER_POSTFIX;
_stprintf(buf, _T("%d"), (*i).Index);
variable += buf;
}
}
}
bool CAPGTSHTIReader::SubstituteCommandBlockWith(const CString& str_substitution, CString& line)
{
int start_index = -1;
int end_index = -1;
if (-1 != (start_index = line.Find(COMMAND_STARTSTR)))
{
if (-1 != (end_index = CString((LPCTSTR)line + start_index).Find(COMMAND_ENDSTR)))
{
CString tmp;
end_index += start_index;
end_index += _tcslen(COMMAND_ENDSTR); // skip closing bracket
tmp += line.Left(start_index);
tmp += str_substitution;
tmp += line.Right(line.GetLength() - end_index);
line = tmp;
return true;
}
}
return false;
}
void CAPGTSHTIReader::ComposeCommandBlock(const CString& command, const CString& variable, CString& command_block)
{
command_block = COMMAND_STARTSTR;
command_block += _T(" ");
command_block += command;
command_block += _T(" ");
command_block += COMMAND_STARTVARSTR;
command_block += variable;
command_block += _T(" ");
command_block += COMMAND_ENDSTR;
}
void CAPGTSHTIReader::PostfixVariable(const long postfix, CString& variable)
{
TCHAR buf[128] = {0};
_stprintf(buf, _T("%ld"), postfix);
variable += DELIMITER_POSTFIX;
variable += buf;
}
void CAPGTSHTIReader::PrefixVariable(const CString& prefix, CString& variable)
{
CString tmp = variable;
variable = prefix;
variable += DELIMITER_PREFIX;
variable += tmp;
}
// JSM V3.2 --
// called by GetCommandVariableFromControlBlock to handle
// decoding the variable part of commands like <!GTS property "fooprop">
// finds the first string argument in strText, which is either:
// any text beginning w/ anything other than '"', ending w/ whitespace or COMMAND_ENDSTR
// all text between doublequote marks "...." where an escape char ('\') escapes the character following.
//
CString CAPGTSHTIReader::GetStringArg(const CString & strText)
{
CString strArg = strText;
// look for quoted text:
int iStartQuote = strArg.Find(COMMAND_DOUBLEQUOTE);
if (iStartQuote != -1)
{
strArg = strArg.Mid(iStartQuote);
return GetEscapedText(strArg);
}
// o/w, assume that we're dealing w/ ordinary text, which ends
// with first whitespace or with COMMAND_ENDSTR
strArg.TrimLeft();
int iWhiteSpace(0), iEndCmd(0);
for(;(iWhiteSpace < strArg.GetLength()) && !(_istspace(strArg[iWhiteSpace])); iWhiteSpace++);
iEndCmd = strArg.Find(COMMAND_ENDSTR);
strArg = strArg.Left(min(iEndCmd,iWhiteSpace));
return strArg;
}
// JSM V3.2
// Called by GetEscapedText
// recursive function which does the work of removing escapes (backslashes)
// also checks for non-escaped endquote, which terminates the process
CString CAPGTSHTIReader::RemoveEscapesFrom(const CString &strIn)
{
int iNextESC = strIn.Find(COMMAND_ESCAPECHAR);
int iNextQuote = strIn.Find(COMMAND_DOUBLEQUOTE);
// (iNextQuote == -1) means a bad input, because the string
// we're looking at must terminate with quote.
// By default, however, we'll keep running to end of strIn.
if (iNextQuote == -1)
iNextQuote = strIn.GetLength();
// no more escape chars
if (iNextESC == -1 || (iNextESC > iNextQuote))
return strIn.Left(iNextQuote);
CString strEscapedChar;
strEscapedChar = strIn.GetAt(iNextESC + _tcslen(COMMAND_ESCAPECHAR));
return strIn.Left(iNextESC) +
strEscapedChar +
RemoveEscapesFrom(strIn.Mid(iNextESC + _tcslen(COMMAND_ESCAPECHAR) + 1));
}
// Converts a double-quoted string using backslash as an escape character to a correct CString
CString CAPGTSHTIReader::GetEscapedText(const CString &strText)
{
CString strEscaped;
// remove leading quote and anything preceding:
int iLeadQuote = strText.Find(COMMAND_DOUBLEQUOTE);
if (iLeadQuote != -1)
{
strEscaped = RemoveEscapesFrom(strText.Mid(iLeadQuote + _tcslen(COMMAND_DOUBLEQUOTE)));
}
return strEscaped;
}
// JSM V3.2 added ability to read string arguments into variable
// e.g. <!GTS property "FOO">
//
bool CAPGTSHTIReader::GetCommandVariableFromControlBlock(const CString& control_block, CString& command, CString& variable)
{
int start_command_index = -1;
int end_command_index = -1;
int start_variable_index = -1;
int end_variable_index = -1;
variable.Empty();
command.Empty();
start_command_index = control_block.Find(COMMAND_STARTSTR);
if (start_command_index == -1) // invalid control block
return false;
start_command_index += _tcslen(COMMAND_STARTSTR); // skip prefix
// extract the variable block, which can look like:
// ... $variable_name ...
// ... "parameter_name\\\"" ... (text in quotes w/ backslash escape)
// parameter_name (plain text)
if (-1 != ( end_command_index = (control_block.Mid(start_command_index)).Find(COMMAND_STARTVARSTR) ) )
{
// Variable prefixed with '$...'
end_command_index += start_command_index; // make end_command_index relative to start of control block
start_variable_index = end_command_index + _tcslen(COMMAND_STARTVARSTR); // skip "$"
end_variable_index = control_block.Find(COMMAND_ENDSTR);
// validation of indexes
if (-1 == min(start_command_index, end_command_index) ||
start_command_index > end_command_index)
return false;
command = ((CString&)control_block).Mid(start_command_index, end_command_index - start_command_index);
command.TrimLeft();
command.TrimRight();
if (start_variable_index > end_variable_index)
return false;
if (-1 != start_variable_index)
{
// extract variable from "..$varname>"
variable = ((CString&)control_block).Mid(start_variable_index, end_variable_index - start_variable_index);
variable.TrimLeft();
variable.TrimRight();
}
}
else
{
// Not prefixed with $.
// we don't know whether we're looking for a "\"quoted\"" or
// non-quoted string, or no variable at all. Also, we need
// to handle special cases like:
// <!GTS parameter ">">
// <!GTS endfor >
// etc.
command = ((CString&)control_block).Mid(start_command_index);
command.TrimLeft();
command.TrimRight();
// step through looking for whitespace at end of command:
int iWhiteSpace;
for(iWhiteSpace = 0;
(iWhiteSpace < command.GetLength()) && !(_istspace(command[iWhiteSpace]));
iWhiteSpace++);
if (iWhiteSpace != command.GetLength())
{
// found whitespace; the rest of the string may be a variable:
variable = GetStringArg(command.Mid(iWhiteSpace));
command = command.Left(iWhiteSpace); // truncate command where appropriate
}
else
{
// If there wasn't a variable after the command, we
// may still need to truncate to remove the COMMAND_ENDSTR:
end_command_index = command.Find(COMMAND_ENDSTR);
if (end_command_index != -1)
command = command.Left(end_command_index);
}
}
return true;
}
bool CAPGTSHTIReader::GetControlBlockFromLine(const CString& line, CString& control_block)
{
int start_index = -1;
int end_index = -1;
if (-1 == (start_index = line.Find(COMMAND_STARTSTR)))
return false;
if (-1 == (end_index = CString((LPCTSTR)line + start_index).Find(COMMAND_ENDSTR)))
return false;
end_index += _tcslen(COMMAND_ENDSTR); // points beyond closing bracket
end_index += start_index; // points in "line" string
control_block = ((CString&)line).Mid(start_index, end_index - start_index);
control_block.TrimLeft();
control_block.TrimRight();
return true;
}
bool CAPGTSHTIReader::HasHistoryTable()
{
bool bRet;
LOCKOBJECT();
CString indicator = CString(COMMAND_STARTVARSTR) + VAR_RECOMMENDATIONS;
bRet= Find( indicator );
UNLOCKOBJECT();
return( bRet );
}
#ifdef __DEBUG_CUSTOM
#include <io.h>
#include <fcntl.h>
#include <sys\\stat.h>
bool CAPGTSHTIReader::FlushOutputStreamToFile(const CString& file_name)
{
int hf = 0;
hf = _open(
file_name,
_O_CREAT | _O_TRUNC | /*_O_TEMPORARY |*/
_O_BINARY | _O_RDWR | _O_SEQUENTIAL ,
_S_IREAD | _S_IWRITE
);
if (hf != -1)
{
//tstringstream m_StreamOutput
basic_string<TCHAR> str = m_StreamOutput.rdbuf()->str();
long size = str.size();
LPCTSTR buf = str.c_str();
int ret = _write(hf, buf, size);
_close(hf);
if (-1 != ret)
return true;
}
return false;
}
#endif
// V3.2 - Enhancement to support cookies.
// This function handles the substituting of "<!Cookie" clauses with the either
// values from cookies, "_CK" values passed in via Get/Post, or the default value.
void CAPGTSHTIReader::SubstituteCookieValues( CString& strText )
{
CString strNewText;
const CString kstr_CommaChar= _T(",");
const CString kstr_DoubleQuote= _T("\"");
// Loop until we have processed all cookie clauses.
int nNumericCompareStart= strText.Find( kstrCond_NumericCompare );
int nCookieClauseStart= strText.Find( COMMAND_COOKIE );
while (CString::FIND_FAILED != nCookieClauseStart)
{
CString strCookieClause;
CString strCookieName, strCookieAttr, strCookieValue;
int nCookieClauseEnd, nScratchMarker;
// Add any text preceding the cookie clause to the return string.
strNewText+= strText.Left( nCookieClauseStart );
// Remove all preceding text.
strText= strText.Mid( nCookieClauseStart + _tcslen( COMMAND_COOKIE ) );
// Look for the ending clause.
nCookieClauseEnd= strText.Find( COMMAND_ENDSTR );
if (CString::FIND_FAILED == nCookieClauseEnd)
{
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
COMMAND_ENDSTR, _T(""),
EV_GTS_COOKIE_COMPONENT_NOT_FOUND );
break;
}
// Pull out the current cookie clause and reset the working string.
strCookieClause= strText.Left( nCookieClauseEnd );
strText= strText.Mid( nCookieClauseEnd + 1 );
// Extract the cookie name.
nScratchMarker= strCookieClause.Find( kstr_CommaChar );
if (CString::FIND_FAILED == nScratchMarker)
{
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
kstr_CommaChar, _T(""),
EV_GTS_COOKIE_COMPONENT_NOT_FOUND );
break;
}
strCookieName= strCookieClause.Left( nScratchMarker );
strCookieName.TrimLeft();
strCookieName.TrimRight();
// Extract the cookie setting.
strCookieClause= strCookieClause.Mid( nScratchMarker + 1 );
nScratchMarker= strCookieClause.Find( kstr_CommaChar );
if (CString::FIND_FAILED == nScratchMarker)
{
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
kstr_CommaChar, _T(""),
EV_GTS_COOKIE_COMPONENT_NOT_FOUND );
break;
}
strCookieAttr= strCookieClause.Left( nScratchMarker );
strCookieAttr.TrimLeft();
strCookieAttr.TrimRight();
strCookieClause= strCookieClause.Mid( nScratchMarker + sizeof( TCHAR ) );
// Attempt to locate the appropriate attribute/value pair,
// first checking the command line CK_ values, and
// then checking the cookies passed in the HTTP header.
bool bCookieNotFound= true;
if (!m_mapCookies.empty())
{
// Search the command line CK_ values.
map<CString,CString>::const_iterator iterMap= m_mapCookies.find( strCookieAttr );
if (iterMap != m_mapCookies.end())
{
strCookieValue= iterMap->second;
bCookieNotFound= false;
}
}
if (bCookieNotFound)
{
if (!m_strHTTPcookies.IsEmpty())
{
// Attempt to locate the attribute in the HTTP header information.
if (LocateCookieValue( strCookieName, strCookieAttr, strCookieValue ))
bCookieNotFound= false;
}
}
if (bCookieNotFound)
{
// Extract the default value for this attribute, which should be surrounded
// by double quotes.
nScratchMarker= strCookieClause.Find( kstr_DoubleQuote );
if (CString::FIND_FAILED == nScratchMarker)
{
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
kstr_DoubleQuote, _T(""),
EV_GTS_COOKIE_COMPONENT_NOT_FOUND );
break;
}
strCookieClause= strCookieClause.Mid( nScratchMarker + sizeof( TCHAR ) );
nScratchMarker= strCookieClause.Find( kstr_DoubleQuote );
if (CString::FIND_FAILED == nScratchMarker)
{
CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
CEvent::ReportWFEvent( SrcLoc.GetSrcFileLineStr(),
SrcLoc.GetSrcFileLineStr(),
kstr_DoubleQuote, _T(""),
EV_GTS_COOKIE_COMPONENT_NOT_FOUND );
break;
}
strCookieValue= strCookieClause.Left( nScratchMarker );
}
// Add the attribute value to the output string.
// >>> $MAINT - The determination of whether or not to output quotes should
// be improved. I currently have no suggestions. RAB-19990918.
if ((nNumericCompareStart == CString::FIND_FAILED) || (nNumericCompareStart > nCookieClauseStart))
strNewText+= _T("\"");
strNewText+= strCookieValue;
if ((nNumericCompareStart == CString::FIND_FAILED) || (nNumericCompareStart > nCookieClauseStart))
strNewText+= _T("\"");
// Look for another cookie clause.
nNumericCompareStart= strText.Find( kstrCond_NumericCompare );
nCookieClauseStart= strText.Find( COMMAND_COOKIE );
}
// Append any remaining text onto the end of the string.
// If a cookie clause did not contain an ending marker it will be appended as well.
strNewText+= strText;
// Reassign the return string.
strText= strNewText;
return;
}
// V3.2 - Enhancement to support cookies.
// This function searches the HTTP cookies for a given cookie name and attribute. If
// found, this function returns a value of true and the located cookie value.
bool CAPGTSHTIReader::LocateCookieValue( const CString& strCookieName,
const CString& strCookieAttr,
CString& strCookieValue )
{
bool bCookieFound= false;
CString strTmpCookieName= strCookieName + _T("=");
int nScratch;
// URL encode the cookie name to handle underscores.
APGTS_nmspace::CookieEncodeURL( strTmpCookieName );
nScratch= m_strHTTPcookies.Find( strTmpCookieName );
if (CString::FIND_FAILED != nScratch)
{
// Verify that we have not matched on a partial string for the cookie name.
if ((nScratch == 0) ||
(m_strHTTPcookies[ nScratch - 1 ] == _T(' ')) ||
(m_strHTTPcookies[ nScratch - 1 ] == _T(';')))
{
// We have found the cookie that we are looking for, now look for the attribute name.
CString strTmpCookieAttr= strCookieAttr + _T("=");
// URL encode the cookie name to handle underscores.
APGTS_nmspace::CookieEncodeURL( strTmpCookieAttr );
// Jump past the starting point and the original cookie name length.
CString strScratch = m_strHTTPcookies.Mid( nScratch + strCookieName.GetLength() );
nScratch= strScratch.Find( _T(";") );
if (CString::FIND_FAILED != nScratch)
{
// Truncate the string at the end of this particular cookie..
if (nScratch > 0)
strScratch= strScratch.Left( nScratch );
}
nScratch= strScratch.Find( strTmpCookieAttr );
if (CString::FIND_FAILED != nScratch)
{
if (nScratch > 0)
{
// Verify that we have not matched on a partial string for the cookie attribute.
if ((strScratch[ nScratch - 1 ] == _T('=')) ||
(strScratch[ nScratch - 1 ] == _T('&')))
{
strCookieValue= strScratch.Mid( nScratch + strTmpCookieAttr.GetLength() );
// Look for and remove any delimiters.
nScratch= strCookieValue.Find( _T("&") );
if (CString::FIND_FAILED != nScratch)
{
// Truncate the string.
if (nScratch > 0)
strCookieValue= strCookieValue.Left( nScratch );
}
nScratch= strCookieValue.Find( _T(";") );
if (CString::FIND_FAILED != nScratch)
{
// Truncate the string.
if (nScratch > 0)
strCookieValue= strCookieValue.Left( nScratch );
}
// Decode the cookie value.
if (!strCookieValue.IsEmpty())
APGTS_nmspace::CookieDecodeURL( strCookieValue );
bCookieFound= true;
}
}
}
}
}
return( bCookieFound );
}
Reference in New Issue View Git Blame Copy Permalink