RmMFCShaderSyntaxParser.h

//=================================================================================================//
// filename: RmMFCShaderSyntaxParser.h                                                             //
//                                                                                                 //
// author:      Toshiaki Tsuji                                                                     //
//              ATI Research, Inc.                                                                 //
//              3D Application Research Group                                                      //
//                                                                                                 //
// description: Shader Editor Tab 
//                                                                                                 //
//=================================================================================================//
// $File: //depot/3darg/Tools/RenderMonkey/sdk/Include/MFCUtilities/RmMFCShaderSyntaxParser.h $                                   
// $Author: tsuji $ $Revision: #2 $                                                                     
//=================================================================================================//
//   (C) 2004 ATI Research, Inc.  All rights reserved.                                             //
//=================================================================================================//

#ifndef RM_MFC_SHADER_SYNTAX_PARSER_H
#define RM_MFC_SHADER_SYNTAX_PARSER_H

//#include "RmShaderEditorTypes.h"
//#include "RmShaderPage.h"

#define MAX_NUM_CHAR 256 /*65536*/

//..............................................................................................................//
//..............................................................................................................//
//..............................................................................................................//
//..............................................................................................................//
//  Shader Parser Class
//..............................................................................................................//
//..............................................................................................................//
//..............................................................................................................//
//..............................................................................................................//
class RMMFCUTIL_API RmMFCShaderSyntaxParser
{
public:
   //--------------------------------------------------------------------
   // Simple Wrapper for Parsing Input/Result
   //--------------------------------------------------------------------
   struct ParseInput
   {
      const TCHAR *pBuffer;
      const RmShaderCharType *pRmShaderCharTypeTable; // Table to identify character type

      int bufferSize;
      int parseBeginPos;   // Starting poistion withtin buffer
      int parseEndPos;     // End limit poistion.  Parsing must stop before this
   }; // End of ParseInput

   //--------------------------------------------------------------------
   struct ParseResult
   {
      bool bProcessed;     // Returns true, if processing done. false if nothing was done
      bool bEndReached;
      int  parseNextPos;   // Position after parsing, next parsing should start from this pos
   }; // End of ParseResult

public :
   //--------------------------------------------------------------------
   // Keyword
   //--------------------------------------------------------------------
   class Keyword
   {
   public :
      Keyword( const TCHAR* szKeyword );
      virtual ~Keyword();

      // Accessor
      const RmStringT& GetString() const { return m_keywordString; };

      // Returns true, if given string matches Keyword
      bool Match( const TCHAR* szStr, bool bCaseSensitive = true ) const;

   private:
      RmStringT m_keywordString; 
   }; // End of Keyword

   typedef RmLinkedList<Keyword*>         KeywordList;
   typedef KeywordList::iterator          KeywordIterator;
   typedef KeywordList::const_iterator    KeywordConstIterator;

   //--------------------------------------------------------------------
   // KeywordCategory
   //--------------------------------------------------------------------
   class KeywordCategory
   {
   public :
      // Keyword Table is a Table of list of Keyword
      // First character of keyword determines the index to array
      // Then each index of keywordtable is a list of keyword
      typedef KeywordList KeywordTable[MAX_NUM_CHAR];

   public :
      KeywordCategory( const TCHAR* szKeywordCategoryName, bool bOperatorType );
      virtual ~KeywordCategory();

      // Returns name of syntax canetgory
      const RmStringT& GetKeywordCategoryName() const { return m_keywordCategoryName; };

      // Is this operator category?
      bool IsOperatorType() const { return m_bOperatorType; };

      // Returns true, if given string matches Syntax CategoryName
      bool Match( const TCHAR* szStr, bool bCaseSensitive = false ) const;

      // Add/Remove Keyword
      void AddKeyword( const TCHAR *szKeyword );
      void RemoveKeyword( const TCHAR *szKeyword );
      void RemoveAllKeywords();

      // Search
      Keyword* FindKeyword( const TCHAR *szKeyword );
      const Keyword* FindKeyword( const TCHAR *szKeyword ) const;

      // Parsing
      // 
      // Parameter :
      //
      //  - parseInput     = Parameters necessary for parsing
      //  - parseInput     = [out] Result of Parsing
      //
      void Parse( const ParseInput& parseInput,
                  ParseResult& parseResult );

      // Set/Get Parent Parser
      void SetParser( RmMFCShaderSyntaxParser *pParser ) { m_pParser = pParser; };

      RmMFCShaderSyntaxParser*       GetParser() { return m_pParser; };
      const RmMFCShaderSyntaxParser* GetParser() const { return m_pParser; };

      // Set/Get Color
      void     SetColor( COLORREF color ) { m_color = color; };
      COLORREF GetColor() const { return m_color; };

      // To directly access keyword table
      KeywordTable&       GetKeywordTable() { return m_keywordTable; };
      const KeywordTable& GetKeywordTable() const { return m_keywordTable; };

   protected :
      RmMFCShaderSyntaxParser *m_pParser;

      RmStringT    m_keywordCategoryName;
      bool         m_bOperatorType;

      KeywordTable m_keywordTable;

      COLORREF     m_color;
   }; // End of KeywordCategory

   typedef RmLinkedList<KeywordCategory*>      KeywordCategoryList;
   typedef KeywordCategoryList::iterator       KeywordCategoryIterator;
   typedef KeywordCategoryList::const_iterator KeywordCategoryConstIterator;

   //--------------------------------------------------------------------
   // WhiteSpaceParser
   //--------------------------------------------------------------------
   class WhiteSpaceParser
   {
   public:
      class CommentBlock
      {
      public :
         CommentBlock( const TCHAR* szStartOfComment, 
                       const TCHAR* szEndOfComment );
         virtual ~CommentBlock();

         const RmStringT& GetStartOfComment() const { return m_startOfComment; };
         const RmStringT& GetEndOfComment() const { return m_endOfComment; };

         //--------------------------------------------------------------------
         // Parsing
         // 
         // Parameter :
         //
         //  - parseInput     = Parameters necessary for parsing
         //  - parseInput     = [out] Result of Parsing
         //
         //--------------------------------------------------------------------
         void Parse( const ParseInput& parseInput,
                     ParseResult& parseResult );

      private :
         RmStringT       m_startOfComment;
         RmStringT       m_endOfComment;
      }; // End of CommentBlock

      typedef RmLinkedList<CommentBlock*>      CommentBlockList;
      typedef CommentBlockList::iterator       CommentBlockItr;
      typedef CommentBlockList::const_iterator CommentBlockConstItr;

   public :
      WhiteSpaceParser();
      virtual ~WhiteSpaceParser();

      //--------------------------------------------------------------------
      // Parsing
      // 
      // Parameter :
      //
      //  - parseInput     = Parameters necessary for parsing
      //  - parseInput     = [out] Result of Parsing
      //
      //--------------------------------------------------------------------
      void Parse( const ParseInput& parseInput,
                  ParseResult& parseResult );

      // Add/Remove Comments
      void AddCommentBlock( const TCHAR* szStartOfComment,
                            const TCHAR* szEndOfComment );
      void RemoveAllCommentBlocks();

      // Iterator
      CommentBlockItr BeginCommentBlock() { return m_commentBlockList.begin(); };
      CommentBlockItr EndCommentBlock() { return m_commentBlockList.end(); };

      // Set/Get Parent Parser
      void SetParser( RmMFCShaderSyntaxParser *pParser ) { m_pParser = pParser; };

      RmMFCShaderSyntaxParser*       GetParser() { return m_pParser; };
      const RmMFCShaderSyntaxParser* GetParser() const { return m_pParser; };

   private :
      RmMFCShaderSyntaxParser *m_pParser;
      CommentBlockList       m_commentBlockList;
   }; // End of WhiteSpaceParser

   //--------------------------------------------------------------------
   // TextParser
   //--------------------------------------------------------------------
   class TextParser
   {
   public : 
      TextParser();
      virtual ~TextParser();

      //--------------------------------------------------------------------
      // Parsing
      // 
      // Parameter :
      //
      //  - pBuffer        = Buffer to parse
      //  - parseInput     = Parameters necessary for parsing
      //  - parseInput     = [out] Result of Parsing
      //  - Keywords       = List of Keywords
      //
      //--------------------------------------------------------------------
      void Parse( const ParseInput& parseInput,
                  ParseResult& parseResult,
                  const KeywordCategoryList &keywords );

      // Set/Get Parent Parser
      void SetParser( RmMFCShaderSyntaxParser *pParser ) { m_pParser = pParser; };

      RmMFCShaderSyntaxParser*       GetParser() { return m_pParser; };
      const RmMFCShaderSyntaxParser* GetParser() const { return m_pParser; };

   private :
      RmMFCShaderSyntaxParser *m_pParser;
   }; // End of TextParser

public:
   // Default Constructor:
        RmMFCShaderSyntaxParser();      
   virtual ~RmMFCShaderSyntaxParser();

   // Add/Remove Category
   KeywordCategory* AddKeywordCategory( const TCHAR *szCategoryName, bool bOperator );
   void RemoveKeywordCategory( const TCHAR *szCategoryName );
   void RemoveAllKeywordCategory();

   // Search Category
   KeywordCategory* FindKeywordCategory( const TCHAR* szCategoryName );
   const KeywordCategory* FindKeywordCategory( const TCHAR* szCategoryName ) const;

   // Iterator for Syntax Category
   KeywordCategoryIterator BeginKeywordCategory() { return m_keywordCategoryList.begin(); };
   KeywordCategoryConstIterator BeginKeywordCategory() const { return m_keywordCategoryList.begin(); };

   KeywordCategoryIterator EndKeywordCategory() { return m_keywordCategoryList.end(); };
   KeywordCategoryConstIterator EndKeywordCategory() const { return m_keywordCategoryList.end(); };

   // Keyword
   void AddKeyword( const TCHAR* szCategoryName, const TCHAR *szKeyword );
   void RemoveKeyword( const TCHAR* szCategoryName, const TCHAR *szKeyword );

   // WhiteSpace Processor 
   WhiteSpaceParser& GetWhiteSpaceParser() { return m_whiteSpaceParser; };
   const WhiteSpaceParser& GetWhiteSpaceParser() const { return m_whiteSpaceParser; };

   // Text Processor 
   TextParser& GetTextParser() { return m_textParser; };
   const TextParser& GetTextParser() const { return m_textParser; };

   //--------------------------------------------------------------------
   // Parsing
   // 
   // Parameter :
   //
   //  - pBuffer        = Buffer to parse
   //  - parseBeginPos  = Parse beginning position
   //  - parseEndPos    = Parse end limit position
   //
   //--------------------------------------------------------------------
   void Parse( const TCHAR *pBuffer,
               int bufferSize,
               int parseBeginPos,
               int parseEndPos );

   // Override this to catch when keyword is found
   virtual void OnKeywordFound( Keyword *pKeyword );

   // Colors
   COLORREF                    m_commentColor;
   COLORREF                    m_foregroundColor;
   COLORREF                    m_backgroundColor;
   COLORREF                    m_highlightColor;

//----Class data members ----//
private:
   KeywordCategoryList         m_keywordCategoryList;
   RmShaderCharType            m_charTypeTable[65536];
  
   WhiteSpaceParser            m_whiteSpaceParser;
   TextParser                  m_textParser;
}; // End of RmMFCShaderSyntaxParser

#endif

---