一次性记录关键字，注释，字符串值，C++宏，运算符，括号配对的位置，并设置自定义数据颜色。2022-12-06版本

2022-12-26 更改：

(1) 修改了认不出 wchar_t 

(2)  加入了宏关键字

上次版本出现的问题：

 

执行郊果图：

 

 

 

 代码：

/// <summary>
/// 一次性记录关键字，注释，字符串值，运算符，宏，括号配对,预处理命令的位置,并设置自定义数据颜色
/// </summary>
/// <param name="CustomData">自定义数据</param>
/// <returns></returns>
/// 创建时间： 2022-12-24      最后一次修改时间：2022-12-26   
DList<TextColor> Syntax::GetTextColorPos_C(const DList<Pair<StringList, Color_>> &CustomData) const
{

    DList<TextColor> dtResult;

    //可见字符开始位置
    const _char* p = _code.c_str();

    //可见字符长度
    const int iTextLength = _code.length();

    if (iTextLength <= 0) return dtResult;
      
    log::d(iTextLength.ToString());


    _string sWord(_t(""), 50);  //50个_char缓冲

    Color_  cKeyWordColor = GetColor(SyntaxType::关键字);
    Color_  cExplanatoryNote = GetColor(SyntaxType::注释);
 
    Color_  cOS = GetColor(SyntaxType::运算符号);

    for (int i = 0; i < iTextLength; ++i)
    {
        _char c = p[i];

        if (c == _t('/'))
        {
            ++i;

            if (i < iTextLength)
            {
                if (p[i] == _t('/')) //是"//"注释，查找注释结束位置 \n ，跳过注释
                {
                    int iStart = i - 1;

                    ++i;

                    bool bFind = false; //查找下一个 "\n"
                    while (i < iTextLength)
                    {
                        if (p[i] == '\n')
                        {
                            //++i;
                            bFind = true;
                            break;
                        }
                        ++i;
                    }
                    if (!bFind)
                    {
                        return dtResult;
                    }
                    else
                    {
                        dtResult.Add(TextColor(iStart, i - iStart, cExplanatoryNote));
                    }
                }
                else if (p[i] == _t('*')) //是"/*"注释，查找注释结束位置 */ ，跳过注释
                {
                    int iStart = i - 1;

                    ++i;

                    bool bFind = false;
                    while (i + 1 < iTextLength ) //查找下一个 "*/"
                    {
                        if (p[i] == '*' && p[i + 1] == '/')
                        {
                            i += 2;
                            bFind = true;
                            break;
                        }
                        ++i;
                    }
                    if (!bFind)
                    {
                        return dtResult;
                    }
                    else
                    {
                        dtResult.Add(TextColor(iStart, i - iStart, cExplanatoryNote));
                    }
                }
            }
            else
            {
                return dtResult;
            }
        }
        else if (c == _t('\"')) {  //字符开始

            if (i - 1 > 0 && p[i - 1] != _t('\\'))
            {
                int iStart = i;

                ++i;

                bool bFind = false; //查找下一个 "\""

                while (i < iTextLength )
                {
                    if (p[i] == '\"' && p[i - 1] != _t('\\'))
                    {
                        ++i;
                        bFind = true;
                        break;
                    }
                    else if (p[i] == _t('\n')) //当前行已结束，还未找到引号配对
                    {
                        /*
                        SyntaxInfo si;

                        si.ErrorText = _t("当前行已结束，还未找到引号配对？");

                        si.ErrorText += _t("错误行号为第：");
                        si.ErrorLineNumber = _VisibleCode.GetLineIndexForCharIndex(i - 1);
                        si.ErrorText += _tostr(si.ErrorLineNumber + 1);
                        si.ErrorText += _t("行。");

                        //输出错误信息
                        PrintSyntaxCheckError(si.ErrorText);

                        _siList.Add(si);
                        */
                        ++i;
                        bFind = true;
                        break;
                    }

                    ++i;
                }
                if (!bFind)
                {
                    return dtResult;
                }
                else
                {
                    dtResult.Add(TextColor(iStart, i - iStart, Color_::字符串));
                }
            }
            else
            {
                ++i;
            }
        }
        else if (c == _t('\'')) { //字符开始

            if (i - 1 > 0 && p[i - 1] != _t('\\'))
            {
                int iStart = i;

                ++i;

                bool bFind = false; //查找下一个 "\'"

                while (i < iTextLength )
                {
                    if (p[i] == _t('\'') && p[i - 1] != _t('\\'))
                    {
                        ++i;
                        bFind = true;
                        break;
                    }
                    else if (p[i] == _t('\n')) //当前行已结束，还未找到引号配对
                    {
                        ++i;
                        bFind = true;
                        break;
                    }

                    ++i;
                }
                if (!bFind)
                {
                    return dtResult;
                }
                else
                {
                    dtResult.Add(TextColor(iStart, i - iStart, Color_::字符串));
                }
            }
            else
            {
                ++i;
            }
        }
        else if (Syntax::C_OperationalCharacter.IndexOf(c) != -1)
        {
            dtResult.Add(TextColor(i, 1, cOS));
        }
        else if (c == _t('{'))  //大括号查找全部文本
        {
            int iFlag = 0;

            for (int j = i + 1; j < iTextLength ; ++j)  //查找配对，直到遇到分号;
            {
                _char cRight = p[j];

                if (cRight == _t('}'))
                {
                    if (iFlag == 0)
                    {
                        Color_ c = Color_::RedRandom();
                        dtResult.Add(TextColor(i, 1, c));
                        dtResult.Add(TextColor(j, 1, c));
                        break;
                    }
                    --iFlag;
                }
                else if (cRight == _t('{'))
                {
                    ++iFlag;
                }
            }
        }
        else if (c == _t('['))
        {
            int iFlag = 0;
            for (int j = i + 1; j < iTextLength; ++j)  //查找配对，直到遇到分号;
            {
                _char cRight = p[j];

                if (cRight == _t(']'))
                {
                    if (iFlag == 0)
                    {
                        Color_ c = Color_::RedRandom();
                        dtResult.Add(TextColor(i, 1, c));
                        dtResult.Add(TextColor(j, 1, c));
                        break;
                    }
                    --iFlag;
                }
                else if (cRight == _t('['))
                {
                    ++iFlag;
                }
                else if (ga.c_IsPunctuation(cRight))  //遇到标点符号停止
                {
                    break;
                }
            }
        }
        else if (c == _t('('))
        {

            int iFlag = 0;
            for (int j = i + 1; j < iTextLength; ++j)  //查找配对，直到遇到分号;
            {
                _char cRight = p[j];

                if (cRight == _t(')'))
                {
                    if (iFlag == 0)
                    {
                        Color_ c = Color_::RedRandom();
                        dtResult.Add(TextColor(i, 1, c));
                        dtResult.Add(TextColor(j, 1, c));
                        break;
                    }
                    --iFlag;
                }
                else if (cRight == _t('('))
                {
                    ++iFlag;
                }
                else if (cRight == _t(';'))
                {
                    break;
                }
            }
        }
        else if (c == _t('<')) //这里究竟是小于号还是尖括号
        {
            int iFlag = 0;

            for (int j = i + 1; j < iTextLength; ++j)  //查找配对，直到遇到分号;
            {
                _char cRight = p[j];

                if (cRight == _t('>'))
                {
                    if (iFlag == 0)
                    {
                        Color_ c = Color_::RedRandom();
                        dtResult.Add(TextColor(i, 1, c));
                        dtResult.Add(TextColor(j, 1, c));
                        break;
                    }
                    --iFlag;
                }
                else if (cRight == _t('<'))
                {
                    ++iFlag;
                }
                else if (cRight == _t(';'))
                {
                    break;
                }
            }

        }
        else if (c == _t('#'))
        { //这里开始分析C++宏定义语法
         
            //#ifndef  _MS_WINDOWS_       正确
            //# ifndef _MS_WINDOWS_  正确
            //#include<test.h">
            //# include <test.h> 正确
            // # + 预处理命令 + ？
            
            int j = i + 1;


            while (j < iTextLength)
            {
                if (p[j] != _t(' ')) 
                {
                    sWord.Clear();

                    while (j < iTextLength)
                    {
                        if (gs.s_Syntax_IsIdentifierSeparator(p[j]))
                        {

                            if (this->C_Preprocessor.indexOf(sWord) != -1) //预处理关键字 
                            {
                                dtResult.Add(TextColor(i, sWord.length() + 1, Color_::Red));
                                sWord.Clear();
                            }
                            i = j; 
                            break;
                        }
                        else
                        {
                            sWord.add(p[j]);
                        }                      

                        ++j;
                    }
                    break;  
                }          

                ++j;                               
            }         
        }
       

        //开始查找，关键字，自定义类、等等

        if (gs.s_Syntax_IsWordSeparator(c))
        {
            if (sWord.length() > 0)
            {           
                bool bFind = false;

            
                //查找自定义数据
                auto pNote = CustomData.First();
                while (pNote != null)
                {
                    if (pNote->Data.first.findNoteItem(sWord) != null)
                    {
                        dtResult.Add(TextColor(i - sWord.length(), sWord.length(), pNote->Data.second));
                        bFind = true;
                        break;
                    }
                    pNote = pNote->Next;
                }
        

                if(!bFind) //自定义类和函数不能是关键字
                { 
                    //关键字最小长度大于2，且全是小写字母
                    if (sWord.length() >= 2)
                    {
                        if (C_Keyword.indexOf(sWord) != -1) //是关键字，记录位置
                        {
                            dtResult.Add(TextColor(i - sWord.length(), sWord.length(), cKeyWordColor));                     
                        }      
                    }
                }           

                //log::d(_getc(sWord));

                sWord.Clear(); //清空
            }
        }
        else
        {
            sWord.add(c);
        }
    }

    return dtResult;
}