词法分析的前奏：字符分析（十）UTF-8字符分析

最新推荐文章于 2024-07-12 16:16:27 发布
最新推荐文章于 2024-07-12 16:16:27 发布
阅读量136 收藏
点赞数
分类专栏： 编译之渊 文章标签： python 编译器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jing_liu_lucky/article/details/119097738
版权

UTF-8 字符分析

流程图

在这里插入图片描述

源代码

文件输入类定义
#文件输入类定义
import os
class 文件输入类:
    #
    def __init__(self):
        self.文件名 = ""
        
        self.文件大小 = 0
        self.读写位置 = 0
        self.输出字节值 = 0

    def 打开文件(self,输入文件名):
        self.文件名 = 输入文件名
        self.文件 = open(self.文件名,'rb')           #打开文件
        self.文件大小 = os.path.getsize(self.文件名)  #获取文件大小字节数

    def 读取一字节(self):
        data = self.文件.read(1)#读入一字节字符
        x = data.hex()          #将字符转为16进制表示
        y = int(x,16)           #将16进制表示转为整数值
        self.输出字节值 = y     #整数值作为字节值
        self.读写位置 = self.文件.tell()#记录当前文件读取位置
        return self.输出字节值

    def 到达文件尾(self):
        if self.读写位置 == self.文件大小 :
            return True
        else:
            return False

    def 关闭文件(self):
        self.文件.close()
        self.文件名 = ""
        self.文件大小 = 0
        self.读写位置 = 0
        self.输出字节值 = 0
共享消息与行列号之类定义
#共享消息与行列号之类定义
class 共享消息类:
    def __init__(self):
        self.消息值 = 3
    def 设定消息值(self,设定值):
        self.消息值 = 设定值
    def 读取消息值(self):
        return self.消息值


class 共享行列号类:
    def __init__(self):
        self.行号 = 1
        self.列号 = 0
    def 设定行号值(self,行号值):
        self.行号 = 行号值
    def 设定列号值(self,列号值):
        self.列号 = 列号值
    def 读取行号值(self):
        return self.行号
    def 读取列号值(self):
        return self.列号
    def 列号加一(self):
        self.列号 += 1
    def 行号加一(self):
        self.行号 += 1
字符六元队列类定义
#字符六元队列类定义
from collections import deque

class 字符六元队列类:
    def __init__(self):
        self.六元队列 = deque()
        

    def 已有字节数(self):
        return int( self.六元队列.__len__() )
        
    def 追加元素(self,元素值=32): #默认追加一个空格,用以表明元素值的数据类型
        if self.已有字节数() < 6:
            self.六元队列.append(元素值)

    def 读元素值(self,索引号):
        if 索引号 <= ( self.已有字节数() -1 ):
            return self.六元队列[索引号]
        else:
            return 0

    def 弹出一个元素(self):
        self.六元队列.popleft()

    def 弹出二个元素(self):
        self.六元队列.popleft()
        self.六元队列.popleft()

    def 弹出三个元素(self):
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()

    def 弹出四个元素(self):
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()

    def 弹出五个元素(self):
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()

    def 弹出六个元素(self):
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()
        self.六元队列.popleft()

    def 剩余空位数(self):
        k = 6 - self.已有字节数()
        return k

    def 队列为空(self):
        if self.已有字节数() == 0:
            return True
        else:
            return False
    
    def 清空队列(self):
        self.六元队列.clear()
全局共享
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 文件输入类定义 import 文件输入类 #导入自定义模块
from 共享消息与行列号之类定义 import 共享消息类
from 共享消息与行列号之类定义 import 共享行列号类
from 字符六元队列类定义 import 字符六元队列类

共享消息 = 共享消息类()
共享行列号 = 共享行列号类()
字符六元队列 = 字符六元队列类()
输入文件 = 文件输入类()
字符元素链表 = []
垃圾元素链表 = []
字符元素类定义
#字符元素类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 共享消息与行列号之类定义 import 共享行列号类
from 全局共享 import 共享行列号

class 字符元素类:
    def __init__(self,引用共享行列号 = 共享行列号):
        self.全局行列号 = 引用共享行列号
        self.元素值 = []
        self.私有行列号 = 共享行列号类()
        self.字符有效标志 = False
        self.字符分类值 = 0

    def 占用字节数(self):
        return len(self.元素值)
    
    def 字符分类(self):
        pass

    def 追加一字节垃圾值(self,字节值):
        self.元素值.clear()
        self.元素值.append(字节值)
        self.字符有效标志 = False
        行号 = self.全局行列号.读取行号值()
        列号 = self.全局行列号.读取列号值()
        self.全局行列号.设定列号值( 列号 + 1 )
        self.私有行列号.设定行号值( 行号 )
        self.私有行列号.设定列号值( 列号 + 1 )

    def 追加1字节(self,字节值):
        self.元素值.clear()
        self.元素值.append(字节值)
        self.字符有效标志 = True
        行号 = self.全局行列号.读取行号值()
        列号 = self.全局行列号.读取列号值()
        self.全局行列号.列号加一()
        self.私有行列号.设定行号值( 行号 )
        self.私有行列号.设定列号值( 列号 + 1 )

    def 追加2字节(self,字节值1,字节值2):
        self.元素值.clear()
        self.元素值.append(字节值1)
        self.元素值.append(字节值2)
        self.字符有效标志 = True
        行号 = self.全局行列号.读取行号值()
        列号 = self.全局行列号.读取列号值()
        self.全局行列号.设定列号值( 列号 + 1 )
        self.私有行列号.设定行号值( 行号 )
        self.私有行列号.设定列号值( 列号 + 1 )

    def 追加3字节(self,字节值1,字节值2,字节值3):
        self.元素值.clear()
        self.元素值.append(字节值1)
        self.元素值.append(字节值2)
        self.元素值.append(字节值3)
        self.字符有效标志 = True
        行号 = self.全局行列号.读取行号值()
        列号 = self.全局行列号.读取列号值()
        self.全局行列号.设定列号值( 列号 + 1 )
        self.私有行列号.设定行号值( 行号 )
        self.私有行列号.设定列号值( 列号 + 1 )

    def 追加4字节(self,字节值1,字节值2,字节值3,字节值4):
        self.元素值.clear()
        self.元素值.append(字节值1)
        self.元素值.append(字节值2)
        self.元素值.append(字节值3)
        self.元素值.append(字节值4)
        self.字符有效标志 = True
        行号 = self.全局行列号.读取行号值()
        列号 = self.全局行列号.读取列号值()
        self.全局行列号.设定列号值( 列号 + 1 )
        self.私有行列号.设定行号值( 行号 )
        self.私有行列号.设定列号值( 列号 + 1 )

    def 追加5字节(self,字节值1,字节值2,字节值3,字节值4,字节值5):
        self.元素值.clear()
        self.元素值.append(字节值1)
        self.元素值.append(字节值2)
        self.元素值.append(字节值3)
        self.元素值.append(字节值4)
        self.元素值.append(字节值5)
        self.字符有效标志 = True
        行号 = self.全局行列号.读取行号值()
        列号 = self.全局行列号.读取列号值()
        self.全局行列号.设定列号值( 列号 + 1 )
        self.私有行列号.设定行号值( 行号 )
        self.私有行列号.设定列号值( 列号 + 1 )

    def 追加6字节(self,字节值1,字节值2,字节值3,字节值4,字节值5,字节值6):
        self.元素值.clear()
        self.元素值.append(字节值1)
        self.元素值.append(字节值2)
        self.元素值.append(字节值3)
        self.元素值.append(字节值4)
        self.元素值.append(字节值5)
        self.元素值.append(字节值6)
        self.字符有效标志 = True
        行号 = self.全局行列号.读取行号值()
        列号 = self.全局行列号.读取列号值()
        self.全局行列号.设定列号值( 列号 + 1 )
        self.私有行列号.设定行号值( 行号 )
        self.私有行列号.设定列号值( 列号 + 1 )

    def 字符有效(self):
        return self.字符有效标志

    def 读元素值(self,索引值 = 0):
        if 索引值 < self.占用字节数():
            return self.元素值[索引值]
        else:
            return None

    def 显示字符(self):
        if self.字符有效标志:
            h = bytes(self.元素值)
            字符值 = h.decode('utf-8')
            return 字符值
        else:
            return None
字符解析通用框架抽象类定义
#字符解析通用框架抽象类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 字符六元队列

class 字符解析通用框架抽象类:
    def  __init__(self):
        
        self.启动码 = 3

    def 设启动码(self,启动码值 = 3 ):
        self.启动码 = 启动码值

    def 工作函数(self):
        pass

    def 行动(self):
        n = 共享消息.读取消息值()
        if self.启动码 == n :
            self.工作函数()
队列预存器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件

from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 队列预存器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(3)

    def 工作函数(self):
        while (字符六元队列.剩余空位数() != 0 ) and (输入文件.到达文件尾() == False ):
            x = 输入文件.读取一字节()
            字符六元队列.追加元素( x )
        if 字符六元队列.队列为空() == False:
            共享消息.设定消息值(6)
换行判别器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 字符元素类定义 import 字符元素类
from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 换行判别器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(45)


    def 工作函数(self):
        n = len(字符元素链表)
        
        if n >= 2 :
            前元素 = 字符元素链表[n-2]
            后元素 = 字符元素链表[n-1]
            a = 前元素.占用字节数()
            b = 后元素.占用字节数()
            if a == 1 and b == 1 :
                c = 前元素.读元素值(0)
                d = 后元素.读元素值(0)
                if c == 13 and d == 10 :
                    共享行列号.行号加一()
                    共享行列号.设定列号值(0)
            
        共享消息.设定消息值(48)
循环条件判别器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 循环条件判别器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(48)
        self.a = False
        self.b = False

    def 工作函数(self):
        if 输入文件.到达文件尾():
            self.a = True
        else:
            self.a = False

        if 字符六元队列.队列为空():
            self.b = True
        else:
            self.b = False

        if self.a and self.b:
            共享消息.设定消息值(0)
        else:
            共享消息.设定消息值(3)
六字节字符判别器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件

from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 六字节字符判别器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(6)
        self.第一字节首字节 = 0xFC
        self.第一字节尾字节 = 0xFD
        
        self.其余字节首字节 = 0x80
        self.其余字节尾字节 = 0xBF

        self.a = False
        self.b = False
        self.c = False
        self.d = False
        self.e = False
        self.f = False


    def 工作函数(self):
        if 字符六元队列.已有字节数() == 6:
            第一字节值 = 字符六元队列.读元素值(0)
            第二字节值 = 字符六元队列.读元素值(1)
            第三字节值 = 字符六元队列.读元素值(2)
            第四字节值 = 字符六元队列.读元素值(3)
            第五字节值 = 字符六元队列.读元素值(4)
            第六字节值 = 字符六元队列.读元素值(5)

            if 第一字节值 >= self.第一字节首字节 and 第一字节值 <= self.第一字节尾字节:
                self.a = True
            else:
                self.a = False

            if 第二字节值 >= self.其余字节首字节 and 第二字节值 <= self.其余字节尾字节:
                self.b = True
            else:
                self.b = False

            if 第三字节值 >= self.其余字节首字节 and 第三字节值 <= self.其余字节尾字节:
                self.c = True
            else:
                self.c = False

            if 第四字节值 >= self.其余字节首字节 and 第四字节值 <= self.其余字节尾字节:
                self.d = True
            else:
                self.d = False

            if 第五字节值 >= self.其余字节首字节 and 第五字节值 <= self.其余字节尾字节:
                self.e = True
            else:
                self.e = False

            if 第六字节值 >= self.其余字节首字节 and 第六字节值 <= self.其余字节尾字节:
                self.f = True
            else:
                self.f = False

            
            if self.a and self.b and self.c and self.d and self.e and self.f :
                共享消息.设定消息值(42)
            else:
                共享消息.设定消息值(9)
            
            
        else :
            共享消息.设定消息值(9)
五字节字符判别器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件

from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 五字节字符判别器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(9)
        self.第一字节首字节 = 0xF8
        self.第一字节尾字节 = 0xFB
        
        self.其余字节首字节 = 0x80
        self.其余字节尾字节 = 0xBF

        self.a = False
        self.b = False
        self.c = False
        self.d = False
        self.e = False

    def 工作函数(self):
        if 字符六元队列.已有字节数() >= 5:
            第一字节值 = 字符六元队列.读元素值(0)
            第二字节值 = 字符六元队列.读元素值(1)
            第三字节值 = 字符六元队列.读元素值(2)
            第四字节值 = 字符六元队列.读元素值(3)
            第五字节值 = 字符六元队列.读元素值(4)
            

            if 第一字节值 >= self.第一字节首字节 and 第一字节值 <= self.第一字节尾字节:
                self.a = True
            else:
                self.a = False

            if 第二字节值 >= self.其余字节首字节 and 第二字节值 <= self.其余字节尾字节:
                self.b = True
            else:
                self.b = False

            if 第三字节值 >= self.其余字节首字节 and 第三字节值 <= self.其余字节尾字节:
                self.c = True
            else:
                self.c = False

            if 第四字节值 >= self.其余字节首字节 and 第四字节值 <= self.其余字节尾字节:
                self.d = True
            else:
                self.d = False

            if 第五字节值 >= self.其余字节首字节 and 第五字节值 <= self.其余字节尾字节:
                self.e = True
            else:
                self.e = False

            
            if self.a and self.b and self.c and self.d and self.e  :
                共享消息.设定消息值(39)
            else:
                共享消息.设定消息值(12)

        else :
            共享消息.设定消息值(12)
四字节字符判别器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件

from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 四字节字符判别器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(12)
        self.第一字节首字节 = 0xF0
        self.第一字节尾字节 = 0xF7
        
        self.其余字节首字节 = 0x80
        self.其余字节尾字节 = 0xBF

        self.a = False
        self.b = False
        self.c = False
        self.d = False
 
    def 工作函数(self):
        if 字符六元队列.已有字节数() >= 4:
            第一字节值 = 字符六元队列.读元素值(0)
            第二字节值 = 字符六元队列.读元素值(1)
            第三字节值 = 字符六元队列.读元素值(2)
            第四字节值 = 字符六元队列.读元素值(3)

            if 第一字节值 >= self.第一字节首字节 and 第一字节值 <= self.第一字节尾字节:
                self.a = True
            else:
                self.a = False

            if 第二字节值 >= self.其余字节首字节 and 第二字节值 <= self.其余字节尾字节:
                self.b = True
            else:
                self.b = False

            if 第三字节值 >= self.其余字节首字节 and 第三字节值 <= self.其余字节尾字节:
                self.c = True
            else:
                self.c = False

            if 第四字节值 >= self.其余字节首字节 and 第四字节值 <= self.其余字节尾字节:
                self.d = True
            else:
                self.d = False

            
            if self.a and self.b and self.c and self.d   :
                共享消息.设定消息值(36)
            else:
                共享消息.设定消息值(15)
            
            
        else :
            共享消息.设定消息值(15)
三字节字符判别器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件

from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 三字节字符判别器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(15)
        self.第一字节首字节 = 0xE0
        self.第一字节尾字节 = 0xEF
        
        self.其余字节首字节 = 0x80
        self.其余字节尾字节 = 0xBF

        self.a = False
        self.b = False
        self.c = False
 
    def 工作函数(self):
        if 字符六元队列.已有字节数() >= 3:
            第一字节值 = 字符六元队列.读元素值(0)
            第二字节值 = 字符六元队列.读元素值(1)
            第三字节值 = 字符六元队列.读元素值(2)
            
            
            

            if 第一字节值 >= self.第一字节首字节 and 第一字节值 <= self.第一字节尾字节:
                self.a = True
            else:
                self.a = False

            if 第二字节值 >= self.其余字节首字节 and 第二字节值 <= self.其余字节尾字节:
                self.b = True
            else:
                self.b = False

            if 第三字节值 >= self.其余字节首字节 and 第三字节值 <= self.其余字节尾字节:
                self.c = True
            else:
                self.c = False

            
            if self.a and self.b and self.c  :
                共享消息.设定消息值(33)
            else:
                共享消息.设定消息值(18)
            
            
        else :
            共享消息.设定消息值(18)
二字节字符判别器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件

from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 二字节字符判别器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(18)
        self.第一字节首字节 = 0xC0
        self.第一字节尾字节 = 0xDF
        
        self.其余字节首字节 = 0x80
        self.其余字节尾字节 = 0xBF

        self.a = False
        self.b = False

    def 工作函数(self):
        if 字符六元队列.已有字节数() >= 2:
            第一字节值 = 字符六元队列.读元素值(0)
            第二字节值 = 字符六元队列.读元素值(1)

            if 第一字节值 >= self.第一字节首字节 and 第一字节值 <= self.第一字节尾字节:
                self.a = True
            else:
                self.a = False

            if 第二字节值 >= self.其余字节首字节 and 第二字节值 <= self.其余字节尾字节:
                self.b = True
            else:
                self.b = False

            
            if self.a and self.b  :
                共享消息.设定消息值(30)
            else:
                共享消息.设定消息值(21)
            
            
        else :
            共享消息.设定消息值(21)
一字节字符判别器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件

from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 一字节字符判别器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(21)
        self.第一字节首字节 = 0x00
        self.第一字节尾字节 = 0x7F
        
        #self.其余字节首字节 = 0x80
        #self.其余字节尾字节 = 0xBF

        self.a = False

    def 工作函数(self):
        if 字符六元队列.已有字节数() >= 1:
            第一字节值 = 字符六元队列.读元素值(0)
 
            if 第一字节值 >= self.第一字节首字节 and 第一字节值 <= self.第一字节尾字节:
                self.a = True
            else:
                self.a = False
      
            if self.a  :
                共享消息.设定消息值(27)
            else:
                共享消息.设定消息值(24)

        else :
            共享消息.设定消息值(24)
六字节字符处理器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 字符元素类定义 import 字符元素类
from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 六字节字符处理器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(42)


    def 工作函数(self):
        字节1 = 字符六元队列.读元素值(0)
        字节2 = 字符六元队列.读元素值(1)
        字节3 = 字符六元队列.读元素值(2)
        字节4 = 字符六元队列.读元素值(3)
        字节5 = 字符六元队列.读元素值(4)
        字节6 = 字符六元队列.读元素值(5)

        字符六元队列.弹出六个元素()

        字符元素 = 字符元素类(共享行列号)
        字符元素.追加6字节(字节1,字节2,字节3,字节4,字节5,字节6)

        字符元素链表.append(字符元素)
        共享消息.设定消息值(48)
五字节字符处理器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 字符元素类定义 import 字符元素类
from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 五字节字符处理器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(39)
    def 工作函数(self):
        字节1 = 字符六元队列.读元素值(0)
        字节2 = 字符六元队列.读元素值(1)
        字节3 = 字符六元队列.读元素值(2)
        字节4 = 字符六元队列.读元素值(3)
        字节5 = 字符六元队列.读元素值(4)

        字符六元队列.弹出五个元素()

        字符元素 = 字符元素类(共享行列号)
        字符元素.追加5字节(字节1,字节2,字节3,字节4,字节5)

        字符元素链表.append(字符元素)
        共享消息.设定消息值(48)
四字节字符处理器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 字符元素类定义 import 字符元素类
from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 四字节字符处理器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(36)
    def 工作函数(self):
        字节1 = 字符六元队列.读元素值(0)
        字节2 = 字符六元队列.读元素值(1)
        字节3 = 字符六元队列.读元素值(2)
        字节4 = 字符六元队列.读元素值(3)

        字符六元队列.弹出四个元素()

        字符元素 = 字符元素类(共享行列号)
        字符元素.追加4字节(字节1,字节2,字节3,字节4)

        字符元素链表.append(字符元素)
        共享消息.设定消息值(48)
三字节字符处理器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 字符元素类定义 import 字符元素类
from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 三字节字符处理器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(33)

    def 工作函数(self):
        字节1 = 字符六元队列.读元素值(0)
        字节2 = 字符六元队列.读元素值(1)
        字节3 = 字符六元队列.读元素值(2)

        字符六元队列.弹出三个元素()

        字符元素 = 字符元素类(共享行列号)
        字符元素.追加3字节(字节1,字节2,字节3)

        字符元素链表.append(字符元素)
        共享消息.设定消息值(48)
二字节字符处理器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 字符元素类定义 import 字符元素类
from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 二字节字符处理器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(30)

    def 工作函数(self):
        字节1 = 字符六元队列.读元素值(0)
        字节2 = 字符六元队列.读元素值(1)

        字符六元队列.弹出二个元素()

        字符元素 = 字符元素类(共享行列号)
        字符元素.追加2字节(字节1,字节2)

        字符元素链表.append(字符元素)
        共享消息.设定消息值(48)
一字节字符处理器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 字符元素类定义 import 字符元素类
from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 一字节字符处理器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(27)

    def 工作函数(self):
        字节1 = 字符六元队列.读元素值(0)

        字符六元队列.弹出一个元素()

        字符元素 = 字符元素类(共享行列号)
        字符元素.追加1字节(字节1)

        字符元素链表.append(字符元素)
        共享消息.设定消息值(45)
垃圾字节字符处理器类定义
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 字符元素类定义 import 字符元素类
from 字符解析通用框架抽象类定义 import 字符解析通用框架抽象类

class 垃圾字节字符处理器类(字符解析通用框架抽象类):
    def __init__(self):
        self.设启动码(24)

    def 工作函数(self):
        if 字符六元队列.已有字节数() >= 1:
            字节1 = 字符六元队列.读元素值(0)
            字符六元队列.弹出一个元素()

            字符元素 = 字符元素类(共享行列号)
            字符元素.追加一字节垃圾值(字节1)

            垃圾元素链表.append(字符元素)
        共享消息.设定消息值(48)
对utf8字符分析函数
import sys
sys.path.append("D:\cncc\project\对utf8字符分析") #设定自己模块的存储路径
from 全局共享 import 共享消息
from 全局共享 import 共享行列号
from 全局共享 import 字符六元队列
from 全局共享 import 输入文件
from 全局共享 import 字符元素链表
from 全局共享 import 垃圾元素链表

from 队列预存器类定义 import 队列预存器类
from 六字节字符判别器类定义 import 六字节字符判别器类
from 五字节字符判别器类定义 import 五字节字符判别器类
from 四字节字符判别器类定义 import 四字节字符判别器类
from 三字节字符判别器类定义 import 三字节字符判别器类
from 二字节字符判别器类定义 import 二字节字符判别器类
from 一字节字符判别器类定义 import 一字节字符判别器类
from 六字节字符处理器类定义 import 六字节字符处理器类
from 五字节字符处理器类定义 import 五字节字符处理器类
from 四字节字符处理器类定义 import 四字节字符处理器类
from 三字节字符处理器类定义 import 三字节字符处理器类
from 二字节字符处理器类定义 import 二字节字符处理器类
from 一字节字符处理器类定义 import 一字节字符处理器类
from 垃圾字节字符处理器类定义 import 垃圾字节字符处理器类
from 换行判别器类定义 import 换行判别器类
from 循环条件判别器类定义 import 循环条件判别器类

def 对utf8字符分析函数(输入文件名):
    #初始化
    队列预存器 = 队列预存器类()
    六字节字符判别器 = 六字节字符判别器类()
    五字节字符判别器 = 五字节字符判别器类()
    四字节字符判别器 = 四字节字符判别器类()
    三字节字符判别器 = 三字节字符判别器类()
    二字节字符判别器 = 二字节字符判别器类()
    一字节字符判别器 = 一字节字符判别器类()

    六字节字符处理器 = 六字节字符处理器类()
    五字节字符处理器 = 五字节字符处理器类()
    四字节字符处理器 = 四字节字符处理器类()
    三字节字符处理器 = 三字节字符处理器类()
    二字节字符处理器 = 二字节字符处理器类()
    一字节字符处理器 = 一字节字符处理器类()
    
    垃圾字节字符处理器 = 垃圾字节字符处理器类()
    换行判别器 = 换行判别器类()
    循环条件判别器 = 循环条件判别器类()
    #环境初始化
    输入文件.打开文件(输入文件名)
    字符元素链表.clear()
    垃圾元素链表.clear()
    字符六元队列.清空队列()
    共享行列号.__init__()
    共享消息.设定消息值(3)
    #工作
    while 共享消息.读取消息值() != 0 :
        队列预存器.行动()
        六字节字符判别器.行动()
        五字节字符判别器.行动()
        四字节字符判别器.行动()
        三字节字符判别器.行动()
        二字节字符判别器.行动()
        一字节字符判别器.行动()
        六字节字符处理器.行动()
        五字节字符处理器.行动()
        四字节字符处理器.行动()
        三字节字符处理器.行动()
        二字节字符处理器.行动()
        一字节字符处理器.行动()
        垃圾字节字符处理器.行动()
        换行判别器.行动()
        循环条件判别器.行动()

    输入文件.关闭文件()
    print("有效字符数:",len(字符元素链表))
    print("无效字符数:",len(垃圾元素链表))

    s = len(字符元素链表)
    for i in range(s):
        c = 字符元素链表[i]
        r = c.私有行列号.读取行号值()
        l = c.私有行列号.读取列号值()
        g = c.元素值
        print(r,"行",l,"列",",字符元素值 ",g,",字符 ",c.显示字符())

print("示例文件utf8，字符分析如下：")
对utf8字符分析函数("示例文件utf8")
print("探索6，字符分析如下：")
对utf8字符分析函数("探索6.md")
#print("少年中国说，字符分析如下：")
#对utf8字符分析函数("少年中国说")
jing_liu_lucky
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串分析
ChanCherry的博客
11-25 364
字符串基本属性 只需用’将字符串括起来。 disp()：对字符串进行显示； size()：获取字符串的大小； double()：将字符串以ASCII码显示； char()：将ASCII码以字符串显示。 str='My name is Robin.' disp(str); str_size=size(str) str(1:7) str2=str(end:-1:1) %字符串反序输出 str_as...
strings 字符串分析工具
09-04
通过静态分析来最大程度上的获取PE文件的信息，从而帮助我们了解其行为动态和作用方式，
字符编码
weixin_30642869的博客
05-15 184
转自:http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386819196283586a37629844456ca7e5a7faa9b94ee8000 我们已经讲过了，字符串也是一种数据类型，但是，字符串比较特殊的是还有一个编码问题。 因为计算机只能处理数字，如果要处理文本...
字符分析
The_best_man的博客
03-05 746
输入一个字符串，内有数字和非数字字符，如： a123x456}17960？302tab5876 将其中连续的数字作为一个整体，依次存放到一个数组a中。例如，123放在a[0]，456放在a[1]……，统计共有多少整数，并输出这些整数。 输入格式： 每个输入包含1个测试用例，即一个不超过80位的字符串。 输出格式： 按照从左到右的顺序输出所有整数，用逗号分隔。 输入样例： a
词法分析的前奏：字符分析（四）
jing_liu_lucky的专栏
01-10 77
字符分析之类设计（基础部分） 1、共享消息： 2、共享行列号 与识别出的类对象相比，把行列号独立成一个共享类更为合理，因此多出了一个共享行列号类 3、字符元素 4、字符四元队列 5、字符解析通用框架类（抽象类） ...
实验1：词法分析(NEW--模板)1
08-03
在词法分析中，每个状态代表了分析过程中的一个阶段，而转移函数则根据当前字符决定如何从一个状态转移到另一个状态。DFA能够有效地处理输入流，因为它在任何时刻只有一个确定的后续状态，这使得它在处理单词项时...
cifafenxi.rar_cifafenxi_字符串_词法分析 报告
09-23
实现一个C语言子集的词法分析程序。 首先在关键字列表keywordtable中查询字符串p，若存在就将该字符串及对应的类号插入二元式列表eryuanshi；若没有，在符号表symtable中查询，如果symtable中不存在p就将p插入，这里...
编译原理实验报告-词法分析
01-14
《编译原理实验报告-词法分析》 在编译领域，词法分析是构建编译器的关键步骤之一，它负责将源代码分解成一个个独立的、有意义的符号，即“单词”或“记号”。本实验的目标在于帮助学生深入理解词法分析在编译程序...
编译原理-词法分析实验（c++版）
05-22
请根据给定的文法设计并实现词法分析程序，从源程序中识别出单词，记录其单词类别和单词值，输入输出及处理要求如下： （1）数据结构和与语法分析程序的接口请自行定义；类别码需按下表格式统一定义； （2）为了...
编译原理-基于tiny语言的词法分析器
04-24
编译原理-基于tiny语言的词法分析器 编译原理-基于tiny语言的词法分析器 编译原理-基于tiny语言的词法分析器 编译原理-基于tiny语言的词法分析器 编译原理-基于tiny语言的词法分析器 编译原理-基于tiny语言的词法...
字符串详解+代码分析
2302_80084329的博客
12-10 852
/ 默认初始化，s1是一个空字符串// s2是s1的副本，注意s2只是与s1的值相同，并不指向同一段地址// s3是该字符串字面值的副本// s4的内容是 "cccccccccc"return 0;
python将txt文件转为字符串_[转]python3字符串与文本处理
weixin_39711867的博客
11-24 635
每个程序都回涉及到文本处理，如拆分字符串、搜索、替换、词法分析等。许多任务都可以通过内建的字符串方法来轻松解决，但更复杂的操作就需要正则表达式来解决。1、针对任意多的分隔符拆分字符串In [1]: line = 'asdf fjdk; afed, fjek,asdf, foo'#使用正则模块In [2]: importre#使用正则split方法可以匹配多分割符In [3]: re.spli...
字符串解析
kslly的专栏
03-17 6981
没有任何具体价值，单纯的字符串解析、转换的编程练习 /** @file test.c * @note * @brief 字符串解析 * @author * @date * @note 没有任何具体价值，单纯的字符串解析、转换的编程练习 * @note 历史记录： * @warning */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&...
python文本字符分析
Ashley_hello的博客
12-20 1万+
编写程序接收字符串，按字符出现频率的降序打印字母。分别尝试录入一些中英文文章片段，比较不同语言之间字符频率的差别。 # a6.4CalLetter txt = input("请输入一段英文片段：") txt = txt.lower() count = {} for i in range(97, 123): count[chr(i)] = txt.count(chr(i)) items = list(count.items()) items.sort(key=lambda x: x[1], rever
UTF-8字符集
热门推荐
kiku
08-12 1万+
UTF-8字符集 互联网的普及，强烈要求出现一种统一的编码方式。UTF-8 就是在互联网上使用最广的一种 Unicode 的实现方式。其他实现方式还包括 UTF-16（字符用两个字节或四个字节表示）和 UTF-32（字符用四个字节表示），不过在互联网上基本不用。重复一遍，这里的关系是，UTF-8 是 Unicode 的实现方式之一。 UTF-8 最大的一个特点，就是它是一种变长的编码方式。它可以使...
3.1 　 词 法 分 析 程 序 的 功 能 3.2 　 单 词 符 号 及 输 出 单 词 的 形
qq_45180475的博客
08-05 2130
词 法 分 析 程 序 的 功 能 编译过程的第一步是进行词法分析,词法分析的任务是对字符串表示的源程序从左到右地进行扫描和分解,根据语言的词法规则识别出一个一个具有独立意义的单词符号。 执行词法分析的程序称为词法分析程序,或称词法分析器或扫描器。 单 词 符 号 及 输 出 单 词 的 形 词法分析程序是以字符串形式的源程序作为输入,以单词符号或单词符号表示的源程序作为输出。 3.2.1 语言的单词符号 语言的单词符号是指语言中具有独立意义的最小语法单位,即单词符号是程序语言的基本语法单位。程序语言的单.
cv2读取和保存图片
最新发布
m0_53291740的博客
07-12 187
cv2.imwrite('b\\img1.png',img)#b存在就可以保存进去。如果b存在，c不存在，程序不会报错，也不会保存图片。如果目录b不存在就会存到当前文件夹。
Nginx七层（应用层）反向代理：UWSGI代理uwsgi_pass篇
jclee95的个人博客
07-10 1094
Nginx提供了多种应用层反向代理支持，包括proxy_pass、uwsgi_pass、fastcgi_pass和scgi_pass等。其中，proxy_pass指令可以接受一个URL参数，用于实现对HTTP/HTTPS协议的反向代理；uwsgi_pass用于代理到uWSGI应用服务器；fastcgi_pass用于代理到FastCGI服务器；而scgi_pass则用于代理到SCGI（Simple Common Gateway Interface）应用。这些指令使Nginx能够灵活地处理不同类型的后端服务和应
面试题 21：解释 Python 中的 help() 函数和 dir() 函数？
专注于全栈开发领域
07-10 774
在Python中，help()和dir()是两个非常有用的内置函数，它们可以帮助开发者更好地了解Python对象和模块。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值