Added viewer support for multiline comments

3 files changed, 69 insertions, 19 deletions

diff --git a/linden/indra/llui/llkeywords.cpp b/linden/indra/llui/llkeywords.cpp
index 35f032a..2d5f53d 100644
--- a/linden/indra/llui/llkeywords.cpp
+++ b/linden/indra/llui/llkeywords.cpp
@@ -58,6 +58,22 @@ inline BOOL LLKeywordToken::isHead(const llwchar* s) const
         return res;
 }
 
+inline BOOL LLKeywordToken::isTail(const llwchar* s) const
+{
+        BOOL res = TRUE;
+        const llwchar* t = mDelimiter.c_str();
+        S32 len = mDelimiter.size();
+        for (S32 i=0; i<len; i++)
+        {
+                if (s[i] != t[i])
+                {
+                        res = FALSE;
+                        break;
+                }
+        }
+        return res;
+}
+
 LLKeywords::LLKeywords() : mLoaded(FALSE)
 {
 }
@@ -111,6 +127,7 @@ BOOL LLKeywords::loadFromFile( const std::string& filename )
         std::string SOL_LINE("[line ");
         std::string SOL_ONE_SIDED_DELIMITER("[one_sided_delimiter ");
         std::string SOL_TWO_SIDED_DELIMITER("[two_sided_delimiter ");
+        std::string SOL_TWO_SIDED_DELIMITER_ESC("[two_sided_delimiter_esc ");
 
         LLColor3 cur_color( 1, 0, 0 );
         LLKeywordToken::TOKEN_TYPE cur_type = LLKeywordToken::WORD;
@@ -142,6 +159,12 @@ BOOL LLKeywords::loadFromFile( const std::string& filename )
                         cur_type = LLKeywordToken::TWO_SIDED_DELIMITER;
                         continue;
                 }
+                else if( line.find(SOL_TWO_SIDED_DELIMITER_ESC) == 0 )
+                {
+                        cur_color = readColor( line.substr(SOL_TWO_SIDED_DELIMITER_ESC.size()) );
+                        cur_type = LLKeywordToken::TWO_SIDED_DELIMITER_ESC;
+                        continue;
+                }
                 else if( line.find(SOL_ONE_SIDED_DELIMITER) == 0 )      
                 {
                         cur_color = readColor( line.substr(SOL_ONE_SIDED_DELIMITER.size()) );
@@ -163,6 +186,19 @@ BOOL LLKeywords::loadFromFile( const std::string& filename )
                         std::string keyword = (*token_word_iter);
                         LLStringUtil::trim(keyword);
 
+                        // second word may be right delimiter
+                        std::string delimiter = "";
+
+                        if (cur_type == LLKeywordToken::TWO_SIDED_DELIMITER || 
+                                cur_type == LLKeywordToken::TWO_SIDED_DELIMITER_ESC)
+                        {
+                                while (delimiter.length() == 0 && ++token_word_iter != word_tokens.end())
+                                {
+                                        delimiter = *token_word_iter;
+                                        LLStringUtil::trim(delimiter);
+                                }
+                        }
+
                         // following words are tooltip
                         std::string tool_tip;
                         while (++token_word_iter != word_tokens.end())
@@ -175,11 +211,11 @@ BOOL LLKeywords::loadFromFile( const std::string& filename )
                         {
                                 // Replace : with \n for multi-line tool tips.
                                 LLStringUtil::replaceChar( tool_tip, ':', '\n' );
-                                addToken(cur_type, keyword, cur_color, tool_tip );
+                                addToken(cur_type, keyword, cur_color, tool_tip, delimiter );
                         }
                         else
                         {
-                                addToken(cur_type, keyword, cur_color, LLStringUtil::null );
+                                addToken(cur_type, keyword, cur_color, LLStringUtil::null, delimiter );
                         }
                 }
         }
@@ -194,24 +230,27 @@ BOOL LLKeywords::loadFromFile( const std::string& filename )
 void LLKeywords::addToken(LLKeywordToken::TOKEN_TYPE type,
                                                   const std::string& key_in,
                                                   const LLColor3& color,
-                                                  const std::string& tool_tip_in )
+                                                  const std::string& tool_tip_in,
+                                                  const std::string& delimiter_in )
 {
         LLWString key = utf8str_to_wstring(key_in);
         LLWString tool_tip = utf8str_to_wstring(tool_tip_in);
+        LLWString delimiter = utf8str_to_wstring(delimiter_in);
         switch(type)
         {
         case LLKeywordToken::WORD:
-                mWordTokenMap[key] = new LLKeywordToken(type, color, key, tool_tip);
+                mWordTokenMap[key] = new LLKeywordToken(type, color, key, tool_tip, NULL);
                 break;
 
         case LLKeywordToken::LINE:
-                mLineTokenList.push_front(new LLKeywordToken(type, color, key, tool_tip));
+                mLineTokenList.push_front(new LLKeywordToken(type, color, key, tool_tip, NULL));
                 break;
 
         case LLKeywordToken::TWO_SIDED_DELIMITER:
         case LLKeywordToken::ONE_SIDED_DELIMITER:
-                mDelimiterTokenList.push_front(new LLKeywordToken(type, color, key, tool_tip));
-                break;
+        case LLKeywordToken::TWO_SIDED_DELIMITER_ESC:
+                mDelimiterTokenList.push_front(new LLKeywordToken(type, color, key, tool_tip, delimiter));
+                break;
 
         default:
                 llassert(0);
@@ -341,12 +380,13 @@ void LLKeywords::findSegments(std::vector<LLTextSegment *>* seg_list, const LLWS
                                         seg_start = cur - base;
                                         cur += cur_delimiter->getLength();
                                         
-                                        if( cur_delimiter->getType() == LLKeywordToken::TWO_SIDED_DELIMITER )
+                                        if( cur_delimiter->getType() == LLKeywordToken::TWO_SIDED_DELIMITER || LLKeywordToken::TWO_SIDED_DELIMITER_ESC)
                                         {
-                                                while( *cur && !cur_delimiter->isHead(cur))
+                                                llassert( cur_delimiter->getDelimiter() != NULL );
+                                                while( *cur && !cur_delimiter->isTail(cur))
                                                 {
                                                         // Check for an escape sequence.
-                                                        if (*cur == '\\')
+                                                        if (cur_delimiter->getType() == LLKeywordToken::TWO_SIDED_DELIMITER_ESC && *cur == '\\')
                                                         {
                                                                 // Count the number of backslashes.
                                                                 S32 num_backslashes = 0;
@@ -357,7 +397,7 @@ void LLKeywords::findSegments(std::vector<LLTextSegment *>* seg_list, const LLWS
                                                                         cur++;
                                                                 }
                                                                 // Is the next character the end delimiter?
-                                                                if (cur_delimiter->isHead(cur))
+                                                                if (cur_delimiter->isTail(cur))
                                                                 {
                                                                         // Is there was an odd number of backslashes, then this delimiter
                                                                         // does not end the sequence.
@@ -383,7 +423,9 @@ void LLKeywords::findSegments(std::vector<LLTextSegment *>* seg_list, const LLWS
                                                 if( *cur )
                                                 {
                                                         cur += cur_delimiter->getLength();
-                                                        seg_end = seg_start + between_delimiters + 2 * cur_delimiter->getLength();
+                                                        seg_end = seg_start + between_delimiters
+                                                                + cur_delimiter->getLength()
+                                                                + cur_delimiter->getLength2();
                                                 }
                                                 else
                                                 {
diff --git a/linden/indra/llui/llkeywords.h b/linden/indra/llui/llkeywords.h
index e3361f6..742383a 100644
--- a/linden/indra/llui/llkeywords.h
+++ b/linden/indra/llui/llkeywords.h
@@ -45,23 +45,27 @@ class LLTextSegment;
 class LLKeywordToken
 {
 public:
-        enum TOKEN_TYPE { WORD, LINE, TWO_SIDED_DELIMITER, ONE_SIDED_DELIMITER };
+        enum TOKEN_TYPE { WORD, LINE, TWO_SIDED_DELIMITER, ONE_SIDED_DELIMITER, TWO_SIDED_DELIMITER_ESC };
 
-        LLKeywordToken( TOKEN_TYPE type, const LLColor3& color, const LLWString& token, const LLWString& tool_tip ) 
+        LLKeywordToken( TOKEN_TYPE type, const LLColor3& color, const LLWString& token, const LLWString& tool_tip, const LLWString& delimiter )
                 :
                 mType( type ),
-                mToken( token ),
+                mToken( token ),                        // keyword or left delimiter
                 mColor( color ),
-                mToolTip( tool_tip )
+                mToolTip( tool_tip ),
+                mDelimiter( delimiter )         // right delimiter
         {
         }
 
         S32                                     getLength() const               { return mToken.size(); }
+        S32                                     getLength2() const              { return mDelimiter.size(); }
         BOOL                            isHead(const llwchar* s) const;
+        BOOL                            isTail(const llwchar* s) const;
         const LLWString&        getToken() const                { return mToken; }
         const LLColor3&         getColor() const                { return mColor; }
         TOKEN_TYPE                      getType()  const                { return mType; }
         const LLWString&        getToolTip() const              { return mToolTip; }
+        const LLWString&        getDelimiter() const    { return mDelimiter; }
 
 #ifdef _DEBUG
         void            dump();
@@ -72,6 +76,7 @@ private:
         LLWString       mToken;
         LLColor3        mColor;
         LLWString       mToolTip;
+        LLWString       mDelimiter;
 };
 
 class LLKeywords
@@ -89,7 +94,8 @@ public:
         void addToken(LLKeywordToken::TOKEN_TYPE type,
                                         const std::string& key,
                                         const LLColor3& color,
-                                        const std::string& tool_tip = LLStringUtil::null);
+                                        const std::string& tool_tip = LLStringUtil::null,
+                                        const std::string& delimiter = LLStringUtil::null);
 
         typedef std::map<LLWString, LLKeywordToken*> word_token_map_t;
         typedef word_token_map_t::const_iterator keyword_iterator_t;
diff --git a/linden/indra/newview/app_settings/keywords.ini b/linden/indra/newview/app_settings/keywords.ini
index 3679c38..28ecb00 100644
--- a/linden/indra/newview/app_settings/keywords.ini
+++ b/linden/indra/newview/app_settings/keywords.ini
@@ -551,9 +551,11 @@ return				Leave current function or event handler
 # Comment
 [one_sided_delimiter .8, .3, .15]
 //                                      Comment:Non-functional commentary or disabled code
+[two_sided_delimiter .8, .3, .15]
+/*      */                              Comment:Non-functional commentary or disabled code
 
 # String literals
-[two_sided_delimiter 0, .2, 0]
-"                                       String literal
+[two_sided_delimiter_esc 0, .2, 0]
+"       "                               String literal
 
 #functions are supplied by the program now.