Index: indra/llui/llkeywords.cpp
===================================================================
--- indra/llui/llkeywords.cpp	(revision 338)
+++ indra/llui/llkeywords.cpp	(working copy)
@@ -59,6 +59,22 @@
 	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)
 {
 }
@@ -112,6 +128,7 @@
 	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;
@@ -143,6 +160,12 @@
 			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,7 +186,18 @@
 			// first word is keyword
 			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())
@@ -176,11 +210,11 @@
 			{
 				// 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  );
 			}
 		}
 	}
@@ -195,23 +229,26 @@
 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, LLWStringUtil::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, LLWStringUtil::null));
 		break;
 
 	case LLKeywordToken::TWO_SIDED_DELIMITER:
+	case LLKeywordToken::TWO_SIDED_DELIMITER_ESC:
 	case LLKeywordToken::ONE_SIDED_DELIMITER:
-		mDelimiterTokenList.push_front(new LLKeywordToken(type, color, key, tool_tip));
+		mDelimiterTokenList.push_front(new LLKeywordToken(type, color, key, tool_tip, delimiter));
 		break;
 
 	default:
@@ -342,12 +379,15 @@
 					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::TOKEN_TYPE type = cur_delimiter->getType();
+					if( type == LLKeywordToken::TWO_SIDED_DELIMITER || type == 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 (type == LLKeywordToken::TWO_SIDED_DELIMITER_ESC && *cur == '\\')
 							{
 								// Count the number of backslashes.
 								S32 num_backslashes = 0;
@@ -358,7 +398,7 @@
 									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.
@@ -384,7 +424,7 @@
 						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
 						{
Index: indra/llui/llkeywords.h
===================================================================
--- indra/llui/llkeywords.h	(revision 338)
+++ indra/llui/llkeywords.h	(working copy)
@@ -46,23 +46,27 @@
 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 ),
 		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();
@@ -73,6 +77,7 @@
 	LLWString	mToken;
 	LLColor3	mColor;
 	LLWString	mToolTip;
+	LLWString	mDelimiter;
 };
 
 class LLKeywords
@@ -90,7 +95,8 @@
 	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;
Index: indra/newview/app_settings/keywords.ini
===================================================================
--- indra/newview/app_settings/keywords.ini	(revision 338)
+++ indra/newview/app_settings/keywords.ini	(working copy)
@@ -557,9 +557,11 @@
 # 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.