一个简单的词法分析器

最新推荐文章于 2020-03-23 08:13:00 发布
最新推荐文章于 2020-03-23 08:13:00 发布
阅读量331 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42793225/article/details/81840417
版权 
public class Lexer
    {
        private LexerSetting _setting = LexerSetting.Default;
        private readonly string[] Operators = new string[] { "&&", "||", "==", "=", "!=", ">=", "<=", "<>", ">", "<", "+", "-", "*", "/", "%", "^", "~", "!", ".", "&", "|" };
        internal Lexer(string sou)
        {
            source = sou;
            cursor = 0;
            if (string.IsNullOrEmpty(source))
            {
                length = 0;
                eof = true;
            }
            length = source.Length;
        }
        public Lexer(string sou, LexerSetting setting) : this(sou)
        {
            _setting = setting;
        }
        /// <summary>
        /// 重置当前词法解析器的游标
        /// </summary>
        public void Reset()
        {
            cursor = 0;
        }
        private void Next(int offset = 1)
        {
            cursor += offset;
            if (cursor >= length)
            {
                eof = true;
            }
        }
        private char Preview(int offset)
        {
            if (cursor + offset >= length || cursor + offset < 0)
            {
                return '\0';
            }
            return source[cursor + offset];
        }
        private readonly string source;
        private int cursor = 0;//游标
        private readonly int length;//解析源的长度
        private bool eof = false;//是否已经到达源的末尾
        /// <summary>
        /// 获取当前位置的字符
        /// </summary>
        private char cur
        {
            get
            {
                if (eof)
                {
                    return '\0';
                }
                return source[cursor];
            }
        }
        /// <summary>
        /// 抛出异常
        /// </summary>
        /// <param name="msg"></param>
        private void ex(string msg)
        {
            string context = GetContext(cursor);
            throw new LexerException(msg, context) { Position = cursor };
        }

        public string GetContext(int pos)
        {
            int idx = Math.Max(0, pos - 20);
            var lgh = Math.Min(40, source.Length - idx);
            string context = source.Substring(idx, lgh);
            return context;
        }
        /// <summary>
        /// 发出警告
        /// </summary>
        /// <param name="msg"></param>
        private void waring(string msg)
        {
            //预留
        }

        #region 字符断言
        /// <summary>
        /// 判断字符是否为表示名称标识的文字
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        private bool isLiteral(char c)
        {
            if (c == '_' || char.IsDigit(c) || char.IsLetter(c) || (c >= 0x4e00 && c <= 0x9fbb))//下划线、数字、字母、汉字
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 判断字符是否为表示名称标识的文字的有效首字符
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        private bool isLiteralFirst(char c)
        {
            if (c == '_' || char.IsLetter(c) || (c >= 0x4e00 && c <= 0x9fbb))//下划线、数字、字母、汉字
            {
                return true;
            }
            if (_setting.LiteralFirstChars != null)
            {
                //用户自定义的变量名首字母
                foreach (var item in
                _setting.LiteralFirstChars)
                {
                    if (c == item)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        //是否是运算符
        private bool isOperator(char c)
        {
            switch (c)
            {//四则运算
                case '+':
                case '-':
                case '*':
                case '/':
                //逻辑运算
                case '|':
                case '&':
                //比较运算
                case '>':
                case '<':
                case '=':
                case '!':
                //其他
                case '%'://取模
                case '~'://按位取反
                case '^':
                case '.'://属性/函数读取
                    return true;
                default:
                    return false;
            }
        }

        #endregion

        private void SkipWhiteSpace()
        {
            var c = cur;
            while (char.IsWhiteSpace(c) && !eof)
            {
                Next();
                c = cur;
            }
        }
        private Token token(TokenType type, string content, int pos)
        {
            return new Token(type, content) { Position = pos };
        }
        public Token ReadToken()
        {
            SkipWhiteSpace();
            int startPos = cursor;
            var com = readComments();
            if (com != null)
            {
                return com;
            }
            char c = cur;
            if (c == '(' || c == ')')
            {
                Next();
                return token(TokenType.Bracket, c.ToString(), startPos);
            }
            else if (c == '[' || c == ']')
            {
                Next();
                return token(TokenType.Bracket, c.ToString(), startPos);
            }
            else if (c == '{' || c == '}')
            {
                Next();
                return token(TokenType.Bracket, c.ToString(), startPos);
            }
            else if (c == ',')
            {
                Next();
                return token(TokenType.Comma, c.ToString(), startPos);
            }
            else if (c == ':')
            {
                Next();
                return token(TokenType.Colon, c.ToString(), startPos);
            }
            else if (c == '?')
            {
                Next();
                return token(TokenType.Question, c.ToString(), startPos);
            }
            else if (c == ';')
            {
                Next();
                return token(TokenType.Semicolon, c.ToString(), startPos);
            }
            else if (c == '`')
            {
                Next();
                return token(TokenType.Confine, c.ToString(), startPos);
            }
            else if (c == _setting.StringSign)
            {
                return readString();
            }
            else if (c == '\0')
            {
                return token(TokenType.End, "\0", startPos);
            }
            else if (char.IsDigit(c))
            {//为数字
                return readNumeric();
            }
            else if (readKeyword() is Token tk)
            {
                return tk;
            }
            else if (readCustomOperator() is Token t)
            {
                return t;
            }
            else if (isLiteralFirst(c))
            {//为名称标识
                return readLiteral();
            }
            else if (isOperator(c))
            {
                return readOperator();
            }
            else
            {
                ex("语法错误，在当前位置不可识别的字符：[" + c + "]");
            }

            return null;
        }
        /// <summary>
        /// 解析当前源
        /// </summary>
        /// <returns></returns>
        public Token[] Reslove()
        {
            this.Reset();
            List<Token> l = new List<Token>();
            Token t = null;
            do
            {
                t = this.ReadToken();
                l.Add(t);
            } while (t != null && t.Type != TokenType.End);
            this.Reset();
            return l.ToArray();
        }

        private Token readComments()
        {
            int startPos = cursor;
            var com = _setting.OutlineCommentsSign;
            StringBuilder sb = new StringBuilder(20);
            if (matchText(com))
            {//注释开始
                Next(com.Length);
                var c = cur;
                while (c != '\n' && !eof)
                {
                    sb.Append(c);
                    Next();
                    c = cur;
                }
                return token(TokenType.Comments, sb.ToString(), startPos);
            }
            if (matchText(_setting.InlineCommentsStartSign))
            {//行内注释开始
                if (string.IsNullOrEmpty(_setting.InlineCommentsEndSign))
                {//未指定行内注释的结束符号，该设置无效。
                    waring("未指定行内注释的结束符号，该设置无效。");
                    return null;
                }
                Next(_setting.InlineCommentsStartSign.Length);
                var endchar = _setting.InlineCommentsEndSign[0];
                var c = cur;
                while (!eof)
                {
                    if (c == endchar)
                    {
                        if (matchText(_setting.InlineCommentsEndSign))
                        {//行内注释结束
                            Next(_setting.InlineCommentsEndSign.Length);
                            return token(TokenType.Comments, sb.ToString(), startPos);
                        }
                    }
                    sb.Append(c);
                    Next();
                    c = cur;
                }
                //直到结尾行内注释都没结束。
                ex("直到文档结尾，未发现行内注释的结束符号：[" + _setting.InlineCommentsEndSign + "]");
            }
            return null;
        }
        /// <summary>
        /// 尝试从当前位置匹配一段固定的字符串
        /// </summary>
        /// <returns></returns>
        private bool matchText(string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                return false;
            }
            for (int i = 0; i < text.Length; i++)
            {

                if (!charEquls(Preview(i), text[i]))
                {
                    return false;
                }
            }
            return true;
        }
        /// <summary>
        /// 根据给定的设置比较两个字符
        /// </summary>
        /// <param name="c1"></param>
        /// <param name="c2"></param>
        /// <returns></returns>
        private bool charEquls(char c1, char c2)
        {
            if (_setting.IgnoreCase)
            {//忽略大小写
                return c1.ToString().ToUpper() == c2.ToString().ToUpper();
                //return string.Compare(c1.ToString(), c2.ToString(), true) == 0;
            }
            else
            {
                return c1 == c2;
            }
        }
        /// <summary>
        /// 读取一个符号符号表示的运算符
        /// </summary>
        /// <returns></returns>
        private Token readOperator()
        {
            int startPos = cursor;
            StringBuilder sb = new StringBuilder(2);
            var c = cur;
            if (Operators != null)
            {
                foreach (var item in Operators)
                {
                    if (matchText(item))
                    {
                        Next(item.Length);
                        return token(TokenType.Operator, item, startPos);
                    }
                }
            }
            return null;
        }
        /// <summary>
        /// 从当前位置获取一个自定义的操作符，不存在则返回null。
        /// </summary>
        /// <returns></returns>
        private Token readCustomOperator()
        {
            int startPos = cursor;
            StringBuilder sb = new StringBuilder(6);
            if (_setting.CustomOperators != null)
            {
                foreach (var item in _setting.CustomOperators)
                {
                    if (matchText(item) && !isLiteral(Preview(item.Length)))
                    {
                        Next(item.Length);
                        return token(TokenType.Operator, item, startPos);
                    }
                }
            }
            return null;
        }
        /// <summary>
        /// 读取一个关键字
        /// </summary>
        /// <returns></returns>
        private Token readKeyword()
        {
            int startPos = cursor;
            StringBuilder sb = new StringBuilder(6);
            if (_setting.Keywords != null)
            {
                foreach (var item in _setting.Keywords)
                {
                    if (matchText(item) && !isLiteral(Preview(item.Length)))
                    {//完整匹配关键字并且关键字不是其他标识符的一部分
                        Next(item.Length);
                        return token(TokenType.Keyword, item, startPos);
                    }
                }
            }
            return null;
        }
        //读取一个数字
        private Token readNumeric()
        {
            int startPos = cursor;
            StringBuilder sb = new StringBuilder(5);
            var c = cur;
            bool dotexists = false;//是否已经存在小数点
            while (char.IsDigit(c) || c == '.')
            {
                if (c == '.')
                {
                    if (dotexists)
                    {
                        ex("尝试读取一串数字，但是似乎出现了多个小数点。");
                    }
                    dotexists = true;
                }
                sb.Append(c);
                Next();
                c = cur;
            }
            return token(TokenType.Numeric, sb.ToString(), startPos);
        }
        /// <summary>
        /// 读取文字，包括关键字、表名、列名、函数名等。
        /// </summary>
        /// <returns></returns>
        private Token readLiteral()
        {
            int startPos = cursor;
            StringBuilder sb = new StringBuilder(10);
            var c = cur;
            while (isLiteral(c) || isLiteralFirst(c))
            {
                sb.Append(c);
                Next();
                c = cur;
            }
            return token(TokenType.Literal, sb.ToString(), startPos);
        }
        /// <summary>
        /// 读取一段字符串
        /// </summary>
        /// <returns></returns>
        private Token readString()
        {
            int startPos = cursor;
            StringBuilder sb = new StringBuilder(10);
            Next();//跳过字符串的开头标识
            char c = cur;
            while (!eof)
            {
                c = cur;
                if (c == _setting.StringSign)
                {//字符串内遇到字符串标识
                    if (_setting.TransferredType == TransferredType.DoubleSign && Preview(1) == _setting.StringSign)
                    {//双标识转义
                     //转义，忽略双标识。
                        sb.Append(_setting.StringSign);
                        Next(2);
                        continue;
                    }
                    else
                    {//结束字符串
                        Next();
                        goto end;
                    }
                }
                else if (c == '\\' && _setting.TransferredType == TransferredType.UseBackslash && Preview(1) == _setting.StringSign)//反斜杠转义
                {//忽略反斜杠
                    sb.Append(_setting.StringSign);
                    Next(2);
                    continue;
                }
                else if (c == '\n' || c == '\r')
                {
                    ex($"读取一段字符串时发生异常：字符串内不支持换行符，请检查字符串是否正常闭合，如需换行请使用转义符[\\n或\\r]。");
                }
                sb.Append(c);
                Next();
            }
            ex($"读取一段字符串时发生异常：未发现匹配的字符串结束标识[{_setting.StringSign}]。");
            end:
            return token(TokenType.String, sb.ToString(), startPos);
        }

    }

完整的源码请关注我的公众号，回复”GeneralSQL“查看
我的公众号

欢迎加入技术交流群：14966975

howay!
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Delphi做的用于分析Pascal语言的词法分析器
11-14
编译原理词法分析器，上学时做的，当时花了我许多功夫，现在看来做的还是很不错的。
简单的词法分析器
05-20 703
using System.Data;using System.Drawing;using System.Text;using System.Windows.Forms;namespace cifa{            public partial class 词法分析 : System.Windows.Forms.Form        {            private Syste
手写一个词法分析器
crossoverJie专栏
03-23 346
前言最近大部分时间都在撸 Python，其中也会涉及到将数据库表转换为 Python 中 ORM 框架的 Model，但我们并没有找到一个合适的工具来做...
词法分析器
05-12 682
词法分析器
具备词法分析的Delphi表达式计算程序.rar
07-10
具备语法分析的Delphi表达式计算程序，表达式计算DEMO，利用词法分析器原理，以及后缀表达式计算，暂不支持函数以及乘号省略。
词法分析器_词法分析器_简单的词法分析器_
10-03
词法分析器，也称为扫描器或词法分析程序，是编译器设计中的一个重要组成部分。它的主要任务是将源代码文本...同时，这个简单的实现也为我们提供了一个研究和修改的基础，便于我们进一步理解和定制自己的词法分析器。
一个简易的c语言词法分析器
10-29
这个简易的C语言词法分析器提供了一个实践平台，可以让学生逐步了解如何从字符流中提取有意义的信息，并转化为编译器可以理解的标记。通过阅读和修改这个分析器的代码，学生可以加深对编译过程的理解，为将来编写更...
如何用python写一个简单的词法分析器
12-24
编译原理老师要求写一个java的词法分析器，想了想决定用python写一个。 目标 能识别出变量，数字，运算符，界符和关键字，用excel表打印出来。 有了目标，想想要怎么实现词法分析器。 1.先进行预处理，把注释，多余...
编译原理实验一——C 语言词法分析器设计与实现
08-29
本实验“C语言词法分析器设计与实现”旨在深入理解词法分析原理，并掌握如何构建一个能正确处理源程序中单词的程序。 在编译原理中，词法分析器（也称为扫描器）是第一个处理源代码的组件。它的主要任务是： 1. **...
简易sql词法分析器和语法分析器.zip
07-14
完成 SQL 语言的词法分析器，要求采用课程教授方法，实现有限状态机确定化，最小化算法。词法分析器的输入为 SQL 语言源代码，输出识别出单词的二元属性，填写符号表。单词符号的类型包括关键字、标识符、界符、...
delphi实的词法分析与编译器实现,yacc&lex
09-08
lex是词法分析和语法分析器,本来以为这东西只有c++的呢，没想到也有delphi的 大家可以学习一下lex算法,想搞编译器的可以学习下yacc 非常不错的东西
词法分析程序设计步骤及代码
04-12
这个是编译原理实验课第一次实验词法分析程序设计步骤及一些实现代码.此压缩包里面有实验实现的详细步骤,以及收集了几个此次实验的几个实现代码.
词法分析的Java代码和一个Word简单描述
11-23
使用getProgram()方法从键盘获得程序串，从头至尾遍历程序串，并使用getSym() 方法识别每个符号，并把符号通过addWordtoList()将符号添加进符号表SymList中，最后将符号表输出。 后来添加的消除注释功能，主要使用了indexof（）方法
delphi 教你如何做表达式解析器
04-12
delphi 教你如何做表达式解析器 词法分析器 语法分析器
delphi编写的小型解释器
09-18
delphi编写的小型解释器，进行脚本解析
编译原理 第二章 词法分析器 练习2.6
weixin_44801736的博客
12-15 323
using System; using System.Collections.Generic; using System.Text; using System.IO; namespace Compiler { class Reader { private string str; private int lookahead; priv...
开源代码:Delphi词法分析全过程
WindowsAPI的专栏
01-13 2598
unit DelphiToken;interfaceuses  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,  Dialogs, StringOperations;const  WM_TOKENERROR  = WM_USER + 2034;  const  CHR_SYMHEADER  = 1
简单词法分析器实现
u014285517的专栏
11-23 1122
一.要求 1.1 待分析的简单词法 （1）关键字：所有的关键字都是小写              begin if then  while  do  end   （2）运算符和界符 :=  +  - *  /    > >=  =  ;  ( )  $   （3）其他单词是标识符（ID）和整型常数（NUM），通过以下正规式定义： ID = letter (letter | dig
生成词法分析器中使用的算法
锦衣夜行_
12-16 1473
生成词法分析器算法如下: RE:正则表达式 NFA:非确定有限状态自动机 DFA:确定有限状态自动机   Thompson算法: 从正则表达式代码到NFA(非确定有限状态有限机)过程使用的Thompson算法 基于对RE的结构作归纳 对基本的RE直接构造 对复合的RE递归构造 例如: 如下几种正则表达式规则 进入状态转移过程时,会读取字符串中的起始字符,进行校验 ε (空...
帮我写一个c++词法分析器
最新发布
03-30
下面是一个简单的C++词法分析器的实现步骤： 1. 定义词法单元的类型：根据C++语言的规范，定义不同类型的词法单元，如关键字、标识符、运算符、常量等。 2. 设计正则表达式：根据C++语言的语法规则，设计相应的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值