ccfile.cpp

Go to the documentation of this file.

// $Id: ccfile.cpp 1607 2006-07-29 20:24:58Z alex $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

LICENSE TO USE AND MODIFY SOFTWARE
----------------------------------

This file is part of Xara LX.

Xara LX is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as published
by the Free Software Foundation.

Xara LX and its component source files are distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with Xara LX (see the file GPL in the root directory of the
distribution); if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA  02110-1301 USA


ADDITIONAL RIGHTS
-----------------

Conditional upon your continuing compliance with the GNU General Public
License described above, Xara Group Ltd grants to you certain additional
rights. 

The additional rights are to use, modify, and distribute the software
together with the wxWidgets library, the wxXtra library, and the "CDraw"
library and any other such library that any version of Xara LX relased
by Xara Group Ltd requires in order to compile and execute, including
the static linking of that library to XaraLX. In the case of the
"CDraw" library, you may satisfy obligation under the GNU General Public
License to provide source code by providing a binary copy of the library
concerned and a copy of the license accompanying it.

Nothing in this section restricts any of the rights you have under
the GNU General Public License.


SCOPE OF LICENSE
----------------

This license applies to this program (XaraLX) and its constituent source
files only, and does not necessarily apply to other Xara products which may
in part share the same code base, and are subject to their own licensing
terms.

This license does not apply to files in the wxXtra directory, which
are built into a separate library, and are subject to the wxWindows
license contained within that directory in the file "WXXTRA-LICENSE".

This license does not apply to the binary libraries (if any) within
the "libs" directory, which are subject to a separate license contained
within that directory in the file "LIBS-LICENSE".


ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
----------------------------------------------

Subject to the terms of the GNU Public License (see above), you are
free to do whatever you like with your modifications. However, you may
(at your option) wish contribute them to Xara's source tree. You can
find details of how to do this at:
  http://www.xaraxtreme.org/developers/

Prior to contributing your modifications, you will need to complete our
contributor agreement. This can be found at:
  http://www.xaraxtreme.org/developers/contribute/

Please note that Xara will not accept modifications which modify any of
the text between the start and end of this header (marked
XARAHEADERSTART and XARAHEADEREND).


MARKS
-----

Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
designs are registered or unregistered trademarks, design-marks, and/or
service marks of Xara Group Ltd. All rights in these marks are reserved.


      Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
                        http://www.xara.com/

=================================XARAHEADEREND============================
 */

/********************************************************************************************
    
    CCFile.cpp  - Contains the function declarations of the Kernel CCFile derived classes.
    These include: CCDiskFile, CCMemFile and CCMemTextFile. 

********************************************************************************************/


#include "camtypes.h"

//#include "costream.h"
//#include "ccfile.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "zstream.h"
// WEBSTER-Martin-29/12/96 no accusoft stuff
#ifndef WEBSTER
//#include "extfilts.h"
#endif //WEBSTER

#include <errno.h>
//#include "ensure.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]

//#include "mario.h"
//#include "nev.h"
//#include "tim.h"

DECLARE_SOURCE("$Revision: 1607 $");

CC_IMPLEMENT_DYNAMIC(CCFile, CCObject);
CC_IMPLEMENT_DYNAMIC(CCLexFile, CCFile);
CC_IMPLEMENT_DYNAMIC(CCStreamFile, CCLexFile);
CC_IMPLEMENT_DYNAMIC(CCDiskFile, CCStreamFile);
CC_IMPLEMENT_DYNAMIC(CCMemFile, CCLexFile);
CC_IMPLEMENT_DYNAMIC(CCMemTextFile, CCMemFile);

// Declare smart memory handling in Debug builds
#define new CAM_DEBUG_NEW

#define CHAR_EOF ((char)EOF)

/********************************************************************************************

>   CCFile::CCFile(BOOL ReportErrors, BOOL ThrowExceptions)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/08/94
    Inputs:     Flags to specify whether reporting errors or throwing exceptions.
                Defaults specified to backward compatible. Set to report errors but not to
                throw exceptions.
    Outputs:    None
    Returns:    None
    Purpose:    Default CCFile class constructor. Does nothing but set the reporting flags.
    Errors:     None    

********************************************************************************************/

CCFile::CCFile(BOOL ErrorReporting, BOOL ExceptionThrowing)
{
    // Set our class variables from the passed in values
    ReportErrors = ErrorReporting;
    ThrowExceptions = ExceptionThrowing;

    // Default to no compression
    CompressData = FALSE;
    // Default to no GZipErrorID
    GZipErrorID = 0;
}

/********************************************************************************************

>   BOOL CCFile::IsCompressionSet( )

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/08/94
    Inputs:     None
    Outputs:    None
    Returns:    The state of the compression flag, TRUE if compression is on.
    Purpose:    Allow the reading of the compression flag to see if all output data is
                compressed or not.

********************************************************************************************/

BOOL CCFile::IsCompressionSet( )
{
    return CompressData;
}   

/********************************************************************************************

>   BOOL CCFile::SetCompression( BOOL NewState)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/08/94
    Inputs:     TRUE if want compression, false otherhwise.
    Outputs:    None
    Returns:    True, if it was successful, False otherwise.
    Purpose:    Allow the setting of the compression flag so that all output data is
                compressed.

********************************************************************************************/

BOOL CCFile::SetCompression( BOOL NewState)
{
//  BOOL OldState = CompressData;

    CompressData = NewState;

    BOOL ok = TRUE;
    
    // If turning compression On then start the compression up
    // else turn it off.
    if (NewState)
    {
        // Get the class itself to start the compression process up
        ok = StartCompression();
        if (!ok)
        {
            CompressData = FALSE;   
        }
    }
    else
    {
        // Get the class itself to start the compression process up
        ok = StopCompression();
    }

    return ok;  
}

/********************************************************************************************

>   CCFile::GotError( UNIT errorID )
>   CCFile::GotError( UNIT errorID , const TCHAR*)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/08/94
    Inputs:     Unsigned interger which is the error id and possible error message string
    Outputs:    None
    Returns:    None
    Purpose:    Error handler for the CCFile class. It uses flags set in the constructor
                to determine if the user requires errors to be reported or exceptions
                thrown. 
    Errors:     None
    SeeAlso:    SetReportErrors; SetThrowExceptions

********************************************************************************************/

void CCFile::GotError( UINT32 errorID , const TCHAR* errorString)
{
    ERROR3IF(errorString == 0, "errorString is null. Oh dear.");

    Error::SetError(errorID, errorString, 0);

    // Flag that no more reads/writes should happen by forcing bad() to return True/.
    // So that if the user continues to access the file then they should get an error.
    SetBadState();
    
#if !defined(EXCLUDE_FROM_XARLIB)
    // If the ReportErrors flag is set then report the error now.
    if (ReportErrors)
        InformError();
#endif

    // If the ThrowExceptions flag is set then throw an exception.
    // Use the CFileException with a generic or unknown error and make the ioserror
    // our error number.
    if (ThrowExceptions)
    {   
        TRACE( _T("CCFile GotError call to throw exception\n") );
    
        throw( CFileException( errorID ) );
//      AfxThrowFileException(CFileException::generic, errorID);
    }
}

void CCFile::GotError( UINT32 errorID )
{
    // Expand certain types of error messages to make them more informative
    if ((errorID == _R(IDE_OPEN_ERROR)) ||
        (errorID == _R(IDE_FILE_READ_ERROR)) ||
        (errorID == _R(IDE_FILE_WRITE_ERROR)) )
        // Make the error message contain handy information.
        SetFileErrorMessage(errorID);
    else if ((errorID == _R(IDE_ZOPEN_ERROR) ) ||
        (errorID == _R(IDE_ZFILE_READ_ERROR)) ||
        (errorID == _R(IDE_ZFILE_WRITE_ERROR)) )
        // Make the error message contain handy information.
        SetZipFileErrorMessage(errorID);
    else
        Error::SetError(errorID, 0);

    // Flag that no more reads/writes should happen by forcing bad() to return True.
    // So that if the user continues to access the file then they should get an error.
    SetBadState();
    
#if !defined(EXCLUDE_FROM_XARLIB)
    // If the ReportErrors flag is set then report the error now.
    if (ReportErrors)
        InformError();
#endif
    
    // If the ThrowExceptions flag is set then throw an exception.
    // Use the CFileException with a generic or unknown error and make the ioserror
    // our error number.
    if (ThrowExceptions)
    {   
        TRACE( _T("CCFile GotError call to throw exception\n") );
        //TRACEUSER( "Chris", _T("EXCEPTION!!!!!"));
        //AfxDebugBreak();
        throw( CFileException( errorID ) );
    }
}



/********************************************************************************************

>   BOOL CCFile::SetFileErrorMessage(UINT32 ErrorID)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    02/11/94
    Inputs:     ErrorID - the ID of the string resource to use as the error message.
    Returns:    TRUE if the error message was constructed ok;
                FALSE if not (e.g. string resource did not load).
    Purpose:    Looks at the 'errno' variable to determine what kind of error occured, and
                uses the specified error resource string to make a helpful error message
                out of it.
                NB. The string must have two string fields, to be replaced as follows:
                    #1%s  =  description of error
                    #2%s  =  name of the file that went wrong.

                An example is _R(IDE_FILE_READ_ERROR):

                    "A read error occured (#1%s) with the file: #2%s"

    SeeAlso:    CCFile::GotError

********************************************************************************************/

BOOL CCFile::SetFileErrorMessage(UINT32 ErrorID)
{
    UINT32 FileErrorID;

    // Work out which error description string to use...
    switch (errno)
    {
        case EACCES:
            // Permission denied
            FileErrorID = _R(IDE_FILE_PERM_DENIED);
            break;

        case EBADF:
            // Bad file number
            FileErrorID = _R(IDE_FILE_BAD_FILE);
            break;

        case EEXIST:
            // File already exists
            FileErrorID = _R(IDE_FILE_EXISTS);
            break;

        case EMFILE:
            // Too many open files
            FileErrorID = _R(IDE_FILE_TOO_MANY_OPEN);
            break;

        case ENOENT:
            // No such file or directory
            FileErrorID = _R(IDE_FILE_NO_EXIST);
            break;

        case ENOSPC:
            // No space left on device
            FileErrorID = _R(IDE_FILE_NO_SPACE);
            break;

        default:
            // Unknown error
            FileErrorID = _R(IDE_FILE_UNKNOWN);
    }

    // Load in this resource
    String_64 FileError;

    if (!FileError.Load(FileErrorID))
    {
        // Error occured - just use the error number
        if( FileError._MakeMsg( _T("#1%d"), errno ) == 0 )
            // Couldn't do this (we must be severely shafted by now!) - return error
            return FALSE;
    }

    // Get a shortened name for the file
    String_64 Filename;

    if (!GetName(&Filename))
    {
        // Unable to get a name - substitute with "unknown"
        if (!Filename.Load(_R(IDE_FILE_UNKNOWN)))
        {
            // Error occured - just use the hard-coded literal "unknown"
            // (This was sanctioned by Phil)
            Filename = TEXT("unknown");
        }
    }

    // Use this information to build an error string and pass it to the SetError() function.
    String_256 ErrorMsg;

    if (ErrorMsg.MakeMsg(ErrorID, (LPCTSTR) FileError, (LPCTSTR) Filename) == 0)
        // Error occured - maybe resource would not load...not much we can do now.
        return FALSE;

    Error::SetError(ErrorID, (TCHAR *) ErrorMsg, 0);

    // Error string was constructed ok
    return TRUE;
}

/********************************************************************************************

>   BOOL CCFile::SetZipFileErrorMessage(UINT32 ErrorID)

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/6/94
    Inputs:     ErrorID - the ID of the string resource to use as the error message.
    Returns:    TRUE if the error message was constructed ok;
                FALSE if not (e.g. string resource did not load).
    Purpose:    Looks at the 'GZipErrorID' variable to determine what kind of error occured, and
                uses the specified error resource string to make a helpful error message
                out of it.
                NB. The string must have two string fields, to be replaced as follows:
                    #1%s  =  description of error
                    #2%s  =  name of the file that went wrong.

                An example is _R(IDE_FILE_READ_ERROR):

                    "A read error occured (#1%s) with the file: #2%s"

                Exactly the same as above but is designed for zip file errors.

    SeeAlso:    SetFileErrorMessage; CCFile::GotError

********************************************************************************************/

BOOL CCFile::SetZipFileErrorMessage(UINT32 ErrorID)
{
    UINT32 ZipFileErrorID;

    // Work out which error description string to use...
    switch (GZipErrorID)
    {
        case Z_ERRNO:
            // Bad file number
            ZipFileErrorID = _R(IDE_ZFILE_ERRORNO);
            break;

        case Z_STREAM_ERROR:
            // Permission denied
            ZipFileErrorID = _R(IDE_ZFILE_STREAMERROR);
            break;

        case Z_DATA_ERROR:
            // Bad file number
            ZipFileErrorID = _R(IDE_ZFILE_DATAERROR);
            break;

        case Z_MEM_ERROR:
            // Bad file number
            ZipFileErrorID = _R(IDE_ZFILE_MEMORYERROR);
            break;

        case Z_BUF_ERROR:
            // Bad file number
            ZipFileErrorID = _R(IDE_ZFILE_BUFFERERROR);
            break;

        default:
            // Unknown error
            ZipFileErrorID = _R(IDE_ZFILE_BASEEERROR);
    }

    // Load in this resource
    String_64 FileError;

    if (!FileError.Load(ZipFileErrorID))
    {
        // Error occured - just use the error number
        if( FileError._MakeMsg( _T("#1%d"), errno ) == 0 )
            // Couldn't do this (we must be severely shafted by now!) - return error
            return FALSE;
    }

    // Get a shortened name for the file
    String_32 Filename;

    if (!GetName(&Filename))
    {
        // Unable to get a name - substitute with "unknown"
        if (!Filename.Load(_R(IDE_FILE_UNKNOWN)))
        {
            // Error occured - just use the hard-coded literal "unknown"
            // (This was sanctioned by Phil)
            Filename = TEXT("unknown");
        }
    }

    // Use this information to build an error string and pass it to the SetError() function.
    String_256 ErrorMsg;

    if (ErrorMsg.MakeMsg(ErrorID, (LPCTSTR) FileError, (LPCTSTR) Filename) == 0)
        // Error occured - maybe resource would not load...not much we can do now.
        return FALSE;

    Error::SetError(ErrorID, (TCHAR *) ErrorMsg, 0);

    // Error string was constructed ok
    return TRUE;
}

/********************************************************************************************

>   BOOL CCFile::SetReportErrors( BOOL )

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/08/94
    Inputs:     BOOL which is the TRUE/FALSE state required.
    Outputs:    None
    Returns:    Old state of the flag
    Purpose:    Public way of setting the internal error handling flag to say whether
                errors are going to be reported or not.
    Errors:     None
    SeeAlso:    GotError; IsReportingSet; IsThrowingSet     

********************************************************************************************/
BOOL CCFile::SetReportErrors( BOOL newState )
{
    BOOL OldState = ReportErrors;

    ReportErrors = newState;

    return OldState;
}

/********************************************************************************************

>   BOOL CCFile::SetThrowExceptions( BOOL )

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    29/08/94
    Inputs:     BOOL which is the TRUE/FALSE state required.
    Outputs:    None
    Returns:    Old state of the flag
    Purpose:    Public way of setting the internal error handling flag to say whether
                errors are going to throw an exception or not.
    Errors:     None    
    SeeAlso:    GotError; IsReportingSet; IsThrowingSet 

********************************************************************************************/
BOOL CCFile::SetThrowExceptions( BOOL newState )
{
    BOOL OldState = ThrowExceptions;

    ThrowExceptions = newState;

    return OldState;
}

/********************************************************************************************

>   BOOL CCFile::IsReportingSet()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/09/94
    Inputs:     None.
    Outputs:    None
    Returns:    True if error reporting flag is set.
    Purpose:    Public way of checking the internal error reporting flag to say whether
                InformError is going to be called or not.
    Errors:     None    
    SeeAlso:    GotError; SetReportErrors; SetThrowExceptions   

********************************************************************************************/
BOOL CCFile::IsReportingSet()
{
    return ReportErrors;
}

/********************************************************************************************

>   BOOL CCFile::IsThrowingSet()

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/09/94
    Inputs:     None.
    Outputs:    None
    Returns:    True if exception throwing flag is set.
    Purpose:    Public way of checking the internal error throwing flag to say whether
                errors are going to throw an exception or not.
    Errors:     None    
    SeeAlso:    GotError; SetReportErrors; SetThrowExceptions   

********************************************************************************************/
BOOL CCFile::IsThrowingSet()
{
    return ThrowExceptions;
}

/********************************************************************************************

>   BOOL CCFile::GetName( StringBase* name) const

    Author:     Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com>
    Created:    22/09/94
    Inputs:     Pointer to a CCFile name 
    Outputs:    None
    Returns:    True if a name has been set otherwise False. At present always returns False.
    Purpose:    Given a CCFile*, you can ask for some sort of name which is associated with
                that file. For filenames it might be a filename, or a pathname, for resource
                files it might be "Default Bitmap" etc. These names could then be used for
                making error messages have some extra useful information in.
    Errors:     None    

********************************************************************************************/

BOOL CCFile::GetName( StringBase* name) const
{
    return FALSE;
}



/********************************************************************************************
>   virtual PathName CCFile::GetPathName() const

    Author:     Justin_Flude (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/8/96
    Returns:    The path-name of this file.  If the file doesn't support the notion of a
                file-path (as, for instance, CCMemFiles and CCStreamFiles), then returns
                an empty string.
********************************************************************************************/

PathName CCFile::GetPathName() const
{
    PathName pn;
    return pn;
}



/********************************************************************************************

>   CCFile& CCFile::operator>>(StringBase* buf)

    Author:     Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/9/93
    Inputs:     String buffer.
    Returns:    Reference to the CCFile object.
    Purpose:    Reads file until string buffer is full or end of line or end of file is met.
    SeeAlso:    CCFile::read

********************************************************************************************/

CCFile& CCFile::operator>>(StringBase* buf)
{
    return read(buf);
}

/********************************************************************************************

>   CCFile& CCFile::operator<<(const StringBase& buf)

    Author:     Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com>
    Created:    1/9/93
    Inputs:     buf - the string to write out to the file.
    Returns:    Reference to the CCFile object.
    Purpose:    Writes the charactors found in the String buffer.
    SeeAlso:    CCFile::write

********************************************************************************************/

CCFile& CCFile::operator<<(const StringBase& buf)
{
    return write(buf);
}

// These should be deleted soon..?
CCFile &CCFile::get( char &buf )
{
    return read(buf);
}

CCFile &CCFile::put( const char &buf )
{
    return write((void *) &buf);
}

/********************************************************************************************

>   virtual CCFile& CCFile::flush()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Returns:    Reference to the CCFile object.
    Purpose:    Flushes a file's buffers.  By default it does nothing - override it if you  
                want it to do anything.  (The CCDiskFile class overrides this function.)
    SeeAlso:    CCDiskFile::flush

********************************************************************************************/

CCFile& CCFile::flush()
{
    return (CCFile&) *this;
}

/********************************************************************************************

>   BOOL CCFile::good()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Returns:    TRUE  => file stream is ok.
                FALSE => an error has occured.
    Purpose:    Simple base implentation of this function - just examines EOF status.
                It allows checking of the current file status to see if we should continue
                using the file or not.
                Override this function to provide more sophisticated error checking
                (the CCDiskFile class overrides this function).

********************************************************************************************/

BOOL CCFile::good() const
{
    return !eof();
}

/********************************************************************************************

>   BOOL CCFile::bad()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Returns:    TRUE  => An error has occured.
                FALSE => The file stream is ok.
    Purpose:    Simple base implementation of this function - just examines EOF status.
                It allows checking of the current file status to see if we should continue
                using the file or not.
                Override this function to provide more sophisticated error checking
                (the CCDiskFile class overrides this function).

********************************************************************************************/

BOOL CCFile::bad() const
{
    return eof();
}

/********************************************************************************************

>   BOOL CCFile::fail()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    31/03/94
    Returns:    TRUE  => An error has occured.
                FALSE => The file stream is ok.
    Purpose:    Simple base implementation of this function - just examines EOF status.
                It allows checking of the current file status to see if we should continue
                using the file or not.
                Override this function to provide more sophisticated error checking
                (the CCDiskFile class overrides this function).

********************************************************************************************/

BOOL CCFile::fail() const
{
    return eof();
}





//-----------------------
/********************************************************************************************

                                        CCLexFile

********************************************************************************************/
//-----------------------




/********************************************************************************************

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

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>               (Altered by Neville 01/08/94) 
    Created:    05/04/94
    Purpose:    Initialise a CCLexFile object.

********************************************************************************************/

CCLexFile::CCLexFile(BOOL ErrorReporting, BOOL ExceptionThrowing)
  : 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()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/04/94
    Purpose:    Deinitialises a CCLexFile object (calls DeinitLexer() for you).

********************************************************************************************/

CCLexFile::~CCLexFile()
{
    DeinitLexer();
}

// The size of the token buffer used for lexical analysis in the CCLexFile class.
const INT32 TokenBufSize = 256;

/********************************************************************************************

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

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/04/94
    Inputs:     IsSeekingRequired - Set to TRUE and seekin and tellin will work, but
                                    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.
    Purpose:    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;

                DoIgnoreStringEscapeCodes = Should escape codes in strings be ignored?
                e.g. Should "hello\r" turn into "hello" + CR, or should we ignore the \r code and hence leave
                the string unaltered?
                I.e. if DoIgnoreStringEscapeCodes is TRUE, then the '\' character in strings is left alone.

    Errors:     Out of memory.
    SeeAlso:    CCLexFile::SetWhitespace; CCLexFile::SetDelimiters; 
                CCLexFile::SetCommentMarker; CCLexFile::SetStringDelimiters

********************************************************************************************/

BOOL CCLexFile::InitLexer(BOOL IsSeekingRequired, BOOL DoIgnoreStringEscapeCodes)
{
    // 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;
}


/********************************************************************************************

>   void CCLexFile::DeinitLexer()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/04/94
    Purpose:    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.
    SeeAlso:    CCLexFile::InitLexer

********************************************************************************************/

void CCLexFile::DeinitLexer()
{
    // Deallocate our buffers
    if (LineBuf  != NULL) delete LineBuf;
    if (TokenBuf != NULL) delete [] TokenBuf;

    LineBuf  = NULL;
    TokenBuf = NULL;
    Buf      = NULL;

    DeleteHTMLBuffer();

    LexerInitialised = FALSE;
}

/********************************************************************************************

>   void CCLexFile::SetWhitespace(char *Str)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/04/94
    Inputs:     Str - the set of characters to treat as whitespace.
    Purpose:    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.
    SeeAlso:    CCLexFile::InitLexer; CCLexFile::GetToken

********************************************************************************************/

void CCLexFile::SetWhitespace(char *Str)
{
    WhitespaceChars = Str;
}

/********************************************************************************************

>   void CCLexFile::SetDelimiters(char *Str)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/04/94
    Inputs:     Str - the set of characters to be interpreted as token delimiters.
    Purpose:    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

                By default, the set of delimiter characters is empty.

    SeeAlso:    CCLexFile::InitLexer; CCLexFile::GetToken

********************************************************************************************/

void CCLexFile::SetDelimiters(char *Str)
{
    DelimiterChars = Str;
}

/********************************************************************************************

>   void CCLexFile::SetCommentMarker(char ch)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/04/94
    Inputs:     ch - the character to use as the comment marker.
    Purpose:    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.
    SeeAlso:    CCLexFile::InitLexer; CCLexFile::GetToken

********************************************************************************************/

void CCLexFile::SetCommentMarker(char ch)
{
    CommentMarker = ch;
}

/********************************************************************************************

>   void CCLexFile::SetStringDelimiters(char *Str)

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/04/94
    Inputs:     Str - the two-character string to indicate what characters to use to
                      start and end strings.
    Purpose:    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 "\"\"".
    SeeAlso:    CCLexFile::InitLexer; CCLexFile::GetToken

********************************************************************************************/

void CCLexFile::SetStringDelimiters(char *Str)
{
    StringDelimiters = Str;
}

/********************************************************************************************

>   BOOL CCLexFile::GetSimpleToken()

    Author:     Mark_Neves (Xara Group Ltd) <camelotdev@xara.com>
    Created:    07/04/94
    Inputs:     -
    Purpose:    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().

    SeeAlso:    CCLexFile::GetToken

********************************************************************************************/

BOOL CCLexFile::GetSimpleToken()
{
    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::GetToken()

    Author:     Tim_Browse (Xara Group Ltd) <camelotdev@xara.com>
    Created:    05/04/94
    Returns:    TRUE if all went well; 
                FALSE otherwise.
    Purpose:    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.

    Errors:     A 'string' token exceeded 256 characters in length.

    SeeAlso:    CCLexFile::GetTokenType; CCLexFile::GetTokenBuf; CCLexFile::SetWhitespace;
                CCLexFile::SetDelimiters; CCLexFile::SetCommentMarker;
                CCLexFile::SetStringDelimiters; CCLexFile::InitLexer; CCLexFile

********************************************************************************************/

BOOL CCLexFile::GetToken()
{
    // 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;
}

/********************************************************************

  Graham 15/5/97

  CCLexFile: HTML parsing code

  The lexer above isn't suited to parsing HTML code. For example, it insists
  on breaking tokens at the end of lines, but HTML should be able to run
  over lines ignoring line break characters. And HTML tokens should be able
  to be any length...not just 256 characters. And so on.

  So it makes sense to do HTML parsing completely separately.
  
    This HTML lexer returns two sorts of tokens:

  TAGS  Which start with < and end with >

  TEXT  Which is anything in between tags.

  So for example, a file containing the characters <B>Bold</B> would produce
  three tokens:

  TAG   <B>
  TEXT  Bold
  TAG   </B>

  Here's an example of how to use the lexer. This code reads
  all the HTML from a file pMyFile and prints out only the tags. (I haven't
  tested this code, of course, there might be the odd mistake).

  //First initialise the lexer. This function will call InitHTMLLexer().
  InitLexer();

  //And read HTML tokens from the file until we reach the end of the file
  while (!pMyFile->IsEndOfHTMLFile())
  {
        //Tell the HTML lexer to get an HTML token into its buffer
        pMyFile->GetHTMLToken();

        //Get the text buffer
        TCHAR* pcBuffer=pMyFile->GetHTMLTokenBuffer();

        //Now, does the buffer contain a tag?
        if (pMyFile->IsHTMLTag())
        {
            //Yes. So print it out.
            //Remember that pcBuffer may be NULL if it had nothing in it
            if (pcBuffer)
                TRACE(pcBuffer);
        }
    }

  //And deinitialise the lexer
  DeInitLexer();


  Also see the function ImagemapFilter::WriteExistingDataHelper.

  ************************************************************************/

/********************************************************************************************

>   void CCLexFile::InitHTMLLexer()

    Author:     Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/5/97
    Inputs:     -
    Returns:    -
    Purpose:    Initialises all the variables used in the HTML parsing code

    Errors:     -
    SeeAlso:    CCLexFile::InitLexer

********************************************************************************************/

void CCLexFile::InitHTMLLexer()
{
    //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;
    
}

/********************************************************************************************

>   void CCLexFile::DeleteHTMLBuffer()

    Author:     Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/5/97
    Inputs:     -
    Returns:    -
    Purpose:    Deletes the HTML buffer and sets all the member variables
                that refer to it to appropriate defaults

    Errors:     -
    SeeAlso:    CCLexFile::InitHTMLLexer

********************************************************************************************/

void CCLexFile::DeleteHTMLBuffer()
{
    if (m_pcHTMLBuffer)
        free( m_pcHTMLBuffer );

    m_pcHTMLBuffer=NULL;

    m_iCharsInHTMLBuffer=0;
    m_iLengthOfHTMLBuffer=0;

}

/********************************************************************************************

>   void CCLexFile::AddToHTMLBuffer(TCHAR &cToAdd)

    Author:     Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/5/97
    Inputs:     cToAdd - the character to add to the buffer
    Returns:    -
    Purpose:    Adds cToAdd to the buffer, extending the buffer if
                necessary.

    Errors:     -
    SeeAlso:    CCLexFile::GetHTMLToken

*********************