编程实战：类C语法的编译型脚本解释器（九）编译语句

系列入口：编程实战：类C语法的编译型脚本解释器（系列）-CSDN博客

        前文已经介绍了编译入口，核心就是语句，本文介绍语句的编译。

一、代码概览

 

        代码太长，直接贴：

		bool GetSentence(CTokens& tokens, T_VARIABLE_S& vars, Sentence& sentence, Token*& pToken, size_t& pos)
		{
			sentence.clear();
			Expression* pExpression;

			if (tokens.IsPosNotToken(pos))return false;
			sentence.source_start = tokens.TokenStart(pos);
			sentence.source_end = tokens.TokenStart(pos);
			tokens.MoveCurrentToken(pToken, pos);
			switch (pToken->type)
			{
			case Token::IDENTIFIER:
			case Token::NUMBER:
			case Token::STRING:
			case Token::OPERATOR:
				sentence.type = Sentence::EXPRESSION;
				pExpression = GetExpression(tokens, vars, NULL, pos, ";");
				if (!tokens.IsPosNotToken(pos) && tokens.IsDelimiter(pos, ";"))
				{
					tokens.MoveNextToken(pToken, pos);
				}
				sentence.expressions.reserve(1);
				sentence.expressions.push_back(*pExpression);
				break;
			case Token::DELIMITER:
				if (pToken->text == "{")
				{
					sentence.type = Sentence::BLOCK;
					tokens.MoveNextToken(pToken, pos);
					while (true)
					{
						if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，块语句未结束");
						if (tokens.IsDelimiter(pos, "}"))
						{
							tokens.MoveNextToken(pToken, pos);
							break;
						}
						Sentence tmpsentence;
						if (!GetSentence(tokens, vars, tmpsentence, pToken, pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "获取块语句的语句出错");
						sentence.sentences.reserve(sentence.sentences.size() + 1);
						sentence.sentences.push_back(tmpsentence);
					}
				}
				else if (pToken->text == "}")
				{
					CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的块语句结束标记");
				}
				else if (pToken->text == ";")
				{
					sentence.type = Sentence::NULLSENTENCE;
					tokens.MoveNextToken(pToken, pos);
				}
				else
				{
					CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "尚未支持的分隔符");
				}
				break;
			case Token::KEYWORD:
				if (pToken->text == "return")
				{
					sentence.type = Sentence::RETURN;
					tokens.MoveNextToken(pToken, pos);
					pExpression = GetExpression(tokens, vars, NULL, pos, ";");
					Expression null_expression;
					if (NULL == pExpression)
					{
						pExpression = &null_expression;
					}
					if (!tokens.IsPosNotToken(pos) && tokens.IsDelimiter(pos, ";"))
					{
						tokens.MoveNextToken(pToken, pos);
					}
					sentence.expressions.reserve(1);
					sentence.expressions.push_back(*pExpression);
				}
				else if (pToken->text == "if")
				{
					sentence.type = Sentence::IF;
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待左括号");
					if (!tokens.IsOperator(pos, "("))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待左括号");
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待条件表达式");
					if (NULL == (pExpression = GetExpression(tokens, vars, NULL, pos, ")")))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "条件表达式为空");
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待右括号");
					if (!tokens.IsOperator(pos, ")"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待右括号");
					sentence.expressions.reserve(1);
					sentence.expressions.push_back(*pExpression);
					tokens.MoveNextToken(pToken, pos);
					sentence.sentences.reserve(2);
					Sentence if_sentence;
					if (!GetSentence(tokens, vars, if_sentence, pToken, pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "分析if块的执行语句出错");
					sentence.sentences.push_back(if_sentence);
					if (!tokens.IsPosNotToken(pos))
					{
						if (pToken->type == Token::KEYWORD && pToken->text == "else")
						{
							tokens.MoveNextToken(pToken, pos);
							Sentence else_sentence;
							if (!GetSentence(tokens, vars, else_sentence, pToken, pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "分析else块的执行语句出错");
							sentence.sentences.push_back(else_sentence);
						}
					}
				}
				else if (pToken->text == "do")
				{
					sentence.type = Sentence::DO;
					tokens.MoveNextToken(pToken, pos);
					sentence.sentences.reserve(1);
					Sentence if_sentence;
					if (!GetSentence(tokens, vars, if_sentence, pToken, pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "分析do块的执行语句出错");
					sentence.sentences.push_back(if_sentence);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待while");
					if (pToken->type != Token::KEYWORD || pToken->text != "while")CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待while");
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待左括号");
					if (!tokens.IsOperator(pos, "("))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待左括号");
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待条件表达式");
					if (NULL == (pExpression = GetExpression(tokens, vars, NULL, pos, ")")))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "条件表达式为空");
					tokens.MoveCurrentToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待右括号");
					if (!tokens.IsOperator(pos, ")"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待右括号");
					sentence.expressions.reserve(1);
					sentence.expressions.push_back(*pExpression);
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待分号");
					if (!tokens.IsDelimiter(pos, ";"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待分号");
					tokens.MoveNextToken(pToken, pos);
				}
				else if (pToken->text == "while")
				{
					sentence.type = Sentence::WHILE;
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待左括号");
					if (!tokens.IsOperator(pos, "("))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待左括号");
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待条件表达式");
					if (NULL == (pExpression = GetExpression(tokens, vars, NULL, pos, ")")))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "条件表达式为空");
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待右括号");
					if (!tokens.IsOperator(pos, ")"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待右括号");
					sentence.expressions.reserve(1);
					sentence.expressions.push_back(*pExpression);
					tokens.MoveNextToken(pToken, pos);
					sentence.sentences.reserve(1);
					Sentence if_sentence;
					if (!GetSentence(tokens, vars, if_sentence, pToken, pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "分析while块的执行语句出错");
					sentence.sentences.push_back(if_sentence);
				}
				else if (pToken->text == "for")
				{
					sentence.type = Sentence::FOR;//第一个分号前面是一个语句
					sentence.expressions.reserve(2);
					sentence.sentences.reserve(2);

					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待左括号");
					if (!tokens.IsOperator(pos, "("))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待左括号");

					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待初始化表达式");
					Sentence init_sentence;
					if (!GetSentence(tokens, vars, init_sentence, pToken, pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "分析for块的初始化语句出错");
					sentence.sentences.push_back(init_sentence);

					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待条件表达式");
					if (NULL == (pExpression = GetExpression(tokens, vars, NULL, pos, ";")))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "获取条件表达式出错");
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待分号");
					if (!tokens.IsDelimiter(pos, ";"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待分号");
					sentence.expressions.push_back(*pExpression);

					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待循环递增表达式");
					if (NULL == (pExpression = GetExpression(tokens, vars, NULL, pos, ")")))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "获取循环递增表达式出错");
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待右括号");
					if (!tokens.IsOperator(pos, ")"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待右括号");
					sentence.expressions.push_back(*pExpression);

					tokens.MoveNextToken(pToken, pos);
					Sentence for_sentence;
					if (!GetSentence(tokens, vars, for_sentence, pToken, pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "分析for块的执行语句出错");
					sentence.sentences.push_back(for_sentence);
				}
				else if ("break" == pToken->text)
				{
					sentence.type = Sentence::BREAK;
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待分号");
					if (!tokens.IsDelimiter(pos, ";"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待分号");
					tokens.MoveNextToken(pToken, pos);
				}
				else if ("continue" == pToken->text)
				{
					sentence.type = Sentence::CONTINUE;
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待分号");
					if (!tokens.IsDelimiter(pos, ";"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待分号");
					tokens.MoveNextToken(pToken, pos);
				}
				else if ("long" == pToken->text || "double" == pToken->text || "int" == pToken->text || "float" == pToken->text || "string" == pToken->text)
				{//声明语句
					sentence.type = Sentence::DECLARE;
					Variable var;
					if ("long" == pToken->text || "int" == pToken->text)var.type = Variable::LONG;
					else if ("double" == pToken->text || "float" == pToken->text)var.type = Variable::DOUBLE;
					else var.type = Variable::STRING;

					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待变量名");
					if (tokens.IsDelimiter(pos, ";"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的分号，期待变量名");
					if (pToken->type != Token::IDENTIFIER)CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待标识符");
					sentence.expressions.resize(1);
					sentence.expressions[0].type = Expression::DEFINE;
					sentence.expressions[0].VariableName = pToken->text;
					sentence.expressions[0].m_variable = var;
					sentence.expressions[0].source_start = sentence.source_start;
					sentence.expressions[0].source_end = tokens.TokenStart(pos + 1);
					tokens.MoveNextToken(pToken, pos);
					if (tokens.IsPosNotToken(pos))
					{
					}
					else if (tokens.IsOperator(pos, "="))
					{//带有初始值
						tokens.MoveNextToken(pToken, pos);
						if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待初始化表达式");
						if (NULL == (pExpression = GetExpression(tokens, vars, NULL, pos, ";")))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "获取初始化表达式出错");
						if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待分号");
						if (!tokens.IsDelimiter(pos, ";"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待分号");
						tokens.MoveNextToken(pToken, pos);
						sentence.expressions[0].AddLeftOperand(*pExpression);
					}
					else if (tokens.IsOperator(pos, "("))
					{//函数
						for (long i = 0; i < (long)m_functions.size(); ++i)
						{
							if (m_functions[i].script_name == sentence.expressions[0].VariableName)CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "函数重名");
						}
						m_functions.resize(m_functions.size() + 1);
						CScript* pFunction = &m_functions[m_functions.size() - 1];
						pFunction->FromParent(*this, sentence.expressions[0].VariableName);
						pFunction->return_type = var.type;
						pFunction->count_global_variable = vars.getGlobalCount();
					
						tokens.MoveNextToken(pToken, pos);
						while (!tokens.IsOperator(pos, ")"))
						{
							Variable param;
							if ("long" == pToken->text || "int" == pToken->text)param.type = Variable::LONG;
							else if ("double" == pToken->text || "float" == pToken->text)param.type = Variable::DOUBLE;
							else if("string"== pToken->text)param.type = Variable::STRING;
							else CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待参数类型");
							tokens.MoveNextToken(pToken, pos);
							if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待参数名");
							if (pToken->type != Token::IDENTIFIER)CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待标识符");
							if (!pFunction->m_EnvVariables.AddVariable(pToken->text, param))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "函数参数重名");
							if (NULL!=vars.FindVariable(pToken->text))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "函数参数与全局变量或环境变量重名");
							tokens.MoveNextToken(pToken, pos);
							if (tokens.IsPosNotToken(pos))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未期待的脚本结束，期待)");
							if (tokens.IsOperator(pos, ","))tokens.MoveNextToken(pToken, pos);
							else break;
						}
						if (!tokens.IsOperator(pos, ")"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待)");
						tokens.MoveNextToken(pToken, pos);
						if (!tokens.IsDelimiter(pos, "{"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待{");
						tokens.MoveNextToken(pToken, pos);
						
						T_VARIABLE_S tmpvars;
						tmpvars.FromParentVars(vars, pFunction->count_global_variable, &pFunction->m_EnvVariables);
						if (!pFunction->Build(tokens, tmpvars, pos))
						{
							m_msg += "编译失败\r\n";
							return false;
						}
						
						if (!tokens.IsDelimiter(pos, "}"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待}");
						tokens.MoveNextToken(pToken, pos);
						if (!tokens.IsDelimiter(pos, ";"))CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待分号");
						tokens.MoveNextToken(pToken, pos);
						
						return GetSentence(tokens, vars, sentence, pToken, pos);
					}
					else if (!tokens.IsDelimiter(pos, ";"))
					{
						CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "期待分号，一个语句只能定义一个变量");
					}
				}
				else
				{
					CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "非期待的的关键字，是否前面缺少分号？");
				}
				break;
			default:
				CException::Throw(__FILE__, __LINE__, m_source, tokens.TokenStart(pos), "未支持的标记类型");
				break;
			}
			sentence.source_end = tokens.TokenStart(pos);
			return sentence.source_end != sentence.source_start;
		}

 

（我还没写完）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/224578.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

urllib爬虫 应用实例（三）

urllib爬虫 应用实例（三）

目录 一、 ajax的get请求豆瓣电影第一页 二、ajax的get请求豆瓣电影前十页 三、ajax的post请求肯德基官网 一、 ajax的get请求豆瓣电影第一页 目标&#xff1a;获取豆瓣电影第一页的数据&#xff0c;并保存为json文件 设置url&#xff0c;检查 --> 网络 --> 全部 -…
阅读更多...
JPA与MySQL锁实战

JPA与MySQL锁实战

前言&#xff1a;最近使用jpa和mysql时&#xff0c;遇到了死锁问题。在解决后将一些排查过程中新学到和复习到的知识点再总结整理一下。首先对InnoDB中锁相关的概念进行介绍&#xff0c;然后展示如何利用JPA提供的排他锁来实现想要的功能&#xff0c;最后对死锁问题进行讨论。 …
阅读更多...
MOSFET

MOSFET

MOSFET 电子元器件百科 文章目录 MOSFET前言一、MOSFET是什么二、MOSFET类别三、MOSFET应用实例四、MOSFET作用原理总结前言 MOSFET是一种常见的半导体器件，通过栅极电场控制通道区的导通特性，以控制电流流动。它在现代电子电路中发挥着重要的作用，并广泛应用于各种应用领域…
阅读更多...
第一百九十一回 自定义TimePicker：一

第一百九十一回 自定义TimePicker：一

文章目录 1. 概念介绍2. 思路与方法2.1 整体思路2.2 实现方法3. 示例代码4. 内容总结我们在上一章回中介绍了"如何自定义一个可选择的星期组件"相关的内容，本章回中将介绍" 自定义TimpePicker".闲话休提，让我们一起Talk Flutter吧。 1. 概念介绍 我们在…
阅读更多...
弘扬中华文化 感受戏曲魅力——安徽演艺小分队赴和田交流演出

弘扬中华文化 感受戏曲魅力——安徽演艺小分队赴和田交流演出

为进一步弘扬中华优秀传统文化&#xff0c;促进皖和两地交往交流交融&#xff0c;12月2日&#xff0c;安徽省演艺小分队走进和田新夜市登台演出&#xff0c;黄梅戏、独唱、民乐演奏、杂技等丰富多样的表演&#xff0c;为观众们送上了一场文化盛宴。 安徽演艺小分队赴和田交流演…
阅读更多...
Stable Diffusion AI绘画系列【18】:东方巨龙，威武霸气

Stable Diffusion AI绘画系列【18】:东方巨龙，威武霸气

《博主简介》 小伙伴们好&#xff0c;我是阿旭。专注于人工智能、AIGC、python、计算机视觉相关分享研究。 ✌更多学习资源&#xff0c;可关注公-仲-hao:【阿旭算法与机器学习】&#xff0c;共同学习交流~ &#x1f44d;感谢小伙伴们点赞、关注&#xff01; 《------往期经典推…
阅读更多...
HarmonyOS（十一）——初识状态管理

HarmonyOS（十一）——初识状态管理

前言 在前文的描述中&#xff0c;我们构建的页面多为静态界面。如果希望构建一个动态的、有交互的界面&#xff0c;就需要引入“状态”的概念。 假设我们要实现如下一个动态的交互界面&#xff1a; 上面的示例中&#xff0c;用户与应用程序的交互触发了文本状态变更&#x…
阅读更多...
Linux中的输入输出重定向

Linux中的输入输出重定向

目录 1.输出重定向 > 2.追加重定向 >> 3.标准 正确/错误 输出重定向 4.输入重定向 < 5.标准输入 0 1.输出重定向 > 将命令执行之后的结果不打印出来&#xff0c;可以输入在另外一个文件当中。 如&#xff0c;我查看文件a.txt 的前3行&#xff0c;然后不显…
阅读更多...
计算机图形图像技术（OpenCV核心功能、图像变换与图像平滑处理）

计算机图形图像技术（OpenCV核心功能、图像变换与图像平滑处理）

一、实验原理&#xff1a; 1、显示图像 void imshow(const string &name, InputArray image); ①功能&#xff1a;在指定窗口中显示图像。 ②参数&#xff1a;name为窗口的名字&#xff1b;image为待显示的图像。 ③说明&#xff1a;可显示彩色或灰度的字节图像和浮点数图…
阅读更多...
Stm32_串口的帧(不定长)数据接收

Stm32_串口的帧(不定长)数据接收

目录标题 前言1、串口中断接收固定帧头帧尾数据1.1、任务需求1.2、实现思路1.3、程序源码&#xff1a; 2、串口中断接收用定时器来判断帧结束3、串口中断接收数据空闲中断3.1、串口的空闲中断3.2、实现思路3.3、程序源码 4、串口的空闲中断DMA转运4.1、DMA简介4.2、DMA模式4.3、…
阅读更多...
【Gradle】mac环境安装Gradle及配置

【Gradle】mac环境安装Gradle及配置

官网安装说明&#xff1a;Gradle | Installation 由于Gradle运行依赖jvm&#xff0c;所以事先需要安装jdk&#xff0c;并确认你的jdk版本和gradle版本要求的对应关系&#xff0c;这个官网上有说明&#xff0c;但是我试了一下不太准确&#xff0c;供参考&#xff0c;链接如下&a…
阅读更多...
CleanMyMac X4.15.0最新官方和谐版下载

CleanMyMac X4.15.0最新官方和谐版下载

Mac系统进行文件清理&#xff0c;一般是直接将文件拖动入“废纸篓”回收站中&#xff0c;然后通过清理回收站&#xff0c;就完成了一次文件清理的操作&#xff0c;但是这么做并无法保证文件被彻底删除了&#xff0c;有些文件通过一些安全恢复手段依旧是可以恢复的&#xff0c;那…
阅读更多...
【算法】约瑟夫环

【算法】约瑟夫环

约瑟夫问题是个有名的问题&#xff1a;N个人围成一圈&#xff0c;从第一个开始报数&#xff0c;第M个将被杀掉&#xff0c;最后剩下一个&#xff0c;其余人都将被杀掉。例如N6&#xff0c;M5&#xff0c;被杀掉的顺序是&#xff1a;5&#xff0c;4&#xff0c;6&#xff0c;2&a…
阅读更多...
【FPGA图像处理实战】- 图像处理前景如何？就业前景如何？

【FPGA图像处理实战】- 图像处理前景如何？就业前景如何？

图像处理是FPGA应用的主要领域之一&#xff0c;图像处理数据量特别大且对实时性处理要求高的场景&#xff0c;这恰好能发挥FPGA流水线可实时处理的优势。 那么FPGA图像处理的前景如何&#xff1f; 一、FPGA开发&#xff08;图像处理&#xff09;招聘就业情况 看FPGA图像处理…
阅读更多...
docker基本管理和相关概念

docker基本管理和相关概念

1、docker是什么&#xff1f; docker是开源的应用容器引擎。基于go语言开发的&#xff0c;运行在Linux系统当中开源轻量级的“虚拟机”。 docker可以在一台主机上轻松的为任何应用创建一个轻量级的&#xff0c;可移植的&#xff0c;自给自足的容器。docker的宿主机是Linux系统…
阅读更多...
2024年江苏省职业院校技能大赛 信息安全管理与评估 第二阶段教师组 (样卷)

2024年江苏省职业院校技能大赛 信息安全管理与评估 第二阶段教师组 (样卷)

2024年江苏省职业院校技能大赛 信息安全管理与评估 第二阶段教师组 (样卷) 项目竞赛样题 本文件为信息安全管理与评估项目竞赛-第二阶段样题&#xff0c;内容包括&#xff1a;网络安全事件响应、数字取证调查、应用程序安全。 本次比赛时间为180分钟。 介绍 GeekSec专注技能竞…
阅读更多...
visual Studio MFC 平台实现拉普拉斯和拉普拉斯与直方图均衡化与中值滤波相结合实现比较

visual Studio MFC 平台实现拉普拉斯和拉普拉斯与直方图均衡化与中值滤波相结合实现比较

拉普拉斯变换的原理与应用 本文使用visual Studio MFC 平台实现图像增强中的拉普拉斯变换&#xff0c;同时拉普拉斯一般不会单独使用&#xff0c;与其他平滑操作相结合&#xff0c;本文使用了拉普拉斯与直方图均衡化以及与中值滤波相结合&#xff0c;也对三种方式进行了对比 关…
阅读更多...
MIT6S081-Lab2总结

MIT6S081-Lab2总结

大家好&#xff0c;我叫徐锦桐&#xff0c;个人博客地址为www.xujintong.com&#xff0c;github地址为https://github.com/xjintong。平时记录一下学习计算机过程中获取的知识&#xff0c;还有日常折腾的经验&#xff0c;欢迎大家访问。 Lab2就是了解一下xv6的系统调用流程&…
阅读更多...
Python 进阶（十三）：JSON 序列化和反序列化（json 模块）

Python 进阶（十三）：JSON 序列化和反序列化（json 模块）

大家好&#xff0c;我是水滴~~ 本篇文章主要介绍json模块的功能&#xff0c;包括将Python对象序列化到文件、将Python对象序列化为字符串、序列化时类型的对照表、将文件中JSON数据反序列化为Python对象&#xff0c;将JSON字符串反序列化为Python对象、反序列化时类型的对照表…
阅读更多...
Kafka使用指南

Kafka使用指南

Kafka简介架构设计Kafka的架构设计关键概念Kafka的架构设计关键机制 Partition介绍Partition工作机制 应用场景ACK机制介绍ACK机制原理ACK机制对性能的影响ACK控制粒度Kafka分区数对集群性能影响调整分区优化集群性能拓展Kafka数据全局有序 Kafka简介 Kafka是由Apache软件基金…
阅读更多...
最新文章

Copyright @ 2022~2023