ITextParsers.h

Go to the documentation of this file.

#ifndef _INCLUDE_SOURCEMOD_TEXTPARSERS_INTERFACE_H_
#define _INCLUDE_SOURCEMOD_TEXTPARSERS_INTERFACE_H_

#include <IShareSys.h>

namespace SourceMod
{

        #define SMINTERFACE_TEXTPARSERS_NAME            "ITextParsers"
        #define SMINTERFACE_TEXTPARSERS_VERSION         4

        class ITextListener_INI
        {
        public:
                virtual unsigned int GetTextParserVersion1()
                {
                        return SMINTERFACE_TEXTPARSERS_VERSION;
                }
        public:
                virtual bool ReadINI_NewSection(const char *section,
                                                                                bool invalid_tokens,
                                                                                bool close_bracket,
                                                                                bool extra_tokens,
                                                                                unsigned int *curtok)
                {
                        return true;
                }

                virtual bool ReadINI_KeyValue(const char *key, 
                                                                          const char *value, 
                                                                          bool invalid_tokens,
                                                                          bool equal_token,
                                                                          bool quotes,
                                                                          unsigned int *curtok)
                {
                        return true;
                }

                virtual bool ReadINI_RawLine(const char *line, unsigned int *curtok)
                {
                        return true;
                }
        };

        enum SMCResult
        {
                SMCResult_Continue,             
                SMCResult_Halt,                 
                SMCResult_HaltFail              
        };

        enum SMCError
        {
                SMCError_Okay = 0,                      
                SMCError_StreamOpen,            
                SMCError_StreamError,           
                SMCError_Custom,                        
                SMCError_InvalidSection1,       
                SMCError_InvalidSection2,       
                SMCError_InvalidSection3,       
                SMCError_InvalidSection4,       
                SMCError_InvalidSection5,       
                SMCError_InvalidTokens,         
                SMCError_TokenOverflow,         
                SMCError_InvalidProperty1,      
        };

        struct SMCStates
        {
                unsigned int line;                      
                unsigned int col;                       
        };

        class ITextListener_SMC
        {
        public:
                virtual unsigned int GetTextParserVersion2()
                {
                        return SMINTERFACE_TEXTPARSERS_VERSION;
                }
        public:
                virtual void ReadSMC_ParseStart()
                {
                };

                virtual void ReadSMC_ParseEnd(bool halted, bool failed)
                {
                }

                virtual SMCResult ReadSMC_NewSection(const SMCStates *states, const char *name)
                {
                        return SMCResult_Continue;
                }

                virtual SMCResult ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value)
                {
                        return SMCResult_Continue;
                }

                virtual SMCResult ReadSMC_LeavingSection(const SMCStates *states)
                {
                        return SMCResult_Continue;
                }

                virtual SMCResult ReadSMC_RawLine(const SMCStates *states, const char *line)
                {
                        return SMCResult_Continue;
                }
        };      

        class ITextParsers : public SMInterface
        {
        public:
                virtual const char *GetInterfaceName()
                {
                        return SMINTERFACE_TEXTPARSERS_NAME;
                }
                virtual unsigned int GetInterfaceVersion()
                {
                        return SMINTERFACE_TEXTPARSERS_VERSION;
                }
                virtual bool IsVersionCompatible(unsigned int version)
                {
                        if (version < 2)
                        {
                                return false;
                        }
                        return SMInterface::IsVersionCompatible(version);
                }
        public:
                virtual bool ParseFile_INI(const char *file, 
                                                                        ITextListener_INI *ini_listener,
                                                                        unsigned int *line,
                                                                        unsigned int *col) =0;

                virtual SMCError ParseFile_SMC(const char *file, 
                                                                        ITextListener_SMC *smc_listener, 
                                                                        SMCStates *states) =0;

                virtual const char *GetSMCErrorString(SMCError err) =0;

        public:
                virtual unsigned int GetUTF8CharBytes(const char *stream) =0;

                virtual bool IsWhitespace(const char *stream) =0;

                virtual SMCError ParseSMCFile(const char *file,
                        ITextListener_SMC *smc_listener,
                        SMCStates *states,
                        char *buffer,
                        size_t maxsize) =0;

                virtual SMCError ParseSMCStream(const char *stream,
                        size_t length,
                        ITextListener_SMC *smc_listener,
                        SMCStates *states,
                        char *buffer,
                        size_t maxsize) =0;
        };

        inline unsigned int _GetUTF8CharBytes(const char *stream)
        {
                unsigned char c = *(unsigned char *)stream;
                if (c & (1<<7))
                {
                        if (c & (1<<5))
                        {
                                if (c & (1<<4))
                                {
                                        return 4;
                                }
                                return 3;
                        }
                        return 2;
                }
                return 1;
        }
}

extern SourceMod::ITextParsers *textparsers;

#endif //_INCLUDE_SOURCEMOD_TEXTPARSERS_INTERFACE_H_