C++词法分析（C#描述）

最新推荐文章于 2020-05-10 20:30:50 发布
最新推荐文章于 2020-05-10 20:30:50 发布
阅读量975 收藏 1
点赞数
文章标签： c++ c# token string exception class

近来开始学习编译原来，这是词法分析最基础的，在网上看到很多高手的作品，我也照着做了一个,有错别介意


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace 词法分析成功改造3
{
    class Program
    {
        static void Main(string[] args)
        {
            StreamReader reader = new StreamReader("D:/test.txt");
            string wholeText = reader.ReadToEnd();
            Console.WriteLine(wholeText + "\n\n");

            LexicalAnalysis manage = new LexicalAnalysis();
            Console.WriteLine(manage.Analysis(wholeText));

            Console.WriteLine("\n\n" + manage.ErrorNO());
            Console.WriteLine(LexicalAnalysis.AllWrongText);

            Console.Read();
        }

        #region 词法分析
        class LexicalAnalysis
        {
            /// <summary>
            /// 记录字符位置
            /// </summary>
            int i = 0, j = 0;                  

            /// <summary>
            /// 行号
            /// </summary>
            public static int LineNo = 1;                         

            /// <summary>
            /// 记录识别出的单词   
            /// </summary>
            string token = "";    
          
            /// <summary>
            /// 记录每一次得到的完整信息
            /// </summary>
            string text2 = "";

            /// <summary>
            /// 用来记录错误信息
            /// </summary>
            string text3 = "";                     
 
            /// <summary>
            /// 记录异常信息
            /// </summary>
            string wrong = "";                

            /// <summary>
            /// 错误字段的个数
            /// </summary>
            public static int errors = 0;           
      
            /// <summary>
            /// 记录错误的详细信息
            /// </summary>
            public static string AllWrongText = "";            
     
            /// <summary>
            /// 标记成对出现的界符
            /// </summary>
            int flag1 = 0, flag2 = 0, flag3, flag4, flag5, flag6 = 0;                       

            /// <summary>
            /// 关键字(部分)
            /// </summary>
            string[] keyWords = new string[32]{"auto", "double", "int","struct", "break", "else",
                "long","switch","case","enum","register","typedef","char","extern","return",
                "union","const","float","short","unsigned","continue","for","signed","void","default",
                "goto","sizeof","volatile","do","if","while","static" };

            /// <summary>
            /// 运算符
            /// </summary>
            string[] operatorWords = new string[28]{"+","-","*","/","%",">","<",">=","<=","==", "-=",
                "+=","*=","/=","!=","=","%=","&","&&","|","||","!","++","--","~","<<",">>","?:"};

            /// <summary>
            /// 边界符
            /// </summary>
            string[] boundWords = new string[15] { "{", "}", "[", "]", ";", ",", ".", 
                "(", ")", ":", "\"", "#", ">", "<", "\'" };

            /// <summary>
            /// 词法分析
            /// </summary>
            /// <param name="str">所要分析的句子</param>
            /// <returns>经过分析之后的句子</returns>
            public string Analysis(string str)
            {
                string space = "";                         //空格数
                if (str.Length == 0)                           //判断字符串是否为空
                    return "";
                try
                {
                    while (str[i] != '\0')  	//读入字符判断，空格、字母、数字、界符
                    {
                        if (str[i] == ' ' || str[i] == '\t' || str[i] == '\r')
                        {
                            i++;                                     //跳过无意义的字符
                        }
                        else if (str[i] == '\n')		//如果是换行符，则行号加1
                        {
                            LineNo++;
                            i++;
                        }

                        else if (IsLetter(str[i]))		//如果是字母
                        {
                            i = RecogniseLetter(str, i);
                            for (j = 0; j < keyWords.Length; j++)
                            {
                                if (token.CompareTo(keyWords[j]) == 0)
                                {
                                    break;
                                }
                            }

                            if (j >= keyWords.Length)					//是普通的标志符
                            {
                                for (int m = 0; m < 12 - token.Length; m++)
                                {
                                    space = space + " ";
                                }
                                text2 = text2 + LineNo.ToString() + ":  " + token + space + "标识符" + "\r\n";
                                token = "";
                                space = "";
                            }

                            if (j < keyWords.Length)								//是保留字
                            {
                                for (int m = 0; m < 12 - token.Length; m++)
                                    space = space + " ";
                                text2 = text2 + LineNo.ToString() + ":  " + keyWords[j] + space + "关键字" + "\r\n"; ;
                                token = "";
                                space = "";
                            }
                        }//end else if

                        else if (IsDigit(str[i]))		//如果是数字
                        {
                            i = RecogniseDigit(str, i);
                            for (int m = 0; m < 12 - token.Length; m++)
                            {
                                space = space + " ";
                            }
                            text2 = text2 + LineNo.ToString() + ":  " + token + space + "常量" + "\r\n";
                            token = "";
                            space = "";
                        }//end else if

                        else if (IsBound(str[i]))                  //识别界符
                        {
                            i = RecogniseBound(str, i);
                            for (int m = 0; m < 12 - token.Length; m++)
                            {
                                space = space + " ";
                            }
                            text2 = text2 + LineNo.ToString() + ":  " + token + space + "界符" + "\r\n"; ;
                            token = "";
                            space = "";
                        }//end else if

                        else if (IsOperator(str[i]))
                        {
                            i = RecogniseOperator(str, i);
                            for (int m = 0; m < 12 - token.Length; m++)
                            {
                                space = space + " ";
                            }
                            text2 = text2 + LineNo.ToString() + ":  " + token + space + "运算符" + "\r\n";
                            token = "";
                            space = "";
                        }//end else if

                        else
                        {
                            error(0); i++;
                        }
                    }//end while
                }//end try

                catch (DivideByZeroException e1)
                {
                    wrong = e1.Message;
                }
                catch (IndexOutOfRangeException e2)
                {

                    wrong = e2.Message;
                }
                catch (Exception e)
                {

                    wrong = e.Message;
                }

                return text2;
            }

            /// <summary>
            /// 判断字符是不是字母
            /// </summary>
            /// <param name="ch">待定字符</param>
            /// <returns>是否</returns>
            public bool IsLetter(char ch)
            {
                if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
                {
                    return true;
                }
                else
                    return false;
            }

            /// <summary>
            /// 判断字符是不是数字
            /// </summary>
            /// <param name="ch">待定字符</param>
            /// <returns>是否</returns>
            public bool IsDigit(char ch)
            {
                if (ch >= '0' && ch <= '9')
                {
                    return true;
                }
                else
                    return false;
            }

            /// <summary>
            /// 判断字符是不是下划线
            /// </summary>
            /// <param name="ch">待定字符</param>
            /// <returns>是否</returns>
            public bool IsUnderline(char ch)
            {
                if (ch == '_')
                    return true;
                else return false;
            }

            /// <summary>
            /// 判断字符是不是边界符
            /// </summary>
            /// <param name="ch">待定字符</param>
            /// <returns></returns>
            public bool IsBound(char ch)
            {
                for (int j = 0; j < boundWords.Length; j++)
                {
                    if (ch.CompareTo(boundWords[j][0]) == 0)
                    {
                        return true;
                    }
                }
                return false;
            }

            /// <summary>
            /// 判断字符是不是操作符
            /// </summary>
            /// <param name="ch">待定字符</param>
            /// <returns>是否</returns>
            public bool IsOperator(char ch)
            {
                for (int i = 0; i < operatorWords.Length; i++)
                {
                    if (ch == operatorWords[i][0])
                    {
                        return true;
                    }
                }
                return false;
            }

            /// <summary>
            /// 识别整个操作符
            /// </summary>
            /// <param name="str">字符串</param>
            /// <param name="i">字符串中字符的位置</param>
            /// <returns>字符位置</returns>
            private int RecogniseOperator(string str, int i)
            {
                char state = '0';
                string temp = "";

                while (state != '2')
                {
                    switch (state)
                    {
                        case '0':
                            temp += str[i];
                            i++;
                            state = '1';
                            break;

                        case '1':
                            //判断为双个运算符 
                            if (str.Substring(i - 1, 2) == "++" || str.Substring(i - 1, 2) == "--" || str.Substring(i - 1, 2) == "<<" || str.Substring(i - 1, 2) == ">>" || str.Substring(i - 1, 2) == "+=" || str.Substring(i - 1, 2) == "-=" || str.Substring(i - 1, 2) == "*=" || str.Substring(i - 1, 2) == "/=" || str.Substring(i - 1, 2) == "!=" || str.Substring(i - 1, 2) == "%=")
                            {
                                temp += str[i];
                                i++;
                                state = '2';
                            }
                            //三目运算符
                            if (str[i - 1] == '?' && str[i] == ':')
                            {
                                temp += str[i];
                                i++;
                                state = '2';
                            }
                            //不是运算符
                            else
                            {
                                state = '2';
                            }
                            break;
                    }//end switch
                }//end while

                token = temp;
                return i;
            }

            /// <summary>
            /// 识别普通的标识符
            /// </summary>
            /// <param name="str">用来识别的字符串</param>
            /// <param name="i">字符串中字符的位置</param>
            /// <returns>字符位置</returns>
            public int RecogniseLetter(string str, int i)                          //识别单词
            {
                char state = '0';
                string temp = "";                             //记录单词
                while (state != '2')
                {
                    switch (state)
                    {
                        case '0':
                            if (IsLetter(str[i]))
                            {
                                state = '1';
                                temp = temp + str[i];
                                i++;
                            }
                            break;

                        case '1':
                            if (IsLetter(str[i]) || IsDigit(str[i]) || IsUnderline(str[i]))
                            {
                                state = '1';
                                temp = temp + str[i];
                                i++;
                            }
                            else
                                state = '2';
                            break;
                    }//end switch
                }//end while

                token = temp;                   //记录识别的字符串
                return i;
            }

            /// <summary>
            /// 识别整个常熟
            /// </summary>
            /// <param name="str">待测字符串</param>
            /// <param name="i">字符串中字符的位置</param>
            /// <returns>字符位置</returns>
            public int RecogniseDigit(string str, int i)                                //识别常数
            {
                char state = '0';
                string temp = "";

                while (state != '2')
                {
                    switch (state)
                    {
                        case '0':
                            if (IsDigit(str[i]))
                            {
                                temp += str[i];
                                state = '1';
                                i++;
                            }
                            break;

                        case '1':
                            if (IsDigit(str[i]))
                            {
                                temp += str[i];
                                state = '1';
                                i++;
                            }
                            else if (str[i] == '.' && IsDigit(str[i + 1])) //有小数点的数                         
                            {
                                temp += str[i];
                                state = '1';
                                i++;
                            }
                            else 
                                state = '2';
                            break;
                    }//end switch                  
                }//end while

                token = temp;
                return i;
            }

            /// <summary>
            /// 识别标识符
            /// </summary>
            /// <param name="str">待测字符串</param>
            /// <param name="i">字符串中字符的位置</param>
            /// <returns>字符位置</returns>
            public int RecogniseBound(string str, int i)
            {
                string temp = "";
                for (int k = 0; k < boundWords.Length; k++)
                {
                    if (str[i].CompareTo(boundWords[k][0]) == 0)
                    {
                        temp += str[i];
                        i++;
                        break;
                    }
                    else 
                        continue;
                }//end for

                token = temp;

                //这些标志数是用来等会做错误判断用的（没有成双出现就是错误）
                if (token == "{" || token == "}")
                    flag1++;

                else if (token == "[" || token == "]")
                    flag2++;

                else if (token == "(" || token == ")")
                    flag3++;

                else if (token == "<" || token == ">")
                    flag4++;

                else if (token == "\'")
                    flag5++;

                else if (token == "\"")
                    flag6++;

                return i;
            }

            /// <summary>
            /// 得到已经识别的字符串
            /// </summary>
            /// <param name="str">字符串</param>
            /// <param name="k">字符位置</param>
            /// <returns>字符位置</returns>
            public int GetetToken(string str, int k)                       
            {
                switch (k)
                {
                    case 1:
                        for (int i = 0; i < keyWords.Length; i++)  //关键字
                        {
                            if (str == keyWords[i])
                                return i;
                        }
                        break;

                    case 2:
                        for (int i = 0; i < operatorWords.Length; i++)  //运算符
                        {
                            if (str == operatorWords[i])
                                return i + 32;   //+32的原因是keyWords中有32个关键字
                        }
                        break;

                    case 3:
                        for (int i = 0; i < boundWords.Length; i++) //界符
                        {
                            if (str == boundWords[i])
                                return i + 60;   //+60的原因是keyWords+operatorWords有60个
                        }
                        break;
                }//end switch

                return 0;
            }

            /// <summary>
            /// 错误个数
            /// </summary>
            /// <returns>错误信息</returns>
            public string ErrorNO()                                      
            {
                error(1);
                text3 = errors.ToString() + "   errors";
                return text3;
            }

            /// <summary>
            /// 错误信息
            /// </summary>
            /// <param name="k"></param>
            public void error(int k)                                     
            {
                switch (k)
                {
                    case 0:    //输入了非法字符
                        AllWrongText = AllWrongText + LineNo.ToString() + ": " + "非法字符" + "\r\n";  
                        errors++;
                        break;

                    case 1:   //界符不匹配
                        if (flag1 % 2 != 0)
                        {
                            AllWrongText = AllWrongText + "{ 不匹配" + "\r\n";
                            errors++;
                        }
                        if (flag2 % 2 != 0)
                        {
                            AllWrongText = AllWrongText + "[ 不匹配" + "\r\n";
                            errors++;
                        }
                        if (flag3 % 2 != 0)
                        {
                            AllWrongText = AllWrongText + "( 不匹配" + "\r\n";
                            errors++;
                        }
                        if (flag4 % 2 != 0)
                        {
                            AllWrongText = AllWrongText + "< 不匹配" + "\r\n";
                            errors++;
                        }
                        if (flag5 % 2 != 0)
                        {
                            AllWrongText = AllWrongText + "' 不匹配" + "\r\n";
                            errors++;
                        }
                        if (flag6 % 2 != 0)
                        {
                            AllWrongText = AllWrongText + " \" 不匹配" + "\r\n";
                            errors++;
                        }
                        break;
                }//end switch
            }

        }
        #endregion





    }
}


罗汉松驻扎的工作基地
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#实现词法分析器
02-29
C#实现的词法分析器，VS2010版本，比较简单，很容易懂
编译原理——词法分析程序(C#)
qq_40404477的博客
09-15 2248
词法分析实验目的与要求   编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类；要求能对五类单词符号进行正确的分析，给出相应的提示信息。 实验内容   对于这个实验，我主要使用了三种函数：文件读取函数，逐行分析函数，以及数据打印函数。 实验步骤   首先规定好程序中合法的关键字、边界符、运算符、关系符、以及用户定义变量表，程序中所出...
词法分析器（Lexical Analyzer）【C#实现】
数据联盟
12-16 3202
正文内容 using System; using System.IO; using System.Linq; using System.Collections.Generic; namespace Rosetta { public enum TokenType { End_of_input, Op_multiply, Op_divide, Op_mod, Op_...
词法分析器+语法分析器实现（c#桌面程序）
weixin_42865135的博客
05-10 2377
1.先定义对应的数据结构，这里将分隔符，操作符和关键字的集合定义了三个字典 public Dictionary<String, int> keyWordList = new Dictionary<String, int> { { "char",101},{"int", 102 },{"float",103 },{"break",104},{ "const",105}, {"return",106},{"void",107
C# 可视化——C++词法分析器
一叶舟遥
11-02 1323
实现了一个可用的C++语法分析器，从文件读取源代码，从左到右扫描每行该语言源程序的符号，拼成单词，换成统一的内部表示（token）。识别标识符、数字、特殊字符、关键字等类别，删除注释行和空白符，打印出每行包含的记号的二元形式到目标文件中去。 源文件： 程序运行、选择源文件：   源代码显示在textBox1中并标出行号： 点击生成文件按钮，启用语法分析并将文件保存在指定位置:...
WinForm程序C++词法分析器
10-30
实现了一个可用的C++语法分析器，从文件读取源代码，从左到右扫描每行该语言源程序的符号，拼成单词，换成统一的内部表示（token）。识别标识符、数字、特殊字符、关键字等类别，删除注释行和空白符，打印出每行包含...
词法分析器-程序转二元组-C#-VS2017
07-05
Win 10 系统下 Visual Studio 2017 下调试好的 CC# Winform 版 词法分析器。分析 C 语言程序，输入二元组（够详细注释）。内附具体使用方法。另外：附送 C++版 控制台词法分析器。 有不足不想完善了（几个运算符，界...
实现对C程序设计语言的源程序（自定）的词法分析 .exe
03-13
一个词法分析器，实现对自己输入的类C语言源程序中的所有单词进行分类，指出其所属类型，实现简单的词法分析操作。双击直接运行
用C#写的较完整的词法分析器
04-21
一个可以识别标识符,关健字,运算符和各种数字的词法分析器. 其中标识符，关键字，运算符，界符存储在一个四行的二维数组中，只要将需要识别的串加入到相应的数组中即可，而且不需要结束标志 例如： for(int i=0;i<intput.length;i++) 输出结果为： for：是关键字 (：是界符 int：是关键字 =：是算数运算符 0：是数字 ;：是界符 i：是标识符 <：是比较运算符 intput：是标识符 .：是界符 length：是关键字 ;：是界符 i：是标识符 ++：是算数运算符 )：是界符
简单词法分析器C#含代码
10-22
去年做的编译原理作业，由于时间紧迫，没有完成语法分析与语义分析，但拥有比较完善的界面（界面有两个，在主程序中可以修改使用哪个界面）。 词法规则如下： 关键字：int char if else real for do while 数字、变量名（不使用下划线，头字母不为数字）、符号 词法分析生成*.TAKEN、*.SymbolTable两个文件。 保留部分语法分析接口，可以继续完成。 词法分析部分在Lex文件夹下，生成中间数据存储的类在Data下。 由于老师给的语法分析规则太复杂（老师给的还是错的，我后来自己改的），而且在程序中还没有体现，故不上传，需要的可以来信索取，有完成的语法分析表（不知道是否正确……orz）。 注：在界面最下边……2009后面有一个箭头可以弹出菜单，选择"恢复默认设置"即可使用全部功能。将DisplayForm.cs中38-40行的 toolStrip1.Visible = false; toolStrip2.Visible = false; listBox1.Visible = false; 中false改为ture则默认显示全部组件。 本程序系自己完成，版权没有，盗版自由，个人完成程序均免资源分下载。 [email protected]
利用C#实现的词法语法分析器
03-13
利用C#实现的词法语法分析器，能解析运算表达式，有极强的参考价值
C#词法分析器之正则表达式的使用
09-05
本篇文章介绍了，C#词法分析器之正则表达式的使用。需要的朋友参考下
CodeConics:CodeConics是C＃词法分析器/解析器/语法树生成器-开源
04-26
与其他基于DFA（确定性有限状态自动机）的解决方案相比，CodeConics是一种简单，直观，易于使用和调试的代码处理解决方案，它独立于语法且基于递归。
c#词法分析器
12-31
自己用c#在vs05下调试出来的一个简单的词法分析器。可以分析c#,java.c++等程序的源代码！
仿查询分析器的C#计算器——3.词法分析
weixin_33724059的博客
06-22 449
承接上一篇，这一篇讲如何把表达式转换成记号对象，这里就涉及到了编译原理中的词法分析。关于编译原理我不想多讲，毕竟我自己也不怎么熟悉，现在只知道其中有个有限自动机的概念。不管什么概念，用代码实现才是最终目标。 因为不清楚字符串中到底包含什么字符，只能一个个字符进行处理，采用循环一次次向后取一个字符进行判断。这里建立一个TokenFactory记号“工厂”类，由这个类负责对表达式进行分析并“生产”...
c++词法分析代码实现
最新发布
12-31
然后可以使用编程语言（如C++）编写词法分析器的代码来实现词法分析的功能。 代码的实现可以大致分为以下几个步骤： 1. 定义c语言中的基本单词类型，例如关键字、标识符、常量、运算符和界符等。 2. 设置适当的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值