CCLexFile Class Reference

#include <ccfile.h>

Inheritance diagram for CCLexFile:

List of all members.

Public Member Functions
	CCLexFile (BOOL ErrorReporting=TRUE, BOOL ExceptionThrowing=FALSE)
	Initialise a CCLexFile object.
	~CCLexFile ()
	Deinitialises a CCLexFile object (calls DeinitLexer() for you).
BOOL	InitLexer (BOOL IsSeekingRequired=FALSE, BOOL DoIgnoreStringEscapeCodes=FALSE)
	Prepare the file object for performing lexical analysis on the input stream. This allocates the buffers and sets the various character sets to the default values: Whitespace: spaces and tabs Delimiters: none Comment: # String: Delimited by " and " (i.e. like C) Also resets the newline indent output used by PutNewLine() to 0;.
void	DeinitLexer ()
	Frees up the dynamic objects allocated by CCLexFile::InitLexer. Can be called at any point, and should be called before the next call to InitLexer(), even if the last InitLexer() call has failed.
void	SetWhitespace (char *)
	This function changes the set of characters that the lexical analyser treats as white space. Note that it defaults to tabs and spaces, but you can specify any set of characters you want - for example you could even pass in " tf" and it would treat spaces, lower case t's and lower case f's as whitespace characters. Tokens extracted by CCLexFile::GetToken never contain any whitespace characters.
void	SetDelimiters (char *)
	Change the set of characters that are treated as 'delimiters'. A delimiter character indicates that a token has finished. A delimiter character *will* be extracted by CCLexFile::GetToken, and returned on its own. For example, for the line "hello; there ();", processed with the set of delimiters ";()", you would get the following tokens out of CCLexFile::GetToken: MonoOn "hello" ";" "there" "(" ")" ";" MonoOff.
void	SetCommentMarker (char)
	Change the character used to denote a comment token. Comments start from the comment character until the end of the line. So, for example, to set the lexer up for PostScript style comments, pass in '' as the comment marker; for assembler style comments, pass in ';'. Multi-line comments are not supported.
void	SetStringDelimiters (char *)
	Change the characters used to delimit a string. The lexer will handle strings as a special token type (see CCLexFile::GetToken). You can specify which characters delimit the strings - you pass in a two-character string; the first character is used to start the string,and the second is used to terminate it. The two characters can be the same. So, for example, for PostScript strings, use "()", or for C-style strings, use "\"\"".
BOOL	GetToken ()
	Extract the next lexical token from the input stream of this file. Tokens are separated by whitespace, delimiters, line-breaks, or any combination of the three. Delimiters and line-breaks are returned as tokens (and may be ignored if desired); whitespace is never returned. Call CCLexFile::GetTokenType() to find out what kind of token was extracted. You can examine the token directly by looking at the buffer returned by CCLexFile::GetTokenBuf() (this is a const buffer so you may examine it, but not alter it). This buffer address will not change unless CCLexFile::InitLexer is called again, so it is safe to cache the return value of CCLexFile::GetTokenBuf.
BOOL	GetHexToken ()
	Extract the next lexical token from the input stream of this file. The token is expected to be a string of hexadecimal digits, and its length should be an even number of characters. If whitespace or a delimiter is encountered then the token is returned ok. If any other character is found which is not a legal hex digit thenFALSE is returned.
BOOL	GetSimpleToken ()
	A simplified interface onto GetToken(). The caller is not informed of token types TOKEN_COMMENT and TOKEN_EOL. The function returns TRUE if a TOKEN_NORMAL or TOKEN_STRING is read. FALSE is returned if TOKEN_EOF is read, or if FALSE is returned by GetToken().
BOOL	GetLineToken ()
	Read in a token in a line-based manner. If the current input position is in the middle of a line, the data up until the end of the line is read. If at the start of a line, the whole line is returned. The token is still examined to work out what it is, but obviously it may not match any proper construct, in which case the type of the token is set to TOKEN_LINE. (NB this is the only time that TOKEN_LINE is used).
void	UngetToken ()
	Put the current token back onto the input stream - i.e. the next time GetToken() is called it will return the token it returned last time. This is not nestable - you can only put back one token at once.
UINT32	GetLineNumber ()
UINT32	GetCharOffset ()
virtual INT32	GetCharsRead ()
LexTokenType	GetTokenType ()
const TCHAR *	GetTokenBuf ()
BOOL	IsLexerInitialised ()
BOOL	PutString (const StringBase &str, UINT32 length=0, char *Sep=" ")
	Outputs the string to the file enclosed in the string delimiting chars. (see CCLexFile::SetStringDelimiters for more details) Writes out 'length' chars of str, then finishes off by writing 'Sep' out as a bunch of Sep characters.
BOOL	PutToken (const StringBase &str, UINT32 length=0, char *Sep=" ")
	Outputs the string to the file. Writes out 'length' chars of str, then finishes off by writing 'Sep' out as a bunch of Sep characters.
BOOL	PutToken (const TCHAR *buf, char *Sep=" ")
	Outputs the string to the file. Writes out 'length' chars of str, then finishes off by writing 'Sep' out as a bunch of Sep characters.
BOOL	PutToken (INT32 n, char *Sep=" ")
	Outputs the number to the file. Writes out 'n', then finishes off by writing 'Sep' out as a bunch of Sep characters.
BOOL	PutNewLine ()
	Outputs a new line, followed by a number of spaces. The number of spaces output can be changed using IncIndent() and DecIndent(); InitLexer resets the number of indent spaces to 0.
void	IncIndent ()
	Increases the number of spaces written by PutNewLine() at the start of the next line. It is increased by IndentDelta, which can be altered using SetIndentDelta().
void	DecIndent ()
	Decreases the number of spaces written by PutNewLine() at the start of the next line. It is decreased by IndentDelta, which can be altered using SetIndentDelta().
void	SetIndentDelta (UINT32 d)
void	GetLine ()
	Read in the next line from the file - used when extracted tokens with CCLexFile::GetToken(). Handles the current line count, number of chars read count, etc.
void	GetCh ()
	Gets the next character from the input stream, reading in a new line if necessary.
const TCHAR *	GetLineBuf ()
virtual void	SetDontFail (BOOL state)
BOOL	GetHTMLToken (BOOL fIgnoreEOL=TRUE, BOOL fCorrectCase=TRUE)
	Get the next HTML token from the file.
char *	GetHTMLTokenBuffer ()
BOOL	IsHTMLTag ()
BOOL	IsEndOfHTMLFile ()
String_256	GetHTMLTagName ()
	This function reads the name of the tag in the buffer.
String_256	GetHTMLParameterValue (const String_256 &strParameterName, BOOL fCorrectCase=TRUE)
	Finds the value of the specified parameter.
Protected Member Functions
void	InitHTMLLexer ()
	Initialises all the variables used in the HTML parsing code.
void	DeleteHTMLBuffer ()
	Deletes the HTML buffer and sets all the member variables that refer to it to appropriate defaults.
void	AddToHTMLBuffer (char cToAdd)
	Adds cToAdd to the buffer, extending the buffer if necessary.
char	PeekNextHTMLChar ()
	In theory, this function finds out what the next character that will be read from the file will be.
char	ReadNextHTMLChar ()
	This function reads the next character from the file. Well, actually, the way it works is slightly more complicated.
BOOL	IsWhitespace (char cToTest)
	Tests the character passed to see if it is a white-space character.
PCSTR	FindStringWithoutCase (PCSTR strToSearch, PCSTR strToFind)
	Finds strToFind within strToSearch.
BOOL	IsDelim ()
	Test the current character (as read in by CCLexFile::GetCh) to see if it is a delimiter.
BOOL	IsWhitespace ()
	Test the current character (as read in by CCLexFile::GetCh) to see if it is a white-space character.
BOOL	GetStringToken ()
	Extracts a string token from the input stream, as defined by the currently installed string delimiters.
Protected Attributes
char *	m_pcHTMLBuffer
INT32	m_iCharsInHTMLBuffer
INT32	m_iLengthOfHTMLBuffer
BOOL	m_fIsTag
BOOL	m_fIsCharacterWaiting
char	m_cWaitingCharacter
BOOL	m_fEndOfHTMLFile
BOOL	EOFFound
BOOL	DontFail
BOOL	DelimiterFound
BOOL	TokenIsCached
String_256 *	LineBuf
TCHAR *	Buf
TCHAR *	TokenBuf
LexTokenType	TokenType
UINT32	Line
UINT32	Ofs
char	Ch
INT32	CharsRead
FilePos	LastLinePos
BOOL	SeekingRequired
BOOL	IgnoreStringEscapeCodes
char *	WhitespaceChars
char *	DelimiterChars
char	CommentMarker
char *	StringDelimiters
INT32	IndentSpaces
UINT32	IndentDelta
Private Member Functions
	CC_DECLARE_DYNAMIC (CCLexFile)
Private Attributes
BOOL	LexerInitialised

---

Detailed Description

Definition at line 316 of file ccfile.h.

---

Constructor & Destructor Documentation

CCLexFile::CCLexFile (  BOOL  ErrorReporting = TRUE, BOOL  ExceptionThrowing = FALSE )

Initialise a CCLexFile object. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> (Altered by Neville 01/08/94) Date: 05/04/94 Definition at line 802 of file ccfile.cpp. : CCFile(ErrorReporting, ExceptionThrowing), CharsRead(0) { // Ensure that the buffers are NULL so that DeinitLexer() can be called // safely even if called after a failed InitLexer() call. LineBuf = NULL; Buf = NULL; TokenBuf = NULL; LexerInitialised = FALSE; TokenIsCached = FALSE; SeekingRequired = FALSE; IgnoreStringEscapeCodes = FALSE; DontFail = FALSE; //Graham's HTML parsing variables m_pcHTMLBuffer=NULL; }

CCLexFile::~CCLexFile (   )

Deinitialises a CCLexFile object (calls DeinitLexer() for you). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Definition at line 834 of file ccfile.cpp. { DeinitLexer(); }

---

Member Function Documentation

void CCLexFile::AddToHTMLBuffer (  char  cToAdd  )  [protected]

Adds cToAdd to the buffer, extending the buffer if necessary. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 15/5/97 Parameters: cToAdd  - the character to add to the buffer [INPUTS] Returns: - Errors: - See also: CCLexFile::GetHTMLToken Definition at line 1345 of file ccfile.cpp. { //First, do we have an HTML buffer? if( NULL == m_pcHTMLBuffer ) { //No. So create one now m_iLengthOfHTMLBuffer = TokenBufSize; m_pcHTMLBuffer = (char *)malloc( m_iLengthOfHTMLBuffer ); m_iCharsInHTMLBuffer = 0; } //Now, is there enough room in our HTML buffer to store //our new character? if( m_iCharsInHTMLBuffer >= m_iLengthOfHTMLBuffer ) { //No. So double the size of the buffer m_iLengthOfHTMLBuffer *= 2; m_pcHTMLBuffer = (char *)realloc( m_pcHTMLBuffer, m_iLengthOfHTMLBuffer ); } ERROR3IF(m_pcHTMLBuffer==NULL, "AddToHTMLBUffer - realloc error"); //And finally add our character m_pcHTMLBuffer[m_iCharsInHTMLBuffer] = cToAdd; //And increase the number of characters in the buffer m_iCharsInHTMLBuffer++; }

CCLexFile::CC_DECLARE_DYNAMIC (  CCLexFile   )  [private]

void CCLexFile::DecIndent (   )

Decreases the number of spaces written by PutNewLine() at the start of the next line. It is decreased by IndentDelta, which can be altered using SetIndentDelta(). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Decreases IndentSpaces by IndentDelta. Errors: - See also: - Definition at line 2517 of file ccfile.cpp. { IndentSpaces -= IndentDelta; if (IndentSpaces < 0) IndentSpaces = 0; }

void CCLexFile::DeinitLexer (   )

Frees up the dynamic objects allocated by CCLexFile::InitLexer. Can be called at any point, and should be called before the next call to InitLexer(), even if the last InitLexer() call has failed. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 See also: CCLexFile::InitLexer Definition at line 942 of file ccfile.cpp. { // Deallocate our buffers if (LineBuf != NULL) delete LineBuf; if (TokenBuf != NULL) delete [] TokenBuf; LineBuf = NULL; TokenBuf = NULL; Buf = NULL; DeleteHTMLBuffer(); LexerInitialised = FALSE; }

void CCLexFile::DeleteHTMLBuffer (   )  [protected]

Deletes the HTML buffer and sets all the member variables that refer to it to appropriate defaults. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 15/5/97 Parameters: -  [INPUTS] Returns: - Errors: - See also: CCLexFile::InitHTMLLexer Definition at line 1317 of file ccfile.cpp. { if (m_pcHTMLBuffer) free( m_pcHTMLBuffer ); m_pcHTMLBuffer=NULL; m_iCharsInHTMLBuffer=0; m_iLengthOfHTMLBuffer=0; }

PCSTR CCLexFile::FindStringWithoutCase (  PCSTR  strToSearch, PCSTR  strToFind )  [protected]

Finds strToFind within strToSearch. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 20/5/97 Parameters: strToSearch  The string in which to search [INPUTS] strToFind The string to search for Returns: A pointer to the first occurrence of strToFind within strToSearch. The find operation is done without regard to case - so, for example, the string "Map" would be found within the string "<MAP NAME=MyMap>" Returns: Errors: - See also: CCLexFile::GetHTMLParameterValue Definition at line 1815 of file ccfile.cpp. { //We assume strToSearch and strToFind are valid //First set up a pointer to search strToSearch with PCSTR pcThisChar = strToSearch; //Now, while pcThisChar is valid while( pcThisChar != NULL && *pcThisChar != '\0' ) { //Is strToSearch from pcThisChar onwards the same //as strToFind, doing a case insensitive comparision? if( 0 == _strnicmp( pcThisChar, strToFind, strlen( strToFind ) ) ) { //Yes. So return TRUE return pcThisChar; } // pcThisChar = camStrinc(pcThisChar); pcThisChar++; } //Otherwise return NULL return NULL; }

void CCLexFile::GetCh (   )

Gets the next character from the input stream, reading in a new line if necessary. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 See also: CCLexFile::GetLine Definition at line 2233 of file ccfile.cpp. { // Get a character from the stream. // If end of file, there is no effect if (EOFFound) return; // If at the end of a line, get a new line first if ((Ch == 0) && (Ofs != 0)) GetLine(); // Test again as GetLine() might encounter the end of the file... // NB the above comment inserted for the hard of thinking (e.g. Justin and Simon) if (EOFFound) { Ch = 0; return; } Ch = Buf[Ofs++]; }

UINT32 CCLexFile::GetCharOffset (   )  [inline]

Definition at line 358 of file ccfile.h. { return Ofs; }

virtual INT32 CCLexFile::GetCharsRead (   )  [inline, virtual]

Reimplemented in CCStreamFile. Definition at line 359 of file ccfile.h. { return CharsRead; }

BOOL CCLexFile::GetHexToken (   )

Extract the next lexical token from the input stream of this file. The token is expected to be a string of hexadecimal digits, and its length should be an even number of characters. If whitespace or a delimiter is encountered then the token is returned ok. If any other character is found which is not a legal hex digit thenFALSE is returned. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Returns: TRUE if all went well; FALSE otherwise. Errors: A 'string' token exceeded 256 characters in length. See also: CCLexFile::GetTokenType; CCLexFile::GetTokenBuf; CCLexFile::SetWhitespace; CCLexFile::SetDelimiters; CCLexFile::SetCommentMarker; CCLexFile::SetStringDelimiters; CCLexFile::InitLexer; CCLexFile Definition at line 1863 of file ccfile.cpp. { // Check to see if the client has put a token back onto the input stream if (TokenIsCached) { // Yes - just return success to the caller and they will use the current token // again. // But for hex token we must check that it is a legal hex token... INT32 i = 0; while (TokenBuf[i] != 0) { if (!camIsxdigit(TokenBuf[i])) // Not valid hex data return FALSE; // Try next character i++; } // Valid hex data - return success. TokenIsCached = FALSE; return TRUE; } DelimiterFound = FALSE; // Keep ignoring whitespace/comments etc for(;;) { // No effect if at EOF if (EOFFound) { // Did not find a hex token TokenType = TOKEN_EOF; TokenBuf[0] = 0; return FALSE; } // Ignore white space until we get something useful while (!EOFFound && IsWhitespace()) GetCh(); if (EOFFound) { // Did not find a hex token TokenType = TOKEN_EOF; TokenBuf[0] = 0; return FALSE; } if (Ch == 0) { // Skip line breaks GetCh(); } else if (Ch == CommentMarker) { // It's a comment - ignore the rest of this line GetLine(); GetCh(); } else { // Ok - is it a hex digit? if (camIsxdigit(Ch)) // Yes - fall through to next bit of code to decode it break; else // No - so we can't find a hex string so return an error return FALSE; } } // Read until not a hexadecimal digit, and analyse result. // NB. 0-terminator ends a token => tokens cannot be split over a line. INT32 i = 0; // This loop is hugely critical (e.g. importing large bitmaps), so we resort to direct // buffer access and register variables. (sorry!) register TCHAR *pHexCh = Buf + Ofs - 1; while (camIsxdigit(*pHexCh)) { TokenBuf[i++] = *pHexCh++; } // Update the offset variable and Ch variable so we maintain lookahead. Ofs += i; Ch = Buf[Ofs-1]; // Set up token correctly. TokenBuf[i] = 0; TokenType = TOKEN_NORMAL; // End of hex data - is it a legal or illegal end? if ((i % 2) != 0) { // Not an even number of hex digits => illegal return FALSE; } // Inform caller if the hex data was terminated legally // (i.e. delimiter, whitespace or line-end) return (IsDelim() || IsWhitespace() || (Ch == 0)); }

String_256 CCLexFile::GetHTMLParameterValue (  const String_256 &  strParameterName, BOOL  fCorrectCase = TRUE )

Finds the value of the specified parameter. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/97 Parameters: strParameterName  The name of the parameter whose [INPUTS] value we want to find. For example, in an image tag, we might want to find the value of 'SRC'. fCorrectCase TRUE if the value should be returned in uppercase FALSE if the value should be returned in its original case Returns: If the parameter is specified within the buffer (e.g. , then the value of that parameter will be returned without any enclosing quotes (e.g. www.xara.com will be returned, not "www.xara.com"). If the parameter is not specified within the buffer, an empty string will be returned. For example, if we search for the value of "ALT" and the buffer contains the text Then the string returned will be Alt This is done as follows: first we make up a composite string consisting of the strParameterName with an equals sign on the end (e.g. "ALT="). Then we search for that string. If we find it: Then if the character after that string is a ", we return everything up until the next ". Otherwise, if the character after that string is not a ", we return everything up until the next > or whitespace character. Returns: Errors: - See also: CCLexFile::GetHTMLToken Definition at line 1696 of file ccfile.cpp. { //Create an empty string to return String_256 strToReturn; //And, if there's less than two characters in the buffer, //return now if (m_iCharsInHTMLBuffer<2) return strToReturn; //So search for the string we have been told to search for PCSTR pcFound; #if 0 != wxUSE_UNICODE { size_t cchParam = camWcstombs( NULL, (const TCHAR *)strParameterName, 0 ) + 1; PSTR pszParam = PSTR( alloca( cchParam ) ); camWcstombs( pszParam, (const TCHAR *)strParameterName, cchParam ); pcFound = FindStringWithoutCase( m_pcHTMLBuffer, pszParam ); } #else pcFound = FindStringWithoutCase( m_pcHTMLBuffer, (const TCHAR *)strParameterName ); #endif //Have we found something? if (pcFound) { //Yes. So move our found pointer past the string we've found // pcFound = camStrninc( pcFound, strParameterName.Length() ); pcFound = pcFound + strParameterName.Length(); //We're now pointing to the character after the parameter name //If we're pointing to a whitespace character, move forward //to the first character that's not whitespace while (*pcFound!='\0' && IsWhitespace(*pcFound)) { // pcFound = camStrinc( pcFound ); pcFound++; } //If that character is not an equals, return an empty string if (*pcFound!='=') return strToReturn; //And, again, move our found pointer to the next character that's not a space do { // pcFound = camStrinc( pcFound ); pcFound++; } while (*pcFound!='\0' && IsWhitespace(*pcFound)); //Note that there is no way that pcFound can //have been advanced past the end of the buffer. //It may, possibly, have been advanced to the NULL //character at the end of the buffer, and I'll handle that... //Now, this variable will tell us whether the parameter value //is in quotes. Set to FALSE by default. BOOL fInQuotes=FALSE; //And is the parameter value in quotes? if (*pcFound=='\"') { //Yes. So make a note of that fInQuotes=TRUE; //And move on to the character after the quotes // pcFound=camStrinc(pcFound); pcFound++; } //Now, copy everything from the character we are pointing at //until... //IF the parameter value is in quotes, until the next " //OTHERWISE, until the next > or whitespace character while (*pcFound!='\0' && ((fInQuotes && *pcFound!='\"') || (!fInQuotes && (!IsWhitespace(*pcFound) && *pcFound!='>')))) { strToReturn+=*pcFound; // pcFound=camStrinc(pcFound); pcFound++; } } //And correct the case if necessary if (fCorrectCase) strToReturn.toUpper(); //And return the string //Note that if nothing was found, this string will be empty return strToReturn; }

String_256 CCLexFile::GetHTMLTagName (   )

This function reads the name of the tag in the buffer. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/97 Returns: The name of the tag which is currently in the buffer It does this by simply reading from the second character in the buffer to the first whitespace character (where whitespace is usually either a space or a tab). Also, if the token in the buffer is not a tag, this function returns FALSE. Returns: Errors: - See also: CCLexFile::GetHTMLToken Definition at line 1604 of file ccfile.cpp. { //Create an empty string to return String_256 strToReturn = ""; //If this isn't a tag, return that empty string if (!IsHTMLTag()) return strToReturn; //And, if there's less than two characters in the buffer, //return now if (m_iCharsInHTMLBuffer<2) return strToReturn; //Otherwise, start copying from the buffer to the string //Start with the second character (remember that the second //character is m_pcHTMLBuffer[1]) and finish //when either we find a whitespace character or we go //past the end of the string INT32 i; for( i = 1; ( i < 255 && i < ( m_iCharsInHTMLBuffer - 1 ) && !IsWhitespace( m_pcHTMLBuffer[i] ) && m_pcHTMLBuffer[i] != _T('>') ); i++ ) { strToReturn+=m_pcHTMLBuffer[i]; } // test for overflow if (i == 255) return ""; //Correct the string to upper case strToReturn.toUpper(); //And return our string return strToReturn; }

BOOL CCLexFile::GetHTMLToken (  BOOL  fIgnoreEOL = TRUE, BOOL  fCorrectCase = TRUE )

Get the next HTML token from the file. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/97 Parameters: fIgnoreReturns  Whether all EOL characters should [INPUTS] be removed from the text in the buffer. This is TRUE by default because HTML should normally ignore EOL characters fCorrectCase Whether the string should automatically be converted to upper case. This is TRUE by default because HTML should ignore case. Returns: TRUE if all went well; FALSE otherwise. This works as follows: if the first character read in the token is a <, then the token will contain all the characters between that < and the following >. If the next character read is not a <, then the token will contain all the characters until the next <. So the token you get back from this function will either be an HTML tag: Or some text: This is some text Note that we read into a variable length buffer. This is because HTML tokens could be any length at all. So, as soon as you have called GetHTMLToken, you should call GetHTMLTokenBuffer to get a pointer to the string that has just been read. Returns: Errors: - See also: CCLexFile::GetToken; CCLexFile::GetHTMLTokenBuffer Definition at line 1427 of file ccfile.cpp. { //First delete our buffer DeleteHTMLBuffer(); //Now, are we reading a tag or some text? //It depends on whether the first character we read is a < m_fIsTag=(PeekNextHTMLChar()=='<'); //Create a two-character buffer to read characters into //(Why is it a buffer, not a single character? Because the //function _tcsupr needs to be passed a null-terminated //string rather than a single character) TCHAR pcReadCharacter[2]; //But when does the HTML token end? If the token is a tag, it ends after the //next > is read. If the token is text, it ends just *before* the next < //is read. This condition is contained in the following while statement... while (!eof() && !(m_fIsTag && pcReadCharacter[0]=='>') && !(!m_fIsTag && PeekNextHTMLChar()=='<')) { //Read in a character pcReadCharacter[0]=ReadNextHTMLChar(); //And null terminate the string pcReadCharacter[1]='\0'; //Correct the string to uppercase if necessary if( fCorrectCase ) CharUpper( pcReadCharacter ); //If we just reached the end of the file, break if (eof()) break; //Now, are we ignoring end of line characters? //And is the character we've read an end of line character? if (!(fIgnoreEOL && (pcReadCharacter[0]=='\r' || pcReadCharacter[0]=='\n'))) { //No. So add the character to the buffer AddToHTMLBuffer(pcReadCharacter[0]); } } //If we reached the end of the file if (eof()) { //Then set our member flag m_fEndOfHTMLFile=TRUE; } //And NULL terminate the buffer AddToHTMLBuffer('\0'); //And return TRUE return TRUE; }

char* CCLexFile::GetHTMLTokenBuffer (   )  [inline]

Definition at line 400 of file ccfile.h. { return m_pcHTMLBuffer; }

void CCLexFile::GetLine (   )

Read in the next line from the file - used when extracted tokens with CCLexFile::GetToken(). Handles the current line count, number of chars read count, etc. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 See also: CCLexFile::GetCh Definition at line 2168 of file ccfile.cpp. { // End of file? if (eof()) { EOFFound = TRUE; return; } if(SeekingRequired) { // It would be much better to do it via variables rather than doing a tellin() //LastLinePos += CharsRead; //tellIn(); //FilePos StartLastLinePos = LastLinePos; /* static FilePos LastLinePosTmp = 0; static BOOL LastLinePosBool = FALSE; if(LastLinePosTmp == 0) { LastLinePosTmp = LastLinePos + Ofs - 1 + 2; LastLinePosBool = FALSE; } else { LastLinePosTmp += Ofs + 1 + 2; if(LastLinePosBool == FALSE) { LastLinePosTmp -= 2; LastLinePosBool = TRUE; } } LastLinePos = LastLinePosTmp;*/ //LastLinePos += Ofs + 1; // Store position of start of line LexerInitialised = FALSE; LastLinePos = tellIn(); LexerInitialised = TRUE; } else { LastLinePos = 0; } // Get a new line from the file. read( LineBuf ); Line++; Ofs = 0; }

const TCHAR* CCLexFile::GetLineBuf (   )  [inline]

Definition at line 388 of file ccfile.h. { return Buf; }

UINT32 CCLexFile::GetLineNumber (   )  [inline]

Definition at line 357 of file ccfile.h. { return Line; }

BOOL CCLexFile::GetLineToken (   )

Read in a token in a line-based manner. If the current input position is in the middle of a line, the data up until the end of the line is read. If at the start of a line, the whole line is returned. The token is still examined to work out what it is, but obviously it may not match any proper construct, in which case the type of the token is set to TOKEN_LINE. (NB this is the only time that TOKEN_LINE is used). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 09/08/94 Returns: TRUE if all went well; FALSE otherwise. See also: CCLexFile::GetToken; CCLexFile::GetSimpleToken; CCLexFile::UngetToken Definition at line 2008 of file ccfile.cpp. { // Check to see if the client has put a token back onto the input stream if (TokenIsCached) { TokenIsCached = FALSE; if (Ofs == 1) { // We're at the start of the line, so the last token must have been the // wholeof the rest of the line, so just return it. return TRUE; } // Otherwise, we should append the rest of the current line to the token, // and work out the token type again. camStrcpy( TokenBuf + camStrlen( TokenBuf ), Buf + Ofs - 1 ); if (TokenBuf[0] == CommentMarker) { TokenType = TOKEN_COMMENT; } else { TokenType = TOKEN_LINE; } GetLine(); GetCh(); // We have a token return TRUE; } // No effect if at EOF if (EOFFound) { TokenType = TOKEN_EOF; TokenBuf[0] = 0; return TRUE; } // Ignore white space until we get something useful while (!EOFFound && IsWhitespace()) GetCh(); if (EOFFound) { TokenType = TOKEN_EOF; TokenBuf[0] = 0; return TRUE; } // Check for line breaks if (Ch == 0) { GetCh(); TokenType = TOKEN_EOL; return TRUE; } // Otherwise, just get the rest of the line... camStrcpy( TokenBuf, Buf + Ofs - 1 ); GetLine(); GetCh(); if (TokenBuf[0] == CommentMarker) { TokenType = TOKEN_COMMENT; } else { TokenType = TOKEN_LINE; } // Token extracted ok return TRUE; }

BOOL CCLexFile::GetSimpleToken (   )

A simplified interface onto GetToken(). The caller is not informed of token types TOKEN_COMMENT and TOKEN_EOL. The function returns TRUE if a TOKEN_NORMAL or TOKEN_STRING is read. FALSE is returned if TOKEN_EOF is read, or if FALSE is returned by GetToken(). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 07/04/94 Parameters: -  [INPUTS] See also: CCLexFile::GetToken Definition at line 1073 of file ccfile.cpp. { BOOL ok; LexTokenType TokenType; do { do { ok = GetToken(); } while (DelimiterFound); TokenType = GetTokenType(); } while (ok && (TokenType != TOKEN_NORMAL) && (TokenType != TOKEN_STRING) && (TokenType != TOKEN_EOF)); return (ok && (TokenType != TOKEN_EOF)); }

BOOL CCLexFile::GetStringToken (   )  [protected]

Extracts a string token from the input stream, as defined by the currently installed string delimiters. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Returns: TRUE if all ok; FALSE if not. Errors: String too long. See also: CCLexFile::InitLexer; CCLexFile; CCLexFile::SetStringDelimiters Definition at line 2102 of file ccfile.cpp. { INT32 i = 0; TokenType = TOKEN_STRING; // Extract the string. // The first time through the loop causes the 'open string' character character to be // discarded. do { GetCh(); TokenBuf[i++] = Ch; if (!IgnoreStringEscapeCodes) { // We are NOT ignoring '\' characters, so have we found one? if (Ch == '\\') { // Backslash character - ignore it and insert the next character in its place. GetCh(); if(Ch == 'r') { TokenBuf[i-1] = '\r'; Ch = 32; } else { TokenBuf[i-1] = Ch; // Set Ch to 32, in case this is a string delimiter - it's been escaped (by // a backslash) so we don't want it to terminate the loop. // (Space (ASCII 32) is a 'safe' value - 0 is out as it causes GetCh() to // read in the next line. Ch = 32; } } } // If string is too long to fit into our buffer, this is classed as an error ERRORIF(i >= TokenBufSize, _R(IDT_LEX_STRINGTOOLONG), FALSE); } while (!EOFFound && (Ch != StringDelimiters[1])); // Null terminate the token string TokenBuf[i-1] = 0; // Discard the 'close string' character GetCh(); // String extracted ok return TRUE; }

BOOL CCLexFile::GetToken (   )

Extract the next lexical token from the input stream of this file. Tokens are separated by whitespace, delimiters, line-breaks, or any combination of the three. Delimiters and line-breaks are returned as tokens (and may be ignored if desired); whitespace is never returned. Call CCLexFile::GetTokenType() to find out what kind of token was extracted. You can examine the token directly by looking at the buffer returned by CCLexFile::GetTokenBuf() (this is a const buffer so you may examine it, but not alter it). This buffer address will not change unless CCLexFile::InitLexer is called again, so it is safe to cache the return value of CCLexFile::GetTokenBuf. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Returns: TRUE if all went well; FALSE otherwise. Errors: A 'string' token exceeded 256 characters in length. See also: CCLexFile::GetTokenType; CCLexFile::GetTokenBuf; CCLexFile::SetWhitespace; CCLexFile::SetDelimiters; CCLexFile::SetCommentMarker; CCLexFile::SetStringDelimiters; CCLexFile::InitLexer; CCLexFile Definition at line 1124 of file ccfile.cpp. { // Check to see if the client has put a token back onto the input stream if (TokenIsCached) { // Yes - just return success to the caller and they will use the current token // again. TokenIsCached = FALSE; return TRUE; } DelimiterFound = FALSE; // No effect if at EOF if (EOFFound) { TokenType = TOKEN_EOF; TokenBuf[0] = 0; return TRUE; } // Ignore white space until we get something useful while (!EOFFound && IsWhitespace()) GetCh(); if (EOFFound) { TokenType = TOKEN_EOF; TokenBuf[0] = 0; return TRUE; } // Check for line breaks if (Ch == 0) { GetCh(); TokenType = TOKEN_EOL; return TRUE; } else if (Ch == StringDelimiters[0]) { // It's a string return GetStringToken(); } else if (Ch == CommentMarker) { // It's a comment - ignore the rest of this line camStrcpy( TokenBuf, Buf + Ofs - 1 ); TokenType = TOKEN_COMMENT; GetLine(); GetCh(); } // Extract the next token else { // Read until delimiter or white-space, and analyse result. // NB. 0-terminator ends a token => tokens cannot be split over a line. INT32 i = 0; if (IsDelim()) { // Found a delimiter token - just return it TokenBuf[i++] = Ch; GetCh(); DelimiterFound = TRUE; } else { do { TokenBuf[i++] = Ch; GetCh(); } while (!EOFFound && !IsDelim() && !IsWhitespace() && (Ch != 0)); } // Terminate the token TokenBuf[i] = 0; TokenType = TOKEN_NORMAL; } // Token extracted ok return TRUE; }

const TCHAR* CCLexFile::GetTokenBuf (   )  [inline]

Definition at line 361 of file ccfile.h. { return TokenBuf; }

LexTokenType CCLexFile::GetTokenType (   )  [inline]

Definition at line 360 of file ccfile.h. { return TokenType; }

void CCLexFile::IncIndent (   )

Increases the number of spaces written by PutNewLine() at the start of the next line. It is increased by IndentDelta, which can be altered using SetIndentDelta(). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Increases IndentSpaces by IndentDelta. Errors: - See also: - Definition at line 2495 of file ccfile.cpp. { IndentSpaces += IndentDelta; }

void CCLexFile::InitHTMLLexer (   )  [protected]

Initialises all the variables used in the HTML parsing code. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 15/5/97 Parameters: -  [INPUTS] Returns: - Errors: - See also: CCLexFile::InitLexer Definition at line 1284 of file ccfile.cpp. { //Initialise the "character waiting" variables m_cWaitingCharacter=0; m_fIsCharacterWaiting=FALSE; //And delete the buffer DeleteHTMLBuffer(); //And say that we haven't reached the end of the file m_fEndOfHTMLFile=FALSE; //And say that the current token is not a tag m_fIsTag=FALSE; }

BOOL CCLexFile::InitLexer (  BOOL  IsSeekingRequired = FALSE, BOOL  DoIgnoreStringEscapeCodes = FALSE )

Prepare the file object for performing lexical analysis on the input stream. This allocates the buffers and sets the various character sets to the default values: Whitespace: spaces and tabs Delimiters: none Comment: # String: Delimited by " and " (i.e. like C) Also resets the newline indent output used by PutNewLine() to 0;. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Parameters: IsSeekingRequired  - Set to TRUE and seekin and tellin will work, but [INPUTS] all the lexfile stuff is slowed down a bit DoIgnoreStringEscapeCodes - Set to TRUE to force '\' chars in strings to be ignored (see below) Returns: TRUE if successful; FALSE otherwise. DoIgnoreStringEscapeCodes = Should escape codes in strings be ignored? e.g. Should "hello\r" turn into "hello" + CR, or should we ignore the code and hence leave the string unaltered? I.e. if DoIgnoreStringEscapeCodes is TRUE, then the '\' character in strings is left alone. Returns: Errors: Out of memory. See also: CCLexFile::SetWhitespace; CCLexFile::SetDelimiters; CCLexFile::SetCommentMarker; CCLexFile::SetStringDelimiters Definition at line 873 of file ccfile.cpp. { // If we've already been here before, get out of town. if (LexerInitialised) return TRUE; // Allocate buffer for reading in each line LineBuf = new String_256; if (LineBuf == NULL) return FALSE; // Allocate space for storing tokens while decoding a line TokenBuf = new TCHAR[TokenBufSize]; if (TokenBuf == NULL) { delete LineBuf; LineBuf = NULL; return FALSE; } // Get ready to parse tokens. TokenBuf[0] = 0; Ofs = 0; Ch = 0; Line = 0; // Make buffer pointer point to line buffer. Buf = (TCHAR *) (*LineBuf); CharsRead = 0; LastLinePos = (FilePos) 0; EOFFound = FALSE; // Set character classes to reasonable defaults. WhitespaceChars = " \t"; DelimiterChars = NULL; CommentMarker = '#'; StringDelimiters = "\"\""; // reset the current indent count and delta value IndentSpaces = 0; IndentDelta = 4; // If true then seeking and tellin lex files will work - slows things down a bit SeekingRequired = IsSeekingRequired; // Ignore '\' characters in string tokens? IgnoreStringEscapeCodes = DoIgnoreStringEscapeCodes; InitHTMLLexer(); LexerInitialised = TRUE; return TRUE; }

BOOL CCLexFile::IsDelim (   )  [protected]

Test the current character (as read in by CCLexFile::GetCh) to see if it is a delimiter. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Returns: TRUE if the current character is a delimiter; FALSE if not. See also: CCLexFile::SetDelimiters Definition at line 2270 of file ccfile.cpp. { if (DelimiterChars == NULL) return FALSE; return( strchr( DelimiterChars, Ch ) != NULL); }

BOOL CCLexFile::IsEndOfHTMLFile (   )  [inline]

Definition at line 410 of file ccfile.h. { return m_fEndOfHTMLFile; }

BOOL CCLexFile::IsHTMLTag (   )  [inline]

Definition at line 405 of file ccfile.h. { return m_fIsTag; }

BOOL CCLexFile::IsLexerInitialised (   )  [inline]

Definition at line 362 of file ccfile.h. { return LexerInitialised; }

BOOL CCLexFile::IsWhitespace (   )  [protected]

Test the current character (as read in by CCLexFile::GetCh) to see if it is a white-space character. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Returns: TRUE if the current character is white-space; FALSE if not. See also: CCLexFile::SetWhitespace Definition at line 2292 of file ccfile.cpp. { // 0-terminators are not whitespace if (Ch == 0) return FALSE; return( strchr( WhitespaceChars, Ch ) != NULL ); }

BOOL CCLexFile::IsWhitespace (  char  cToTest  )  [protected]

Tests the character passed to see if it is a white-space character. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 16/5/97 Parameters: cToTest  Character to test [INPUTS] Returns: TRUE if the character is white-space; FALSE if not. See also: CCLexFile::GetWhitespace() Definition at line 2316 of file ccfile.cpp. { // 0-terminators are not whitespace if (cToTest == 0) return FALSE; return( strchr( WhitespaceChars, cToTest ) != NULL ); }

char CCLexFile::PeekNextHTMLChar (   )  [protected]

In theory, this function finds out what the next character that will be read from the file will be. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/97 Returns: The next character that will be read from the file But of course to find out what the next character in the file is, we have to read that character. So this is what we do. We read the character, but we put it into our member variable m_cWaitingCharacter. We also set our member flag m_fIsCharacterWaiting to TRUE. Then the function ReadNextHTMLCharacter will know there is a character waiting to be 'read' in m_cWaitingCharacter, and will return that character instead of actually reading one from the file. Not perfect but it works. Returns: Errors: - See also: CCLexFile::GetHTMLToken; CCLexFile::ReadNextHTMLChar Definition at line 1516 of file ccfile.cpp. { //Is there a character waiting in m_cWaitingCharacter? if (!m_fIsCharacterWaiting) { //No. So read the next character into our "Waiting Character" buffer //We use "get" because "read" will throw an exception //if you try to read past the end of the file. get(m_cWaitingCharacter); //And remember there's a character waiting m_fIsCharacterWaiting=TRUE; } //Now return the waiting character return m_cWaitingCharacter; }

BOOL CCLexFile::PutNewLine (   )

Outputs a new line, followed by a number of spaces. The number of spaces output can be changed using IncIndent() and DecIndent(); InitLexer resets the number of indent spaces to 0. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE = successful, FALSE = error Errors: - See also: - Definition at line 2469 of file ccfile.cpp. { write("\n"); for (INT32 n=0; n < IndentSpaces;n++) write(" "); return (good()); }

BOOL CCLexFile::PutString (  const StringBase &  str, UINT32  length = 0, char *  pszSep = " " )

Outputs the string to the file enclosed in the string delimiting chars. (see CCLexFile::SetStringDelimiters for more details) Writes out 'length' chars of str, then finishes off by writing 'Sep' out as a bunch of Sep characters. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/94 Parameters: str  = string to write [INPUTS] length = num chars in str to write (0 means write to termination char) Sep = chars to use as a separator between this string and the next. -  [OUTPUTS] Returns: TRUE = successful, FALSE = error Errors: - See also: - Definition at line 2347 of file ccfile.cpp. { write( StringDelimiters[0] ); write( str, length ); write( StringDelimiters[1] ); if( strlen( pszSep ) > 0 ) write( pszSep, (UINT32)strlen( pszSep ) ); return (good()); }

BOOL CCLexFile::PutToken (  INT32  n, char *  Sep = " " )

Outputs the number to the file. Writes out 'n', then finishes off by writing 'Sep' out as a bunch of Sep characters. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/94 Parameters: n  = a number to write [INPUTS] Sep = chars to use as a separator between this string and the next. -  [OUTPUTS] Returns: TRUE = successful, FALSE = error Errors: - See also: - Definition at line 2439 of file ccfile.cpp. { char buf[256]; _snprintf( buf, 256, "%d", n ); UINT32 length = strlen( buf ); write( buf, length ); if( strlen( Sep ) > 0 ) write( Sep, (UINT32)strlen(Sep) ); return( good() ); }

BOOL CCLexFile::PutToken (  const TCHAR *  buf, char *  Sep = " " )

Outputs the string to the file. Writes out 'length' chars of str, then finishes off by writing 'Sep' out as a bunch of Sep characters. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/94 Parameters: buf  = buffer of chars to write [INPUTS] Sep = chars to use as a separator between this string and the next. -  [OUTPUTS] Returns: TRUE = successful, FALSE = error Errors: - See also: - Definition at line 2404 of file ccfile.cpp. { #if 0 != wxUSE_UNICODE size_t cch = camWcstombs( NULL, (const TCHAR *)buf, 0 ) + 1; PSTR psz = PSTR( alloca( cch ) ); camWcstombs( psz, (const TCHAR *)buf, cch ); write( psz, cch ); #else UINT32 length = camStrlen( buf ); write( buf, length ); #endif if( strlen( Sep ) > 0 ) write( Sep, (UINT32)strlen( Sep ) ); return (good()); }

BOOL CCLexFile::PutToken (  const StringBase &  str, UINT32  length = 0, char *  pszSep = " " )

Outputs the string to the file. Writes out 'length' chars of str, then finishes off by writing 'Sep' out as a bunch of Sep characters. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/94 Parameters: str  = string to write [INPUTS] length = num chars in str to write (0 means write to termination char) Sep = chars to use as a separator between this string and the next. -  [OUTPUTS] Returns: TRUE = successful, FALSE = error Errors: - See also: - Definition at line 2377 of file ccfile.cpp. { write( str, length ); if( strlen( pszSep ) > 0 ) write( pszSep, (UINT32)strlen( pszSep ) ); return( good() ); }

char CCLexFile::ReadNextHTMLChar (   )  [protected]

This function reads the next character from the file. Well, actually, the way it works is slightly more complicated. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/97 Returns: The next character in the file That's because the function PeekNextHTMLChar may have given us a character "waiting to be read" in m_cCharacterWaiting. If so, we should return that character first. See PeekNextHTMLChar for a better explanation. Returns: Errors: - See also: CCLexFile::GetHTMLToken; CCLexFile::PeekNextHTMLChar Definition at line 1557 of file ccfile.cpp. { //Do we have a character waiting? if (m_fIsCharacterWaiting) { //Yes. So remember we no longer have a character waiting m_fIsCharacterWaiting=FALSE; //And return our waiting character return m_cWaitingCharacter; } else { //No. So simply read a new character from the file //We use "get" because "read" will throw an exception //if you try to read past the end of the file. char cToRead; get( cToRead ); return cToRead; } }

void CCLexFile::SetCommentMarker (  char  ch  )

Change the character used to denote a comment token. Comments start from the comment character until the end of the line. So, for example, to set the lexer up for PostScript style comments, pass in '' as the comment marker; for assembler style comments, pass in ';'. Multi-line comments are not supported. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Parameters: ch  - the character to use as the comment marker. [INPUTS] See also: CCLexFile::InitLexer; CCLexFile::GetToken Definition at line 1027 of file ccfile.cpp. { CommentMarker = ch; }

void CCLexFile::SetDelimiters (  char *  Str  )

Change the set of characters that are treated as 'delimiters'. A delimiter character indicates that a token has finished. A delimiter character *will* be extracted by CCLexFile::GetToken, and returned on its own. For example, for the line "hello; there ();", processed with the set of delimiters ";()", you would get the following tokens out of CCLexFile::GetToken: MonoOn "hello" ";" "there" "(" ")" ";" MonoOff. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Parameters: Str  - the set of characters to be interpreted as token delimiters. [INPUTS] By default, the set of delimiter characters is empty. See also: CCLexFile::InitLexer; CCLexFile::GetToken Definition at line 1006 of file ccfile.cpp. { DelimiterChars = Str; }

virtual void CCLexFile::SetDontFail (  BOOL  state  )  [inline, virtual]

Reimplemented in CCAsynchDiskFile. Definition at line 393 of file ccfile.h. { DontFail=state;};

void CCLexFile::SetIndentDelta (  UINT32  d  )  [inline]

Definition at line 375 of file ccfile.h. { IndentDelta = d; }

void CCLexFile::SetStringDelimiters (  char *  Str  )

Change the characters used to delimit a string. The lexer will handle strings as a special token type (see CCLexFile::GetToken). You can specify which characters delimit the strings - you pass in a two-character string; the first character is used to start the string,and the second is used to terminate it. The two characters can be the same. So, for example, for PostScript strings, use "()", or for C-style strings, use "\"\"". Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Parameters: Str  - the two-character string to indicate what characters to use to [INPUTS] start and end strings. See also: CCLexFile::InitLexer; CCLexFile::GetToken Definition at line 1051 of file ccfile.cpp. { StringDelimiters = Str; }

void CCLexFile::SetWhitespace (  char *  Str  )

This function changes the set of characters that the lexical analyser treats as white space. Note that it defaults to tabs and spaces, but you can specify any set of characters you want - for example you could even pass in " tf" and it would treat spaces, lower case t's and lower case f's as whitespace characters. Tokens extracted by CCLexFile::GetToken never contain any whitespace characters. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/94 Parameters: Str  - the set of characters to treat as whitespace. [INPUTS] See also: CCLexFile::InitLexer; CCLexFile::GetToken Definition at line 974 of file ccfile.cpp. { WhitespaceChars = Str; }

void CCLexFile::UngetToken (   )

Put the current token back onto the input stream - i.e. the next time GetToken() is called it will return the token it returned last time. This is not nestable - you can only put back one token at once. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 03/08/94 See also: CCLexFile::GetToken(); CCLexFile Definition at line 1984 of file ccfile.cpp. { TokenIsCached = TRUE; }

---

Member Data Documentation

TCHAR* CCLexFile::Buf [protected]

Definition at line 469 of file ccfile.h.

char CCLexFile::Ch [protected]

Definition at line 484 of file ccfile.h.

INT32 CCLexFile::CharsRead [protected]

Definition at line 487 of file ccfile.h.

char CCLexFile::CommentMarker [protected]

Definition at line 512 of file ccfile.h.

char* CCLexFile::DelimiterChars [protected]

Definition at line 506 of file ccfile.h.

BOOL CCLexFile::DelimiterFound [protected]

Definition at line 459 of file ccfile.h.

BOOL CCLexFile::DontFail [protected]

Definition at line 451 of file ccfile.h.

BOOL CCLexFile::EOFFound [protected]

Definition at line 449 of file ccfile.h.

BOOL CCLexFile::IgnoreStringEscapeCodes [protected]

Definition at line 500 of file ccfile.h.

UINT32 CCLexFile::IndentDelta [protected]

Definition at line 525 of file ccfile.h.

INT32 CCLexFile::IndentSpaces [protected]

Definition at line 524 of file ccfile.h.

FilePos CCLexFile::LastLinePos [protected]

Definition at line 491 of file ccfile.h.

BOOL CCLexFile::LexerInitialised [private]

Definition at line 529 of file ccfile.h.

UINT32 CCLexFile::Line [protected]

Definition at line 478 of file ccfile.h.

String_256* CCLexFile::LineBuf [protected]

Definition at line 466 of file ccfile.h.

char CCLexFile::m_cWaitingCharacter [protected]

Definition at line 427 of file ccfile.h.

BOOL CCLexFile::m_fEndOfHTMLFile [protected]

Definition at line 429 of file ccfile.h.

BOOL CCLexFile::m_fIsCharacterWaiting [protected]

Definition at line 426 of file ccfile.h.

BOOL CCLexFile::m_fIsTag [protected]

Definition at line 424 of file ccfile.h.

INT32 CCLexFile::m_iCharsInHTMLBuffer [protected]

Definition at line 421 of file ccfile.h.

INT32 CCLexFile::m_iLengthOfHTMLBuffer [protected]

Definition at line 422 of file ccfile.h.

char* CCLexFile::m_pcHTMLBuffer [protected]

Definition at line 420 of file ccfile.h.

UINT32 CCLexFile::Ofs [protected]

Definition at line 481 of file ccfile.h.

BOOL CCLexFile::SeekingRequired [protected]

Definition at line 494 of file ccfile.h.

char* CCLexFile::StringDelimiters [protected]

Definition at line 516 of file ccfile.h.

TCHAR* CCLexFile::TokenBuf [protected]

Definition at line 472 of file ccfile.h.

BOOL CCLexFile::TokenIsCached [protected]

Definition at line 463 of file ccfile.h.

LexTokenType CCLexFile::TokenType [protected]

Definition at line 475 of file ccfile.h.

char* CCLexFile::WhitespaceChars [protected]

Definition at line 505 of file ccfile.h.

---

The documentation for this class was generated from the following files:

• Kernel/ccfile.h (r1785/r1492)
• Kernel/ccfile.cpp (r1785/r1607)

---