记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）-天翼云

记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）

2024-11-22 08:10:33 阅读次数：31

上次版本，遇到字符串错误语法会终止，或者在字符串中

有引号，也会不正确：

记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）

修改后：

记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）

/// <summary>
///  记录C，C++关键字的位置，跳过注释和字符串文本。
/// </summary>
/// <returns></returns>
/// 创建时间： 2022-12-19      最后一次修改时间：2022-12-21  已测试
DList<TextColor> Syntax::GetTextColorPosForC_Keywords3() const
{ 

    DList<TextColor> dtResult;

    if (_code.length() <= 0) return dtResult;

    const _char* p = _code.c_str();

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

    Color_  cKeyWordColor = GetColor(SyntaxType::关键字);

    for (int i = 0; i < _code.length(); ++i)
    {
        if (p[i] == _t('/'))
        {
            ++i;

            if (i < _code.length())
            {
                if (p[i] == _t('/')) //是"//"注释，查找注释结束位置 \n ，跳过注释
                {
                    ++i;

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

                    bool bFind = false;
                    while (i + 1 < _code.length()) //查找下一个 "*/"
                    {
                        if (p[i] == '*' && p[i + 1] == '/')
                        {
                            i += 2;
                            bFind = true;
                            break;
                        }
                        ++i;
                    }
                    if (!bFind) return dtResult;
                }
            }
            else
            {
                return dtResult;
            }
        }
        else if (p[i] == _t('\"')) //字符开始
        {
            if (i - 1 > 0 && p[i - 1] != '\\')
            {
                ++i;

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

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

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

                        ei.Text += _t("错误行号为第：");
                        ei.LineNumber = _code.GetLineIndexForCharIndex(i - 1);
                        ei.Text += _tostr(ei.LineNumber + 1);
                        ei.Text += _t("行。");
                      
                        //输出错误信息
                        PrintSyntaxCheckError(ei.Text);
                        
                        Error.Add(ei);

                        ++i;
                        bFind = true;
                        break;
                    }

                    ++i;
                }
                if (!bFind) return dtResult;
            }
            else
            {
                ++i;
            }
        }

        if (gs.s_Syntax_IsWordSeparator(p[i]))
        {
            //关键字最小长度大于2，且全是小写字母
            if (sWord.length() >= 2 && sWord.IsAllLowerCaseEnglishLetter())
            {
                if (C_Keyword.findNoteItem(sWord) != null) //是关键字，记录位置
                {
                    dtResult.Add(TextColor(i - sWord.length(), sWord.length(), cKeyWordColor));
                }

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


            sWord.Clear(); //清空
        }
        else
        {
            sWord.add(p[i]);
        }
    }

    return dtResult;
}

之前版本：

依据第二版本，可以写一个跳过注释的查找函数

C_IndexOfWord

Java_IndexOfWord

CSharp_IndexOfWord

还有一种方法，可以先把所有注释用空格代替，查出的字符位置也不变。

以前版本：

记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）

DList<TextColor> Syntax::GetTextColorPosForC_Keywords1() const
{
DList<TextColor> dtResult;
int nPos = -1;

if (_LanguageType == LanguageType::C)//-----------------------------------C&C++ Begin
{

//-----------------------------------------------------------------关键字
for (_string s : C_Keyword)
{
nPos = _code.IndexOfWord(s);

while (nPos != -1)
{
dtResult.Add(TextColor(nPos, s.length(), GetColor(SyntaxType::关键字)));

nPos = _nh_en.IndexOfWord(s, nPos + s.length());
}
}
}

return dtResult;
}

修改版本：

记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）

/// <summary>
/// 记录C，C++关键字的位置，跳过注释和字符串文本。
/// </summary>
/// <returns></returns>
/// 创建时间： 2022-12-19 最后一次修改时间：2022-12-19
DList<TextColor> Syntax::GetTextColorPosForC_Keywords2() const
{
DList<TextColor> dtResult;

if (_code.length() <= 0) return dtResult;

const _char *p = _code.c_str();

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

Color_ cKeyWordColor = GetColor(SyntaxType::关键字);

for(int i = 0; i < _code.length(); ++ i)
{
if ( p[i] == _t('/'))
{
if (i + 1 < _code.length())
{
if (p[i + 1] == _t('/') ) //是"//"注释，查找注释结束位置 \n ，跳过注释
{
i += 2;
while (p[i] != 0 && p[i] != '\n')
{
++i;
}
}
else if (p[i + 1] == _t('*')) //是"/*"注释，查找注释结束位置 */ ，跳过注释
{
i += 2;
while (p[i] != 0 && p[i] != _t('*'))
{
if (p[i + 1] != 0 && p[i + 1] != '/') //结束位置
{
++i;
}
else
{
++i;
break;
}
}
}
}
else
{
return dtResult;
}
}
else if (p[i] == _t('\"')) //字符开始
{
++i;
while(p[i] != 0 && p[i] != '\"')
{
++i;
}
}

if (gs.s_Syntax_IsWordSeparator(p[i]))
{
//关键字最小长度大于2，且全是小写字母
if (sWord.length() >= 2 && sWord.IsAllLowerCaseEnglishLetter())
{
if (C_Keyword.findNoteItem(sWord) != null) //是关键字，记录位置
{
dtResult.Add(TextColor(i - sWord.length(), sWord.length(), cKeyWordColor));
}

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

sWord.Clear(); //清空
}
else
{
sWord.add(p[i]);
}
}

return dtResult;
}

记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）

/// <summary>
///  记录C，C++关键字的位置，跳过注释和字符串文本。
/// </summary>
/// <returns></returns>
/// 创建时间： 2022-12-19      最后一次修改时间：2022-12-19
DList<TextColor> Syntax::GetTextColorPosForC_Keywords2() const
{
    DList<TextColor> dtResult;

    if (_code.length() <= 0) return dtResult;

    const _char *p = _code.c_str();
         
    _string sWord(_t(""), 50);  //50个_char缓冲

    Color_  cKeyWordColor = GetColor(SyntaxType::关键字);

    for(int i = 0; i < _code.length(); ++ i)
    {
        if ( p[i] == _t('/'))
        {
            if (i + 1 < _code.length())
            {
                if (p[i + 1] == _t('/') ) //是"//"注释，查找注释结束位置 \n ，跳过注释
                {
                    i += 2;
                    while (p[i] != 0 && p[i] != '\n')
                    {
                        ++i;
                    }
                }
                else if (p[i + 1] == _t('*')) //是"/*"注释，查找注释结束位置 */ ，跳过注释
                {
                    i += 2;
                    while (p[i] != 0 && p[i] != _t('*'))
                    { 
                        if (p[i + 1] != 0 && p[i + 1] != '/') //结束位置
                        {
                            ++i;
                        }
                        else
                        {
                            ++i;
                            break;
                        }
                    }
                }
            }
            else
            {
                return dtResult;
            }      
        }
        else if (p[i] == _t('\"')) //字符开始
        {
            ++i;
            while(p[i] != 0 && p[i] != '\"')
            {
               ++i;   
            }         
        }

        if (gs.s_Syntax_IsWordSeparator(p[i]))
        {
            //关键字最小长度大于2，且全是小写字母
            if (sWord.length() >= 2 && sWord.IsAllLowerCaseEnglishLetter())
            {
                if (C_Keyword.findNoteItem(sWord) != null) //是关键字，记录位置
                {
                    dtResult.Add(TextColor(i - sWord.length(), sWord.length(), cKeyWordColor));
                }

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

            sWord.Clear(); //清空
        }
        else
        {
            sWord.add(p[i]);
        }         
    }

    return dtResult;
}

其中：

   /// <summary>
   /// 判断字符是否单词的有效分隔符
   /// </summary>
   /// <param name="c"></param>
   /// <returns></returns>
   inline static bool s_Syntax_IsWordSeparator(_char c) {
       return (gs.c_IsPunctuation(c) || gs.c_IsControl(c) || Math_::strchr(IdentifierSpecial, c) != -1) && c != _t('_');
   }

const _char* global_c_str::IdentifierSpecial = _t("~!@#$%^&*()+-/.{}[]|\\ `=");

虽然结果正确，但不严谨，以下修正：

/// <summary>
///  记录C，C++关键字的位置，跳过注释和字符串文本。
/// </summary>
/// <returns></returns>
/// 创建时间： 2022-12-19      最后一次修改时间：2022-12-21  已测试
DList<TextColor> Syntax::GetTextColorPosForC_Keywords2() const
{
    DList<TextColor> dtResult;

    if (_code.length() <= 0) return dtResult;

    const _char *p = _code.c_str();
         
    _string sWord(_t(""), 50);  //50个_char缓冲

    Color_  cKeyWordColor = GetColor(SyntaxType::关键字);

    for(int i = 0; i < _code.length(); ++ i)
    {
        if ( p[i] == _t('/'))
        {
            ++i;

            if (i < _code.length())
            {
                if (p[i] == _t('/') ) //是"//"注释，查找注释结束位置 \n ，跳过注释
                {
                    ++i;

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

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

        if (gs.s_Syntax_IsWordSeparator(p[i]))
        {
            //关键字最小长度大于2，且全是小写字母
            if (sWord.length() >= 2 && sWord.IsAllLowerCaseEnglishLetter())
            {
                if (C_Keyword.findNoteItem(sWord) != null) //是关键字，记录位置
                {
                    dtResult.Add(TextColor(i - sWord.length(), sWord.length(), cKeyWordColor));
                }

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

            sWord.Clear(); //清空
        }
        else
        {
            sWord.add(p[i]);
        }         
    }

    return dtResult;
}

另加上查找函数：

/// <summary>
	/// 跳过注释和字符串值查找字符，这里假设注释和字符串书写模式正确，而且你
	/// 不要去查找一个双引号（ '\"'） ,永远都返回-1。
	/// </summary>
	/// <param name="c"></param>
	/// <param name="iFindStart"></param>
	/// <param name="bMatchCase"></param>
	/// <returns></returns>
	/// 创建时间： 2021-12-21      最后一次修改时间：2022-12-21    已测试
	int Syntax_C_IndexOf(const _char c, const int iFindStart = 0)const
	{
		int iStart = iFindStart <= 0 ? 0 : iFindStart;

		if (c == 0 || _nLength <= 0 || iStart >= _nLength) return -1;

		const _char* p = _pData;

		for (int i = iStart; i < _nLength; ++i)
		{
			if (p[i] == _t('/'))
			{
				++i;

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

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

		}

		return -1;
	}

记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）

版权声明：本文内容来自第三方投稿或授权转载，原文地址：https://blog.csdn.net/weixin_42944928/article/details/128383320，作者：碧海蓝天2022，版权归原作者所有。本网站转在其作品的目的在于传递更多信息，不拥有版权，亦不承担相应法律责任。如因作品内容、版权等问题需要同本网站联系，请发邮件至ctyunbbs@chinatelecom.cn沟通。

活动

智算服务

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）

记录C，C++关键字的位置，直接跳过注释和字符串文本。（再次修正，加上字符串语法检查）

上次版本，遇到字符串错误语法会终止，或者在字符串中

有引号，也会不正确：

修改后：

之前版本：

依据第二版本，可以写一个跳过注释的查找函数

C_IndexOfWord

Java_IndexOfWord

CSharp_IndexOfWord

还有一种方法，可以先把所有注释用空格代替，查出的字符位置也不变。

以前版本：

虽然结果正确，但不严谨，以下修正：

另加上查找函数：

相关文章

52.介绍AOP有几种实现方式

C语言练习之猜名次-----A选手说：B第二，我第三；B选手说：我第二，E第四；C选手说：我第一，D第二；D选手说：C最后，我第三；E选手说：我第四，A第一；

30天拿下Rust之切片

30天拿下Rust之字符串

C++ 11新特性之完美转发

函数索引测试

磁盘组扩容测试01

ORA-00823异常处理

添加控制文件—场景(DG备库)—采用Switchover方式

添加控制文件—场景(磁盘组+RAC)

作者介绍

最新文章

C语言练习之猜名次-----A选手说：B第二，我第三；B选手说：我第二，E第四；C选手说：我第一，D第二；D选手说：C最后，我第三；E选手说：我第四，A第一；

52.介绍AOP有几种实现方式

C++ 11新特性之完美转发

函数索引测试

磁盘组扩容测试01

C语言：深入理解指针(2)

热门文章

驱动开发：内核封装WSK网络通信接口

驱动开发：摘链DKOM进程隐藏

HTML介绍与开发环境的搭建

SDL SDL_Delay代码剖析

THINKPHP5近期暴露的漏洞

datafuse基于rust 开发的实时数据处理&&dbms分析系统

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

Java学习笔记（1.0）

【C++笔试强训】

【C++ 01背包 动态规划】879. 盈利计划|2204

时间复杂度O(40n*n)的C++算法：2699修改图中的边权

从生产到消费，设计基于物料的前端开发链路-------------引用

C++双指针算法：1782统计点对的数目

【C++ 01背包动态规划】879. 盈利计划|2204