// Load sentence file into memory, insert null terminators to
// delimit sentence name/sentence pairs. Keep pointer to each
// sentence name so we can search later.
void VOX_ReadSentenceFile( const char *psentenceFileName )
{
char c, *pch, *pFileData;
char *pchlast, *pSentenceData;
int fileSize;
// load file
pFileData = (char *)FS_LoadFile( psentenceFileName, &fileSize, false );
if( !pFileData )
{
MsgDev( D_WARN, "couldn't load %s\n", psentenceFileName );
return;
}
pch = pFileData;
pchlast = pch + fileSize;
while( pch < pchlast )
{
// only process this pass on sentences
pSentenceData = NULL;
// skip newline, cr, tab, space
c = *pch;
while( pch < pchlast && IsWhiteSpace( c ))
c = *(++pch);
// skip entire line if first char is /
if( *pch != '/' )
{
sentence_t *pSentence = &g_Sentences[g_numSentences++];
pSentence->pName = pch;
pSentence->length = 0;
// scan forward to first space, insert null terminator
// after sentence name
c = *pch;
while( pch < pchlast && c != ' ' )
c = *(++pch);
if( pch < pchlast )
*pch++ = 0;
// a sentence may have some line commands, make an extra pass
pSentenceData = pch;
}
// scan forward to end of sentence or eof
while( pch < pchlast && pch[0] != '\n' && pch[0] != '\r' )
pch++;
// insert null terminator
if( pch < pchlast ) *pch++ = 0;
// If we have some sentence data, parse out any line commands
if( pSentenceData && pSentenceData < pchlast )
{
int index = g_numSentences - 1;
// the current sentence has an index of count-1
VOX_ParseLineCommands( pSentenceData, index );
}
}
}
BOOL CSZCommandLine::Analyze(LPCTSTR lpszCmdLine)
{
BOOL bResult = FALSE;
int nParamNamePos = 0;
int nParamValuePos = 0;
int nSubCommandPos = 0;
CString strParamName;
CString strSubCommand;
BOOL bInQuotation = FALSE;
EM_CMDLINE_STATUS nStatus = em_Cmd_New_Arg;
m_mapParams.RemoveAll();
if (!lpszCmdLine)
goto Exit0;
for (int nPos = 0; 0 == nPos || lpszCmdLine[nPos - 1]; ++nPos)
{
TCHAR ch = lpszCmdLine[nPos];
switch (nStatus)
{
case em_Cmd_New_Arg:
bInQuotation = FALSE;
// no break;
case em_Cmd_White_Space:
if (IsWhiteSpace(ch))
{
nStatus = em_Cmd_White_Space;
}
else if (IsArgNamePrefix(ch))
{
nStatus = em_Cmd_Arg_Name_Prefix;
}
else if (IsAlpha(ch))
{ // skip sub command
nSubCommandPos = nPos;
nStatus = em_Cmd_Sub_Command;
}
else if (IsQuotation(ch))
{
bInQuotation = TRUE;
nStatus = em_Cmd_White_Space;
}
else
{
goto Exit0;
}
break;
case em_Cmd_Sub_Command:
if (IsWhiteSpace(ch))
{
strSubCommand.SetString(lpszCmdLine + nSubCommandPos, nPos - nSubCommandPos);
AppendSubCommand(strSubCommand);
nStatus = em_Cmd_New_Arg;
}
else if (IsAlpha(ch))
{ // skip sub command
nStatus = em_Cmd_Sub_Command;
}
else if (IsQuotation(ch))
{
strSubCommand.SetString(lpszCmdLine + nSubCommandPos, nPos - nSubCommandPos);
AppendSubCommand(strSubCommand);
nStatus = em_Cmd_New_Arg;
}
else
{
goto Exit0;
}
break;
case em_Cmd_Arg_Name_Prefix:
if (IsWhiteSpace(ch))
{
goto Exit0;
}
else if (IsArgNamePrefix(ch))
{ // Á¬ÐøµÄǰ׺
nStatus = em_Cmd_Arg_Name_Prefix;
}
else
{
nParamNamePos = nPos;
nStatus = em_Cmd_Arg_Name;
}
break;
case em_Cmd_Arg_Name:
if (IsWhiteSpace(ch))
{
strParamName.SetString(lpszCmdLine + nParamNamePos, nPos - nParamNamePos);
SetParam(strParamName, _T(""));
nStatus = em_Cmd_New_Arg;
}
else if (IsArgValuePrefix(ch))
{
strParamName.SetString(lpszCmdLine + nParamNamePos, nPos - nParamNamePos);
nStatus = em_Cmd_Arg_Value_Prefix;
}
else if (IsQuotation(ch))
{
strParamName.SetString(lpszCmdLine + nParamNamePos, nPos - nParamNamePos);
SetParam(strParamName, _T(""));
nStatus = em_Cmd_New_Arg;
}
else
{
nStatus = em_Cmd_Arg_Name;
}
break;
case em_Cmd_Arg_Value_Prefix:
if (IsWhiteSpace(ch))
{
if (bInQuotation)
{ // treat quoted white space as arg-value
nParamValuePos = nPos;
nStatus = em_Cmd_Arg_Value;
}
else
{
SetParam(strParamName, _T(""));
nStatus = em_Cmd_New_Arg;
}
}
else if (IsQuotation(ch))
{
nParamValuePos = nPos + 1;
bInQuotation = TRUE;
nStatus = em_Cmd_Arg_Value_Prefix;
}
else
{
nParamValuePos = nPos;
nStatus = em_Cmd_Arg_Value;
}
break;
case em_Cmd_Arg_Value:
if (IsWhiteSpace(ch) && !bInQuotation)
{
SetParam(strParamName, lpszCmdLine + nParamValuePos, nPos - nParamValuePos);
nStatus = em_Cmd_New_Arg;
}
else if (IsQuotation(ch))
{
SetParam(strParamName, lpszCmdLine + nParamValuePos, nPos - nParamValuePos);
nStatus = em_Cmd_New_Arg;
}
else
{
nStatus = em_Cmd_Arg_Value;
}
break;
}
}
bResult = TRUE;
Exit0:
return bResult;
}
void TiXmlElement::StreamIn (std::istream * in, TIXML_STRING * tag)
{
// We're called with some amount of pre-parsing. That is, some of "this"
// element is in "tag". Go ahead and stream to the closing ">"
while( in->good() )
{
int c = in->get();
if ( c <= 0 )
{
TiXmlDocument* document = GetDocument();
if ( document )
document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
return;
}
(*tag) += (char) c ;
if ( c == '>' )
break;
}
if ( tag->length() < 3 ) return;
// Okay...if we are a "/>" tag, then we're done. We've read a complete tag.
// If not, identify and stream.
if ( tag->at( tag->length() - 1 ) == '>'
&& tag->at( tag->length() - 2 ) == '/' )
{
// All good!
return;
}
else if ( tag->at( tag->length() - 1 ) == '>' )
{
// There is more. Could be:
// text
// cdata text (which looks like another node)
// closing tag
// another node.
for ( ;; )
{
StreamWhiteSpace( in, tag );
// Do we have text?
if ( in->good() && in->peek() != '<' )
{
// Yep, text.
TiXmlText text( "" );
text.StreamIn( in, tag );
// What follows text is a closing tag or another node.
// Go around again and figure it out.
continue;
}
// We now have either a closing tag...or another node.
// We should be at a "<", regardless.
if ( !in->good() ) return;
assert( in->peek() == '<' );
int tagIndex = (int) tag->length();
bool closingTag = false;
bool firstCharFound = false;
for( ;; )
{
if ( !in->good() )
return;
int c = in->peek();
if ( c <= 0 )
{
TiXmlDocument* document = GetDocument();
if ( document )
document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
return;
}
if ( c == '>' )
break;
*tag += (char) c;
in->get();
// Early out if we find the CDATA id.
if ( c == '[' && tag->size() >= 9 )
{
size_t len = tag->size();
const char* start = tag->c_str() + len - 9;
if ( strcmp( start, "<![CDATA[" ) == 0 ) {
assert( !closingTag );
break;
}
}
if ( !firstCharFound && c != '<' && !IsWhiteSpace( c ) )
{
firstCharFound = true;
if ( c == '/' )
closingTag = true;
}
}
// If it was a closing tag, then read in the closing '>' to clean up the input stream.
// If it was not, the streaming will be done by the tag.
if ( closingTag )
{
if ( !in->good() )
return;
int c = in->get();
if ( c <= 0 )
{
TiXmlDocument* document = GetDocument();
if ( document )
document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
return;
}
assert( c == '>' );
*tag += (char) c;
// We are done, once we've found our closing tag.
return;
}
else
{
// If not a closing tag, id it, and stream.
const char* tagloc = tag->c_str() + tagIndex;
TiXmlNode* node = Identify( tagloc, TIXML_DEFAULT_ENCODING );
if ( !node )
return;
node->StreamIn( in, tag );
delete node;
node = 0;
// No return: go around from the beginning: text, closing tag, or node.
}
}
}
}
//------------------------------------------------------------------------------
Tokeniser::tokentype Tokeniser::GetNextToken ()
{
tokentype TokenType = EMPTY;
while ((TokenType == EMPTY)
&& !in.bad()
&& !atEOF)
{
curChar = GetNextChar ();
//std::cout << curChar << " GetNextChar" << std::endl;
if (IsWhiteSpace (curChar))
{
// skip white space
}
else
{
if (IsPunctuation (curChar))
{
// std::cout << curChar << " IsPunctuation" << std::endl;
// classify punctuation token
switch (curChar)
{
case '[': ParseComment (); break;
case '\'':
if (ParseString ())
TokenType = STRING;
else TokenType = BAD;
break;
case '(':
TokenType = LPAR;
break;
case ')':
TokenType = RPAR;
break;
case '{':
TokenType = LPAR;
break;
case '}':
TokenType = RPAR;
break;
case '!':
TokenType = BANG;
break;
case '#':
TokenType = HASH;
break;
case '=':
TokenType = EQUALS;
break;
case ';':
TokenType = SEMICOLON;
break;
case ',':
TokenType = COMMA;
break;
case '*':
TokenType = ASTERIX;
break;
case ':':
TokenType = COLON;
break;
case '-':
TokenType = MINUS;
break;
case '"':
TokenType = DOUBLEQUOTE;
break;
case '/':
TokenType = BACKSLASH;
break;
default:
TokenType = OTHER;
break;
}
}
else
{
// It's either a number, or a string
if (isdigit (curChar))
{
TokenType = ParseNumber();
/* if (ParseNumber ())
TokenType = NUMBER;
else
TokenType = BAD;
*/
}
else
{
if (ParseToken ())
TokenType = STRING;
else TokenType = BAD;
}
}
}
}
if ((TokenType != STRING) && (TokenType != NUMBER))
{
token = "";
token += curChar;
}
return TokenType;
}
void TiXmlElement::StreamIn (TIXML_ISTREAM * in, TIXML_STRING * tag)
{
// We're called with some amount of pre-parsing. That is, some of "this"
// element is in "tag". Go ahead and stream to the closing ">"
while( in->good() )
{
int c = in->get();
(*tag) += (TCHAR) c ;
if ( c == '>' )
break;
}
if ( tag->length() < 3 ) return;
// Okay...if we are a "/>" tag, then we're done. We've read a complete tag.
// If not, identify and stream.
if ( tag->at( tag->length() - 1 ) == '>'
&& tag->at( tag->length() - 2 ) == '/' )
{
// All good!
return;
}
else if ( tag->at( tag->length() - 1 ) == '>' )
{
// There is more. Could be:
// text
// closing tag
// another node.
for ( ;; )
{
StreamWhiteSpace( in, tag );
// Do we have text?
if ( in->good() && in->peek() != '<' )
{
// Yep, text.
TiXmlText text( TEXT("") );
text.StreamIn( in, tag );
// What follows text is a closing tag or another node.
// Go around again and figure it out.
continue;
}
// We now have either a closing tag...or another node.
// We should be at a "<", regardless.
if ( !in->good() ) return;
assert( in->peek() == '<' );
size_t tagIndex = tag->length();
bool closingTag = false;
bool firstCharFound = false;
for( ;; )
{
if ( !in->good() )
return;
int c = in->peek();
if ( c == '>' )
break;
*tag += (TCHAR)c;
in->get();
if ( !firstCharFound && c != '<' && !IsWhiteSpace( c ) )
{
firstCharFound = true;
if ( c == '/' )
closingTag = true;
}
}
// If it was a closing tag, then read in the closing '>' to clean up the input stream.
// If it was not, the streaming will be done by the tag.
if ( closingTag )
{
int c = in->get();
assert( c == '>' );
*tag += (TCHAR)c;
// We are done, once we've found our closing tag.
return;
}
else
{
// If not a closing tag, id it, and stream.
const TCHAR* tagloc = tag->c_str() + tagIndex;
TiXmlNode* node = Identify( tagloc );
if ( !node )
return;
node->StreamIn( in, tag );
delete node;
node = 0;
// No return: go around from the beginning: text, closing tag, or node.
}
}
}
}
TRISTATE CTextParser::GetCharacterSequence(char* szSequence, int* piLength)
{
char c;
BOOL bFirst;
int iPos;
bFirst = TRUE;
iPos = 0;
PushPosition();
SkipWhiteSpace();
//Make sure we're not off the end of the file.
if (mbOutsideText)
{
PopPosition();
SetErrorEndOfFile();
return TRIERROR;
}
for (;;)
{
if (!mbOutsideText)
{
c = mszParserPos[0];
StepRight();
if (IsWhiteSpace(c))
{
if (bFirst)
{
if (szSequence)
szSequence[iPos] = 0;
PopPosition();
return TRIFALSE;
}
else
{
if (szSequence)
szSequence[iPos] = 0;
if (szSequence)
PassPosition();
else
PopPosition();
SafeAssign(piLength, iPos);
return TRITRUE;
}
}
else
{
if (szSequence)
szSequence[iPos] = c;
}
}
else
{
if (bFirst)
{
PopPosition();
SetErrorEndOfFile();
return TRIERROR;
}
else
{
if (szSequence)
szSequence[iPos] = 0;
if (szSequence)
PassPosition();
else
PopPosition();
SafeAssign(piLength, iPos);
return TRITRUE;
}
}
bFirst = FALSE;
iPos++;
}
}
void FXmlFile::PreProcessInput(TArray<FString>& Input)
{
// Note: This implementation is written simply and will not handle all cases. It
// is made for the simple cases where FXmlFile is to be used.
// Assumptions/Misc:
// - Well-formatted file with 1 entry per line
// - Ignoring versions, encodings, and doctypes
// Remove white space at the beginning of lines
for(int32 i = 0; i < Input.Num(); ++i)
{
int32 NumWhiteSpace = 0;
for(int32 j = 0; j < Input[i].Len(); ++j)
{
if(!IsWhiteSpace(Input[i][j]))
{
break;
}
++NumWhiteSpace;
}
if(NumWhiteSpace > 0)
{
Input[i] = Input[i].Mid(NumWhiteSpace);
}
}
// Cull any text that can be removed on a line-based parse
for(int32 i = 0; i < Input.Num(); ++i)
{
// Find <!DOCTYPE or <?xml and remove those lines
if(Input[i].StartsWith(TEXT("<!DOCTYPE")) || Input[i].StartsWith(TEXT("<?xml")))
{
Input[i] = TEXT("");
}
}
// Cull any text inside of comments
bool bInComment = false;
int32 CommentLineStart = -1;
int32 CommentIndexStart = -1;
for(int32 i = 0; i < Input.Num(); ++i)
{
if(Input[i].Len() == 3)
{
if(bInComment)
{
if(Input[i][0] == TCHAR('-') && Input[i][1] == TCHAR('-') && Input[i][2] == TCHAR('>'))
{
// Found comment end, perform removal (simply replace all text with whitespace to be ignored by tokenizer)
bInComment = false;
int32 CommentLineEnd = i;
int32 CommentIndexEnd = 2;
WhiteOut(Input, CommentLineStart, CommentLineEnd, CommentIndexStart, CommentIndexEnd);
}
}
}
if(Input[i].Len() < 3)
{
continue;
}
int32 Indx1 = 0, Indx2 = 1, Indx3 = 2, Indx4 = 3;
for(; Indx4 < Input[i].Len(); ++Indx1, ++Indx2, ++Indx3, ++Indx4)
{
// Looking for the start of a comment
if(!bInComment)
{
if(Input[i][Indx1] == TCHAR('<') && Input[i][Indx2] == TCHAR('!') && Input[i][Indx3] == TCHAR('-') && Input[i][Indx4] == TCHAR('-'))
{
// Found comment start, mark it
bInComment = true;
CommentLineStart = i;
CommentIndexStart = Indx1;
}
}
// Looking for the end of a comment
else
{
if( (Input[i][Indx2] == TCHAR('-') && Input[i][Indx3] == TCHAR('-') && Input[i][Indx4] == TCHAR('>')) ||
(Input[i][Indx1] == TCHAR('-') && Input[i][Indx2] == TCHAR('-') && Input[i][Indx3] == TCHAR('>')) )
{
// Found comment end, perform removal (simply replace all text with whitespace to be ignored by tokenizer)
bInComment = false;
int32 CommentLineEnd = i;
int32 CommentIndexEnd = Indx4;
WhiteOut(Input, CommentLineStart, CommentLineEnd, CommentIndexStart, CommentIndexEnd);
}
}
}
}
}
int InPlaceParser::ProcessLine(int lineno,char *line,InPlaceParserInterface *callback)
{
int ret = 0;
const char *argv[MAXARGS];
int argc = 0;
char *foo = line;
while ( !EOS(*foo) && argc < MAXARGS )
{
foo = SkipSpaces(foo); // skip any leading spaces
if ( EOS(*foo) ) break;
if ( *foo == mQuoteChar ) // if it is an open quote
{
foo++;
if ( argc < MAXARGS )
{
argv[argc++] = foo;
}
while ( !EOS(*foo) && *foo != mQuoteChar ) foo++;
if ( !EOS(*foo) )
{
*foo = 0; // replace close quote with zero byte EOS
foo++;
}
}
else
{
foo = AddHard(argc,argv,foo); // add any hard separators, skip any spaces
if ( IsNonSeparator(*foo) ) // add non-hard argument.
{
bool quote = false;
if ( *foo == mQuoteChar )
{
foo++;
quote = true;
}
if ( argc < MAXARGS )
{
argv[argc++] = foo;
}
if ( quote )
{
while (*foo && *foo != mQuoteChar ) foo++;
if ( *foo ) *foo = 32;
}
// continue..until we hit an eos ..
while ( !EOS(*foo) ) // until we hit EOS
{
if ( IsWhiteSpace(*foo) ) // if we hit a space, stomp a zero byte, and exit
{
*foo = 0;
foo++;
break;
}
else if ( IsHard(*foo) ) // if we hit a hard separator, stomp a zero byte and store the hard separator argument
{
const char *hard = &mHardString[*foo*2];
*foo = 0;
if ( argc < MAXARGS )
{
argv[argc++] = hard;
}
foo++;
break;
}
foo++;
} // end of while loop...
}
}
}
if ( argc )
{
ret = callback->ParseLine(lineno, argc, argv );
}
return ret;
}
bool TiXmlText::Blank() const {
for (auto & elem : value)
if (!IsWhiteSpace(elem)) return false;
return true;
}
nsresult nsPropertiesParser::ParseBuffer(const PRUnichar* aBuffer,
PRUint32 aBufferLength)
{
const PRUnichar* cur = aBuffer;
const PRUnichar* end = aBuffer + aBufferLength;
// points to the start/end of the current key or value
const PRUnichar* tokenStart = nsnull;
// if we're in the middle of parsing a key or value, make sure
// the current token points to the beginning of the current buffer
if (mState == eParserState_Key ||
mState == eParserState_Value) {
tokenStart = aBuffer;
}
nsAutoString oldValue;
while (cur != end) {
PRUnichar c = *cur;
switch (mState) {
case eParserState_AwaitingKey:
if (c == '#' || c == '!')
EnterCommentState();
else if (!IsWhiteSpace(c)) {
// not a comment, not whitespace, we must have found a key!
EnterKeyState();
tokenStart = cur;
}
break;
case eParserState_Key:
if (c == '=' || c == ':') {
mKey += Substring(tokenStart, cur);
WaitForValue();
}
break;
case eParserState_AwaitingValue:
if (IsEOL(c)) {
// no value at all! mimic the normal value-ending
EnterValueState();
FinishValueState(oldValue);
}
// ignore white space leading up to the value
else if (!IsWhiteSpace(c)) {
tokenStart = cur;
EnterValueState();
// make sure to handle this first character
if (ParseValueCharacter(c, cur, tokenStart, oldValue))
cur++;
// If the character isn't consumed, don't do cur++ and parse
// the character again. This can happen f.e. for char 'X' in sequence
// "\u00X". This character can be control character and must be
// processed again.
continue;
}
break;
case eParserState_Value:
if (ParseValueCharacter(c, cur, tokenStart, oldValue))
cur++;
// See few lines above for reason of doing this
continue;
case eParserState_Comment:
// stay in this state till we hit EOL
if (c == '\r' || c== '\n')
WaitForKey();
break;
}
// finally, advance to the next character
cur++;
}
// if we're still parsing the value and are in eParserSpecial_None, then
// append whatever we have..
if (mState == eParserState_Value && tokenStart &&
mSpecialState == eParserSpecial_None) {
mValue += Substring(tokenStart, cur);
}
// if we're still parsing the key, then append whatever we have..
else if (mState == eParserState_Key && tokenStart) {
mKey += Substring(tokenStart, cur);
}
return NS_OK;
}
AString ADVBPatterns::ParsePattern(const AString& _line, PATTERN& pattern, const AString& user)
{
const ADVBConfig& config = ADVBConfig::Get();
ADataList& list = pattern.list;
AString& errors = pattern.errors;
AString line = config.ReplaceTerms(user, _line);
TERM *term;
uint_t i;
pattern.exclude = false;
pattern.enabled = true;
pattern.scorebased = false;
pattern.pri = 0;
pattern.user = user;
pattern.pattern = line;
if (pattern.user.Valid()) {
pattern.pri = (int)config.GetUserConfigItem(pattern.user, "pri");
}
list.DeleteList();
list.SetDestructor(&__DeleteTerm);
i = 0;
while (IsWhiteSpace(line[i])) i++;
if (line[i] == '#') {
pattern.enabled = false;
i++;
}
else if (line[i] == ';') {
return errors;
}
while (IsWhiteSpace(line[i])) i++;
if (line[i]) {
while (line[i] && errors.Empty()) {
if (!IsSymbolStart(line[i])) {
errors.printf("Character '%c' (at %u) is not a legal field start character (term %u)", line[i], i, list.Count() + 1);
break;
}
uint_t fieldstart = i++;
while (IsSymbolChar(line[i])) i++;
AString field = line.Mid(fieldstart, i - fieldstart).ToLower();
while (IsWhiteSpace(line[i])) i++;
if (field == "exclude") {
pattern.exclude = true;
continue;
}
const FIELD *fieldptr = (const FIELD *)ADVBProg::fieldhash.Read(field);
if (!fieldptr) {
uint_t nfields;
const FIELD *fields = ADVBProg::GetFields(nfields);
errors.printf("'%s' (at %u) is not a valid search field (term %u), valid search fields are: ", field.str(), fieldstart, list.Count() + 1);
for (i = 0; i < nfields; i++) {
const FIELD& field = fields[i];
if (i) errors.printf(", ");
errors.printf("'%s'", field.name);
}
break;
}
uint_t opstart = i;
const char *str = line.str() + i;
bool isassign = fieldptr->assignable;
uint_t j;
uint_t opindex = 0, opcode = Operator_EQ;
for (j = 0; j < NUMBEROF(operators); j++) {
if (((isassign == operators[j].assign) ||
(isassign && !operators[j].assign)) &&
(operators[j].fieldtypes & (1U << fieldptr->type)) &&
(strncmp(str, operators[j].str, operators[j].len) == 0)) {
i += operators[j].len;
opindex = j;
opcode = operators[j].opcode;
break;
}
}
while (IsWhiteSpace(line[i])) i++;
AString value;
bool implicitvalue = false;
if (j == NUMBEROF(operators)) {
if (!line[i] || IsSymbolStart(line[i])) {
if (fieldptr->assignable) {
switch (fieldptr->type) {
case FieldType_string:
break;
case FieldType_date:
value = "now";
break;
default:
value = "1";
break;
}
opcode = Operator_Assign;
}
else opcode = Operator_NE;
for (j = 0; j < NUMBEROF(operators); j++) {
if ((opcode == operators[j].opcode) &&
((isassign == operators[j].assign) ||
(isassign && !operators[j].assign)) &&
(operators[j].fieldtypes & (1U << fieldptr->type))) {
opindex = j;
break;
}
}
implicitvalue = true;
}
else {
errors.printf("Symbols at %u do not represent a legal operator (term %u), legal operators for the field '%s' are: ", opstart, list.Count() + 1, field.str());
bool flag = false;
for (j = 0; j < NUMBEROF(operators); j++) {
if (((isassign == operators[j].assign) ||
(isassign && !operators[j].assign)) &&
(operators[j].fieldtypes & (1U << fieldptr->type))) {
if (flag) errors.printf(", ");
errors.printf("'%s'", operators[j].str);
flag = true;
}
}
break;
}
}
if (!implicitvalue) {
char quote = 0;
if (IsQuoteChar(line[i])) quote = line[i++];
uint_t valuestart = i;
while (line[i] && ((!quote && !IsWhiteSpace(line[i])) || (quote && (line[i] != quote)))) {
if (line[i] == '\\') i++;
i++;
}
value = line.Mid(valuestart, i - valuestart).DeEscapify();
if (quote && (line[i] == quote)) i++;
while (IsWhiteSpace(line[i])) i++;
}
bool orflag = false;
if ((line.Mid(i, 2).ToLower() == "or") && IsWhiteSpace(line[i + 2])) {
orflag = true;
i += 2;
while (IsWhiteSpace(line[i])) i++;
}
else if ((line[i] == '|') && IsWhiteSpace(line[i + 1])) {
orflag = true;
i += 1;
while (IsWhiteSpace(line[i])) i++;
}
if ((term = new TERM) != NULL) {
term->data.start = fieldstart;
term->data.length = i - fieldstart;
term->data.field = fieldptr - ADVBProg::fields;
term->data.opcode = opcode;
term->data.opindex = opindex;
term->data.value = value;
term->data.orflag = (orflag && !RANGE(opcode, Operator_First_Assignable, Operator_Last_Assignable));
term->field = fieldptr;
term->datetype = DateType_none;
switch (term->field->type) {
case FieldType_string:
#if DVBDATVERSION > 1
if (fieldptr->offset == ADVBProg::GetTagsDataOffset()) {
value = "|" + value + "|";
}
#endif
if ((opcode & ~Operator_Inverted) == Operator_Regex) {
AString regexerrors;
AString rvalue;
rvalue = ParseRegex(value, regexerrors);
if (regexerrors.Valid()) {
errors.printf("Regex error in value '%s' (term %u): %s", value.str(), list.Count() + 1, regexerrors.str());
}
value = rvalue;
}
term->value.str = value.Steal();
break;
case FieldType_date: {
ADateTime dt;
uint_t specified;
dt.StrToDate(value, ADateTime::Time_Relative_Local, &specified);
//debug("Value '%s', specified %u\n", value.str(), specified);
if (!specified) {
errors.printf("Failed to parse date '%s' (term %u)", value.str(), list.Count() + 1);
break;
}
else if (((specified == ADateTime::Specified_Day) && (stricmp(term->field->name, "on") == 0)) ||
(stricmp(term->field->name, "day") == 0)) {
//debug("Date from '%s' is '%s' (week day only)\n", value.str(), dt.DateToStr().str());
term->value.u64 = dt.GetWeekDay();
term->datetype = DateType_weekday;
}
else if (specified & ADateTime::Specified_Day) {
specified |= ADateTime::Specified_Date;
}
if (term->datetype == DateType_none) {
specified &= ADateTime::Specified_Date | ADateTime::Specified_Time;
if (specified == (ADateTime::Specified_Date | ADateTime::Specified_Time)) {
//debug("Date from '%s' is '%s' (full date and time)\n", value.str(), dt.DateToStr().str());
term->value.u64 = (uint64_t)dt;
term->datetype = DateType_fulldate;
}
else if (specified == ADateTime::Specified_Date) {
//debug("Date from '%s' is '%s' (date only)\n", value.str(), dt.DateToStr().str());
term->value.u64 = dt.GetDays();
term->datetype = DateType_date;
}
else if (specified == ADateTime::Specified_Time) {
//debug("Date from '%s' is '%s' (time only)\n", value.str(), dt.DateToStr().str());
term->value.u64 = dt.GetMS();
term->datetype = DateType_time;
}
else {
errors.printf("Unknown date specifier '%s' (term %u)", value.str(), list.Count() + 1);
}
}
break;
}
case FieldType_span:
case FieldType_age: {
ADateTime dt;
//ADateTime::EnableDebugStrToDate(true);
term->value.u64 = (uint64_t)ADateTime(value, ADateTime::Time_Absolute);
//ADateTime::EnableDebugStrToDate(false);
break;
}
case FieldType_uint32_t:
case FieldType_external_uint32_t:
term->value.u32 = (uint32_t)value;
break;
case FieldType_sint32_t:
case FieldType_external_sint32_t:
term->value.s32 = (sint32_t)value;
break;
case FieldType_uint16_t:
term->value.u16 = (uint16_t)value;
break;
case FieldType_sint16_t:
term->value.s16 = (sint16_t)value;
break;
case FieldType_uint8_t:
term->value.u8 = (uint8_t)(uint16_t)value;
break;
case FieldType_sint8_t:
term->value.s8 = (sint8_t)(sint16_t)value;
break;
case FieldType_flag...FieldType_lastflag:
term->value.u8 = ((uint32_t)value != 0);
//debug("Setting test of flag to %u\n", (uint_t)term->value.u8);
break;
case FieldType_prog: {
ADVBProg *prog;
if ((prog = new ADVBProg) != NULL) {
if (prog->Base64Decode(value)) {
term->value.prog = prog;
}
else {
errors.printf("Failed to decode base64 programme ('%s') for %s at %u (term %u)", value.str(), field.str(), fieldstart, list.Count() + 1);
delete prog;
}
}
else {
errors.printf("Failed to allocate memory for base64 programme ('%s') for %s at %u (term %u)", value.str(), field.str(), fieldstart, list.Count() + 1);
}
break;
}
default:
errors.printf("Unknown field '%s' type (%u) (term %u)", field.str(), (uint_t)term->field->type, list.Count() + 1);
break;
}
//debug("term: field {name '%s', type %u, assignable %u, offset %u} type %u dateflags %u value '%s'\n", term->field->name, (uint_t)term->field->type, (uint_t)term->field->assignable, term->field->offset, (uint_t)term->data.opcode, (uint_t)term->dateflags, term->value.str);
if (errors.Empty()) {
pattern.scorebased |= (term->field->offset == ADVBProg::GetScoreDataOffset());
list.Add((uptr_t)term);
}
else {
__DeleteTerm((uptr_t)term, NULL);
break;
}
}
}
}
void VTextState::Paint(VGraphicsInfo *pGraphics, VWindowBase *pParentWnd, VColorRef iColor)
{
const char *szText = GetText();
if (!m_spFont || !szText || !szText[0])
return;
VRectanglef vParentRect = pParentWnd->GetClientRect(); // clipping box of parent control
if(!m_bCachedLinesValid)
{
m_lines.Reset();
m_lineOffsets.Reset();
float fLineHeight = m_spFont->GetFontHeight() * m_fRelativeFontHeight * m_fFontScaling;
if(!m_bTextWrap)
{
const char* szCurrentLine = szText;
for (const char* szPtr = szCurrentLine; *szPtr != '\0'; ++szPtr)
{
if (*szPtr == '\n')
{
VStaticString<512> line;
line.Set(szCurrentLine, szPtr - szCurrentLine);
m_lines.Add(line.AsChar());
szCurrentLine = szPtr + 1;
}
}
// Add the last line
if(*szCurrentLine)
{
m_lines.Add(szCurrentLine);
}
}
else
{
float fMaxLineWidth = vParentRect.GetSizeX() / m_fFontScaling;
// Wrap text into individual lines
{
const char *szCurrentLine = szText;
while (*szCurrentLine)
{
// byte offsets
int iByteOffsetAtWrapPosition;
int iByteOffsetAfterWrapPosition;
// search for next newline
const char *pNextNewLine = strchr(szCurrentLine, '\n');
// compute automatic wrap character index
int iCharCount = m_spFont->GetCharacterIndexAtPos(szCurrentLine, fMaxLineWidth, -1, false);
int iWrapOffset = VString::GetUTF8CharacterOffset(szCurrentLine, iCharCount);
if (pNextNewLine != NULL && (pNextNewLine - szCurrentLine) <= iWrapOffset)
{
// newline occurs before automatic text wrap
iByteOffsetAtWrapPosition = static_cast<int>(pNextNewLine - szCurrentLine);
iByteOffsetAfterWrapPosition = iByteOffsetAtWrapPosition + 1;
}
else if(strlen(szCurrentLine) <= iWrapOffset)
{
// End of text occurs before automatic text wrap
iByteOffsetAtWrapPosition = strlen(szCurrentLine);
iByteOffsetAfterWrapPosition = iByteOffsetAtWrapPosition;
}
else
{
// automatic text wrap
iByteOffsetAtWrapPosition = iWrapOffset;
if (iByteOffsetAtWrapPosition > 0)
{
// Go backwards and try to find white space
while (iByteOffsetAtWrapPosition > 0 && !IsWhiteSpace(szCurrentLine[iByteOffsetAtWrapPosition]))
{
iByteOffsetAtWrapPosition--;
}
// no whitespace found? then wrap inside word
if (iByteOffsetAtWrapPosition == 0)
{
iByteOffsetAtWrapPosition = iWrapOffset;
}
else
{
// Find end of next word
int iEndOfWord = iByteOffsetAtWrapPosition + 1;
while(szCurrentLine[iEndOfWord] && !IsWhiteSpace(szCurrentLine[iEndOfWord]))
{
iEndOfWord++;
}
// If the word does not fit into a line by itself, it will be wrapped anyway, so wrap it early to avoid ragged looking line endings
VRectanglef nextWordSize;
m_spFont->GetTextDimension(szCurrentLine + iByteOffsetAtWrapPosition, nextWordSize, iEndOfWord - iByteOffsetAtWrapPosition);
if(nextWordSize.GetSizeX() > fMaxLineWidth)
{
iByteOffsetAtWrapPosition = iWrapOffset;
}
}
}
else
{
// First character is already wider than the line
iByteOffsetAtWrapPosition = VString::GetUTF8CharacterOffset(szCurrentLine, 1);
}
iByteOffsetAfterWrapPosition = iByteOffsetAtWrapPosition;
}
// put together line
VStaticString<512> line;
line.Set(szCurrentLine, iByteOffsetAtWrapPosition);
m_lines.Add(line.AsChar());
szCurrentLine = &szCurrentLine[iByteOffsetAfterWrapPosition];
while(*szCurrentLine == ' ')
szCurrentLine++;
}
}
}
// Compute offset for each line
for(int iLineIdx = 0; iLineIdx < m_lines.GetLength(); iLineIdx++)
{
hkvVec2 offset = m_vOffset;
offset.x += m_spFont->GetTextPositionOfs(m_lines[iLineIdx], vParentRect.GetSize(), m_hAlign, m_vAlign, m_fFontScaling).x;
offset.y += iLineIdx * fLineHeight;
if (m_vAlign == VisFont_cl::ALIGN_CENTER)
{
offset.y += (vParentRect.GetSizeY() - fLineHeight * m_lines.GetSize()) * 0.5f;
}
else if (m_vAlign == VisFont_cl::ALIGN_BOTTOM)
{
offset.y += (vParentRect.GetSizeY() - fLineHeight * m_lines.GetSize());
}
m_lineOffsets.Add(offset);
}
m_bCachedLinesValid = true;
}
// Render lines
if (pGraphics)
{
VSimpleRenderState_t state = VGUIManager::DefaultGUIRenderState();
if (m_fFontScaling!=1.0f)
state.SetFlag(RENDERSTATEFLAG_FILTERING);
for(int iLineIdx = 0; iLineIdx < m_lines.GetLength(); iLineIdx++)
{
m_spFont->PrintText(&pGraphics->Renderer, vParentRect.m_vMin + m_lineOffsets[iLineIdx], m_lines[iLineIdx], iColor, state,
m_fFontScaling, m_pCustomBBox ? m_pCustomBBox : &vParentRect);
}
}
}
//------------------------------------------------------------------------------
// Parse a number (integer or real).
tokentype Parser::ParseNumber ()
{
enum {
start = 0x0001, // 0
sign = 0x0002, // 1
digit = 0x0004, // 2
fraction = 0x0008, // 3
expsymbol = 0x0010, // 4
expsign = 0x0020, // 5
exponent = 0x0040, // 6
bad = 0x0080,
done = 0x0100
} state;
tokentype result = BAD;
token = "";
state = start;
char curChar = text[pos];
while (!IsWhiteSpace (curChar)
&& !(IsPunctuation (curChar) && (curChar != '-'))
&& (state != bad)
&& (state != done))
{
if (isdigit (curChar))
{
switch (state)
{
case start:
case sign:
state = digit;
break;
case expsymbol:
case expsign:
state = exponent;
break;
default:
break;
}
}
else if ((curChar == '-') || (curChar == '+'))
{
switch (state)
{
case start:
state = sign; // sign of number
break;
case digit:
state = done; // minus sign is punctuation, such as 6-10
break;
case expsymbol:
state = expsign; // sign of exponent
break;
default:
state = bad; // syntax error
break;
}
}
else if ((curChar == '.') && (state == digit))
state = fraction;
else if (((curChar == 'E') || (curChar == 'e')) && (state & (digit | fraction)))
state = expsymbol;
else
state = bad;
if ((state != bad) && (state != done))
{
token += curChar;
curChar = GetNextChar ();
}
}
int isNumber = state & (digit | fraction | exponent | done);
if (isNumber)
{
// We have a number
result = NUMBER;
if (IsPunctuation (curChar))
{
// PutBack (curChar);
// if (!atEOL)
// filecol--;
}
}
else
{
// Not a number, but a string that starts with numbers, such as "00BW0762.1"
// cout << "Do something!" << endl;
do {
if (curChar == '_')
token += ' ';
else
token += curChar;
curChar = GetNextChar ();
} while (isalnum (curChar) || (curChar == '_') || (curChar == '.') && (pos < text.length()));
result = STRING; //classify the token
}
return result;
}
char * InPlaceParser::SkipSpaces(char *foo)
{
while ( !EOS(*foo) && IsWhiteSpace(*foo) ) foo++;
return foo;
}
bool TextAreaTextRange::CheckEndPointIsUnitEndpoint(_In_ EndPoint check, _In_ TextUnit unit, _In_ TEXTATTRIBUTEID specificAttribute)
{
if (unit == TextUnit_Character)
{
return true;
}
EndPoint next;
EndPoint prev;
if (!_control->StepCharacter(check, true, &next) ||
!_control->StepCharacter(check, false, &prev))
{
// If we're at the beginning or end, we're at an endpoint
return true;
}
else if (unit == TextUnit_Word)
{
if (IsWhiteSpace(prev) && !IsWhiteSpace(check))
{
return true;
}
return false;
}
else if (unit == TextUnit_Line || unit == TextUnit_Paragraph)
{
return check.line != next.line;
}
// TextUnit_Page and TextUnit_Document are covered by the initial beginning/end check
else if (unit == TextUnit_Page || unit == TextUnit_Document)
{
return false;
}
else if (unit == TextUnit_Format)
{
bool matching = true;
bool checkedLineBoundary = false;
// There are limited attributes that vary in this control
// If its not one of those attributes, then it is not an Endpoint
// unless it's the document start or end, which is checked above
for (int i = 0; i < ARRAYSIZE(lineVariableAttributes); i++)
{
if (specificAttribute == 0 || specificAttribute == lineVariableAttributes[i])
{
if (!checkedLineBoundary)
{
if (!CheckEndPointIsUnitEndpoint(check, TextUnit_Paragraph, 0))
{
break;
}
checkedLineBoundary = true;
}
VARIANT varC = _control->GetAttributeAtPoint(check, lineVariableAttributes[i]);
VARIANT varN = _control->GetAttributeAtPoint(next, lineVariableAttributes[i]);
HRESULT hr = VarCmp(&varC, &varN, LOCALE_NEUTRAL);
VariantClear(&varC);
VariantClear(&varN);
if (hr != VARCMP_EQ)
{
matching = false;
break;
}
}
}
for (int i = 0; i < ARRAYSIZE(charVariableAttributes); i++)
{
if (specificAttribute == 0 || specificAttribute == charVariableAttributes[i])
{
int *annotationIds;
int annotationCount;
if (GetAnnotationsAtPoint(check, &annotationIds, &annotationCount))
{
int *prevAnnotationIds;
int prevAnnotationCount;
if (GetAnnotationsAtPoint(prev, &prevAnnotationIds, &prevAnnotationCount))
{
if (annotationCount != prevAnnotationCount)
{
matching = false;
}
// Since all our annotations are the same type, if the number matches,
// then the UIA_AnnotationTypesAttributeId all match
else if (charVariableAttributes[i] == UIA_AnnotationObjectsAttributeId)
{
for (int j = 0; j < annotationCount; j++)
{
if (annotationIds[j] != prevAnnotationIds[j])
{
matching = false;
}
}
}
delete [] prevAnnotationIds;
}
delete [] annotationIds;
}
}
}
return !matching;
}
return false;
}
bool InPlaceParser::IsNonSeparator(char c)
{
if ( !IsHard(c) && !IsWhiteSpace(c) && c != 0 ) return true;
return false;
}
bool DTextParser::SearchWordInBlock( lpctstr t_pWord, DTextBlock& Block )
{
if( !m_pBuffer || t_pWord==NULL || t_pWord[0]==0 ) return false;
//if( bFromStart )
{
m_lBufPosition = Block.Start();
}
SString strTemp = t_pWord;
int iSrcPos=0;
int iSrcSize = strTemp.Len();
int iReadWordMode = 0;
long BufEnd = Block.End();
while( m_lBufPosition <= BufEnd )
{
// 한줄주석처리 ';'가 나오면 리턴문자가 올 때까지 모든 문자를Skip한다.
if( m_pBuffer[m_lBufPosition]==';' )
{
// reset state
//iReadWordMode = 0;
//iSrcPos = 0;
// go to the end of line
m_lBufPosition++;
while( m_lBufPosition < BufEnd && m_pBuffer[m_lBufPosition] != '\r' && m_pBuffer[m_lBufPosition] != '\n' )
m_lBufPosition++;
}
if( iReadWordMode==0 )
{// Word에 진입하지 않은 상태
//소스 첫글자와 대상현재위치의 단어가 같다면 WordMode=1
if( t_pWord[0]==m_pBuffer[m_lBufPosition] )
{
iSrcPos = 1;
iReadWordMode = 1;
}
++m_lBufPosition;
}
else if( iReadWordMode==1 )
{// Word에 진입하여 검사중인 상태
// WhiteSpace가 나오거나, 틀리면 Mode=0, 그 외에는 SrcPos를 증가
if( t_pWord[iSrcPos]==m_pBuffer[m_lBufPosition] )
{
++iSrcPos;
}
else if( IsWhiteSpace(m_pBuffer[m_lBufPosition]) )
{// 단어검사중에 단어의 끝을 만났다면 현재까지 검사된 단어의 길이를 보고
//맞는 단어를 찾았는지 검사한다.
if( iSrcPos>=iSrcSize ) return true;//found!
}
else
{// 그저 틀린 문자를 발견했다면, Mode=0
iReadWordMode = 0;
iSrcPos = 0;
}
++m_lBufPosition;
}
}
return false;
}
const char* TiXmlAttribute::Parse(const char* p, TiXmlParsingData* data, TiXmlEncoding encoding)
{
p = SkipWhiteSpace(p, encoding);
if (!p || !*p) return 0;
int tabsize = 4;
if (document)
tabsize = document->TabSize();
if (data)
{
data->Stamp(p, encoding);
location = data->Cursor();
}
// Read the name, the '=' and the value.
const char* pErr = p;
p = ReadName(p, &name, encoding);
if (!p || !*p)
{
if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding);
return 0;
}
p = SkipWhiteSpace(p, encoding);
if (!p || !*p || *p != '=')
{
if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding);
return 0;
}
++p; // skip '='
p = SkipWhiteSpace(p, encoding);
if (!p || !*p)
{
if (document) document->SetError(TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding);
return 0;
}
const char* end;
if (*p == '\'')
{
++p;
end = "\'";
p = ReadText(p, &value, false, end, false, encoding);
}
else if (*p == '"')
{
++p;
end = "\"";
p = ReadText(p, &value, false, end, false, encoding);
}
else
{
// All attribute values should be in single or double quotes.
// But this is such a common error that the parser will try
// its best, even without them.
value = "";
while ( p && *p // existence
&& !IsWhiteSpace(*p) && *p != '\n' && *p != '\r' // whitespace
&& *p != '/' && *p != '>') // tag end
{
value += *p;
++p;
}
}
return p;
}
// buf Get Word
// 한 단어. 마치 fscanf같은 역할을 버퍼내에서 하고
// 버퍼 포인팅을 자동으로 이동한다.
// state 0 : init W/S elimination
// state 1 : normal copy mode
// state 2 : "..." copy mode
int DTextParser::GetWord( char *t_pWord, int t_iNumber )
{
int state = 0, i = 0;
if( !m_pBuffer || m_lBufPosition>=m_lBufSize ) return -1;
while( m_lBufPosition < m_lBufSize ) {
/* // 주석처리
if( m_pBuffer[m_lBufPosition]=='/' && m_pBuffer[m_lBufPosition]=='*' ) {
m_lBufPosition++;
while( m_lBufPosition < m_lBufSize && m_pBuffer[m_lBufPosition] != '\r' && m_pBuffer[m_lBufPosition] != '\n' &&
m_pBuffer[m_lBufPosition] != '#' )
m_lBufPosition++;
}
*/
// 한줄주석처리 ';'가 나오면 리턴문자가 올 때까지 모든 문자를Skip한다.
if( m_pBuffer[m_lBufPosition]==';' )
{
m_lBufPosition++;
while( m_lBufPosition < m_lBufSize && m_pBuffer[m_lBufPosition] != '\r' && m_pBuffer[m_lBufPosition] != '\n' )
m_lBufPosition++;
}
// 단어읽기에 들어가고 W/S일 경우
if( state == 1 && IsWhiteSpace(m_pBuffer[m_lBufPosition])) {
t_iNumber--;
state = 0;
if( t_iNumber < 1 ) {
t_pWord[i++] = 0;
m_lBufPosition++;
return 1;
} else {
t_pWord[i++] = ' ';
}
// ".."를 읽고 있으며 Space가 아닌 W/S나 "가 나타났을 때
} else if( state == 2 &&( m_pBuffer[m_lBufPosition]=='\"' || m_pBuffer[m_lBufPosition]=='\r' || m_pBuffer[m_lBufPosition]=='\n')) {
// "..."
t_iNumber--;
state = 0;
if( t_iNumber < 1 ) {
t_pWord[i++] = 0;
m_lBufPosition++;
return 1;
} else {
t_pWord[i++] = ' ';
}
}
// 보통 문자를 넣고 있는 중일때.. (".."든 보통이든..)
if( state == 2 || !IsWhiteSpace(m_pBuffer[m_lBufPosition]) ) {
if(state == 0 )
state = 1;
t_pWord[i++] = m_pBuffer[m_lBufPosition];
if( i-1 == 0 && t_pWord[0]=='\"' ) {
i--;
state = 2;
}
}
m_lBufPosition++;
}
t_pWord[i] = 0;
return 1;
}
bool TiXmlText::Blank() const {
for ( unsigned i=0; i<value.length(); i++ )
if ( !IsWhiteSpace( value[i] ) )
return false;
return true;
}
void conv(RR& x, const char *s)
{
long c;
long cval;
long sign;
ZZ a, b;
long i = 0;
if (!s) Error("bad RR input");
c = s[i];
while (IsWhiteSpace(c)) {
i++;
c = s[i];
}
if (c == '-') {
sign = -1;
i++;
c = s[i];
}
else
sign = 1;
long got1 = 0;
long got_dot = 0;
long got2 = 0;
a = 0;
b = 1;
cval = CharToIntVal(c);
if (cval >= 0 && cval <= 9) {
got1 = 1;
while (cval >= 0 && cval <= 9) {
mul(a, a, 10);
add(a, a, cval);
i++;
c = s[i];
cval = CharToIntVal(c);
}
}
if (c == '.') {
got_dot = 1;
i++;
c = s[i];
cval = CharToIntVal(c);
if (cval >= 0 && cval <= 9) {
got2 = 1;
while (cval >= 0 && cval <= 9) {
mul(a, a, 10);
add(a, a, cval);
mul(b, b, 10);
i++;
c = s[i];
cval = CharToIntVal(c);
}
}
}
if (got_dot && !got1 && !got2) Error("bad RR input");
ZZ e;
long got_e = 0;
long e_sign;
if (c == 'e' || c == 'E') {
got_e = 1;
i++;
c = s[i];
if (c == '-') {
e_sign = -1;
i++;
c = s[i];
}
else if (c == '+') {
e_sign = 1;
i++;
c = s[i];
}
else
e_sign = 1;
cval = CharToIntVal(c);
if (cval < 0 || cval > 9) Error("bad RR input");
e = 0;
while (cval >= 0 && cval <= 9) {
mul(e, e, 10);
add(e, e, cval);
i++;
c = s[i];
cval = CharToIntVal(c);
}
}
if (!got1 && !got2 && !got_e) Error("bad RR input");
RR t1, t2, v;
long old_p = RR::precision();
if (got1 || got2) {
ConvPrec(t1, a, max(NumBits(a), 1));
ConvPrec(t2, b, NumBits(b));
if (got_e)
RR::SetPrecision(old_p + 10);
div(v, t1, t2);
}
else
set(v);
if (sign < 0)
negate(v, v);
if (got_e) {
if (e >= NTL_OVFBND) Error("RR input overflow");
long E;
conv(E, e);
if (e_sign < 0) E = -E;
RR::SetPrecision(old_p + 10);
power(t1, to_RR(10), E);
mul(v, v, t1);
RR::prec = old_p;
}
xcopy(x, v);
}
const char* TiXmlBase::ReadText( const char* p,
TIXML_STRING * text,
bool trimWhiteSpace,
const char* endTag,
bool caseInsensitive,
TiXmlEncoding encoding )
{
*text = "";
if ( !trimWhiteSpace // certain tags always keep whitespace
|| !condenseWhiteSpace ) // if true, whitespace is always kept
{
// Keep all the white space.
while ( p && *p
&& !StringEqual( p, endTag, caseInsensitive, encoding )
)
{
int len;
char cArr[4] = { 0, 0, 0, 0 };
p = GetChar( p, cArr, &len, encoding );
text->append( cArr, len );
}
}
else
{
bool whitespace = false;
// Remove leading white space:
p = SkipWhiteSpace( p, encoding );
while ( p && *p
&& !StringEqual( p, endTag, caseInsensitive, encoding ) )
{
if ( *p == '\r' || *p == '\n' )
{
whitespace = true;
++p;
}
else if ( IsWhiteSpace( *p ) )
{
whitespace = true;
++p;
}
else
{
// If we've found whitespace, add it before the
// new character. Any whitespace just becomes a space.
if ( whitespace )
{
(*text) += ' ';
whitespace = false;
}
int len;
char cArr[4] = { 0, 0, 0, 0 };
p = GetChar( p, cArr, &len, encoding );
if ( len == 1 )
(*text) += cArr[0]; // more efficient
else
text->append( cArr, len );
}
}
}
if ( p )
p += strlen( endTag );
return p;
}
/*
* CRchTxtPtr::ChangeCase(cch, Type, publdr)
*
* @mfunc
* Change case of cch chars starting at this text ptr according to Type,
* which has the possible values:
*
* tomSentenceCase = 0: capitalize first letter of each sentence
* tomLowerCase = 1: change all letters to lower case
* tomUpperCase = 2: change all letters to upper case
* tomTitleCase = 3: capitalize the first letter of each word
* tomToggleCase = 4: toggle the case of each letter
*
* @rdesc
* TRUE iff a change occurred
*
* @devnote
* Since this routine only changes the case of characters, it has no
* effect on rich-text formatting. However it is part of the CRchTxtPtr
* class in order to notify the display of changes. CTxtRanges are also
* notified just in case the text blocks are modified.
*/
BOOL CRchTxtPtr::ChangeCase (
LONG cch, //@parm # chars to change case for
LONG Type, //@parm Type of change case command
IUndoBuilder *publdr) //@parm UndoBuilder to receive anti-event
// for any replacements
{
TRACEBEGIN(TRCSUBSYSBACK, TRCSCOPEINTERN, "CRchTxtPtr::ChangeCase");
_TEST_INVARIANT_
#define BUFFERLEN 256
LONG cchChunk, cchFirst, cchGet, cchLast;
BOOL fAlpha, fToUpper, fUpper; // Flags controling case change
BOOL fChange = FALSE; // No change yet
BOOL fStart = TRUE; // Start of Word/Sentence
TCHAR * pch; // Ptr to walk rgCh with
WORD * pType; // Ptr to walk rgType with
TCHAR rgCh[BUFFERLEN]; // Char buffer to work in
WORD rgType[BUFFERLEN]; // C1_TYPE array for rgCh
if( GetCp() )
{
if( Type == tomSentenceCase )
{
fStart = _rpTX.IsAtBOSentence();
}
else if( Type == tomTitleCase )
{
// check to see if we are at the beginning of
// a word. This is the case if the character preceeding
// our current position is white space.
fStart = IsWhiteSpace(_rpTX.PrevChar());
_rpTX.AdvanceCp(1);
}
}
while(cch > 0) // Do 'em all (or as many as
{ // in story)
cchChunk = min(BUFFERLEN, cch); // Get next bufferful
cch -= cchChunk; // Decrement the count
cchGet = _rpTX.GetText(cchChunk, rgCh); // Manipulate chars in buffer
if(cchGet < cchChunk) // (for undo, need to use
{ // ReplaceRange())
cch = 0; // No more chars in story,
if(!cchGet) // so we'll be done
break; // We're done already
cchChunk = cchGet; // Something in this chunk
}
GetStringTypeEx(0, CT_CTYPE1, rgCh, // Find out whether chars are
cchChunk, rgType); // UC, LC, or neither
cchLast = 0; // Default nothing to replace
cchFirst = -1;
for(pch = rgCh, pType = rgType; // Process buffered chars
cchChunk;
cchChunk--, pch++, pType++)
{
fAlpha = *pType & (C1_UPPER | C1_LOWER); // Nonzero if UC or LC
fUpper = (*pType & C1_UPPER) != 0; // TRUE if UC
fToUpper = fStart ? TRUE : fUpper; // capitalize first letter of a
// sentence
switch(Type)
{ // Decide whether to change
case tomLowerCase: // case and determine start
fToUpper = FALSE; // of word/sentence for title
break; // and sentence cases
case tomUpperCase:
fToUpper = TRUE;
break;
case tomToggleCase:
fToUpper = !fUpper;
break;
case tomSentenceCase:
if(*pch == TEXT('.')) // If sentence terminator,
fStart = TRUE; // capitalize next alpha
if(fAlpha) // If this char is alpha, next
fStart = FALSE; // char can't start a
break; // sentence
case tomTitleCase: // If this char is alpha, next
fStart = (fAlpha == 0); // char can't start a word
break;
default:
return FALSE;
}
if(fAlpha && (fToUpper ^ fUpper)) // Only change case if it
{ // makes a difference (saves
if(fToUpper) // on system calls and undos)
CharUpperBuff(pch, 1);
else
CharLowerBuff(pch, 1);
fChange = TRUE; // Return value: change made
if( cchFirst == -1 ) // Save cch of unchanged
cchFirst = cchGet-cchChunk; // leading string
cchLast = cchChunk - 1; // Save cch of unchanged
} // trailing string
}
if( cchFirst == -1 )
{
Assert(cchLast == 0);
cchFirst = cchGet;
}
Advance(cchFirst); // Skip unchanged leading
cchGet -= cchFirst + cchLast; // string. cchGet = cch of
ReplaceRange(cchGet, cchGet, rgCh // changed span
+ cchFirst, publdr, tomUndefined);
Advance(cchLast); // Skip unchanged trailing
} // string
return fChange;
}
const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
{
p = SkipWhiteSpace( p, encoding );
if ( !p || !*p ) return 0;
if ( data )
{
data->Stamp( p, encoding );
location = data->Cursor();
}
// Read the name, the '=' and the value.
const char* pErr = p;
p = ReadName( p, &name, encoding );
if ( !p || !*p )
{
if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding );
return 0;
}
p = SkipWhiteSpace( p, encoding );
if ( !p || !*p || *p != '=' )
{
if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );
return 0;
}
++p; // skip '='
p = SkipWhiteSpace( p, encoding );
if ( !p || !*p )
{
if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );
return 0;
}
const char* end;
const char SINGLE_QUOTE = '\'';
const char DOUBLE_QUOTE = '\"';
if ( *p == SINGLE_QUOTE )
{
++p;
end = "\'"; // single quote in string
p = ReadText( p, &value, false, end, false, encoding );
}
else if ( *p == DOUBLE_QUOTE )
{
++p;
end = "\""; // double quote in string
p = ReadText( p, &value, false, end, false, encoding );
}
else
{
// All attribute values should be in single or double quotes.
// But this is such a common error that the parser will try
// its best, even without them.
value = "";
while ( p && *p // existence
&& !IsWhiteSpace( *p ) && *p != '\n' && *p != '\r' // whitespace
&& *p != '/' && *p != '>' ) // tag end
{
if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) {
// [ 1451649 ] Attribute values with trailing quotes not handled correctly
// We did not have an opening quote but seem to have a
// closing one. Give up and throw an error.
if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );
return 0;
}
value += *p;
++p;
}
}
return p;
}
/*--------------------------------------------------------------------------------------*/
int p3parseline(char *line, char **argv)
{
char *bptr; /* Pointer into the buffer buf */
char *tptr; /* Temp pointer */
int intoken; /* Are we in the middle of reading a token in? */
int argc; /* Number of args */
int bg; /* Background job? */
if ((strlen(line)*2) > MAXLINE) {
HandleError("Line too long for p3parseline\n");
}
argc = 0;
intoken = 0;
/* Copy line into buf character-by-character to create the argv strings */
bptr = buf;
tptr = line;
while (*tptr != '\n') {
if (IsWhiteSpace(*tptr)) {
*bptr++ = '\0'; /* insert \0 to terminate current token */
intoken = 0;
}
else if (IsSpecialChar(*tptr)) { /* stand-alone token -- add room for \0 */
if (intoken) {
*bptr++ = '\0';
intoken = 0;
}
argv[argc++] = bptr;
*bptr++ = *tptr;
*bptr++ = '\0';
}
else if (*tptr == '"') { /* starting a string -- copy until matching \" */
if (intoken) {
*bptr++ = '\0';
intoken = 0;
}
argv[argc++] = bptr;
tptr++;
while ((*tptr != '\"') && (*tptr != '\0')) *bptr++ = *tptr++;
if (*tptr == '\0') {
HandleError("String not terminated -- missing double quote\n");
}
else {
*bptr++ = '\0';
}
}
else { /* non-special character */
if (intoken) *bptr++ = *tptr;
else {
intoken = 1;
argv[argc++] = bptr;
*bptr++ = *tptr;
}
}
tptr++; /* move to the next character */
}
*bptr = '\0'; /* terminate the last token */
argv[argc] = NULL;
if (argc == 0) /* Ignore blank line */
return 1;
/* Should the job run in the background? */
if ((bg = (*argv[argc-1] == '&')) != 0)
argv[--argc] = NULL;
#ifdef P3PARSELINE_DEBUG
int i;
for (i = 0; i < argc; i++) printf("argv[%d] = '%s'\n", i, argv[i]);
#endif
return bg;
}