compiler

最新推荐文章于 2024-11-05 17:16:24 发布
最新推荐文章于 2024-11-05 17:16:24 发布
阅读量89 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39057744/article/details/129715558
版权
该文章展示了一个用C++编写的简单编译器前端，包括词法分析器（Lexer）和虚拟机（VirtualMachine）的类定义。Lexer负责识别程序中的关键字、标识符、数字等元素，并进行初步处理。VirtualMachine是为执行编译后代码设计的。文章还包含了变量管理、函数列表和表达式解析的相关结构和方法。
摘要由CSDN通过智能技术生成 
#include<iostream>
#include<fstream>
#include<string>
#include<unordered_map>
using namespace std;
class Lexer {
public:
	enum Type {
		Ident = -1000,
		Let,
		Fn,
		Mut,
		Struct,
		Enum,
		Integer,
		Float,
		I32,
		I64,
		F32,
		F64,
		Char,
		Addr,
		New,
		End,
		Rtn,
		While,
		If,
		Else,
		Or,
		And,
	};
	unordered_map<string, Type> KeyWord;
	ifstream inputfile;
	string filename;
	char buffer[1024];
	int bufferpos;
	int bufferlen;
	double old_fval;
	long long old_ival;
	string old_Idname;
	int old_type;
	bool backflag = 0;
	double fval;
	long long ival;
	string Idname;
	int linenum = 0;
	void InitMap() {
		KeyWord["fn"] = Type::Fn;
		KeyWord["i32"] = Type::I32;
		KeyWord["i64"] = Type::I64;
		KeyWord["f32"] = Type::F32;
		KeyWord["f64"] = Type::F64;
		KeyWord["char"] = Type::Char;
		KeyWord["struct"] = Type::Struct;
		KeyWord["let"] = Type::Let;
		KeyWord["mut"] = Type::Mut;
		KeyWord["return"] = Type::Rtn;
		KeyWord["while"] = Type::While;
		KeyWord["if"] = Type::If;
		KeyWord["else"] = Type::Else;
		KeyWord["or"] = Type::Or;
		KeyWord["and"] = Type::And;
	}
	Lexer() {}
	Lexer& operator =(const Lexer& l) {
		bufferpos = 0;
		bufferlen=0;
		InitMap();
		filename = l.filename;
		return *this;
	}
	Lexer(string filename) {
		bufferpos = 0;
		bufferlen = 0;
		InitMap();
		this->filename = filename;
	}
	void open() {
		inputfile.open(filename);
		if (inputfile.is_open() == false) {
			cout << "Open file failed<<endl" << endl;
			exit(0);
		}

	}
	static bool ishexdigit(char ch) {
		return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');
	}
	static int hexChar(char ch) {
		if (ch >= '0' && ch <= '9')return ch - '0';
		else {
			if (ch >= 'a' && ch <= 'F') {
				return ch - 'a' + 10;
			}
			else {
				return ch - 'A' + 10;
			}
		}
	}
	void getBack() {
		backflag = 1;
	}
	int getNextToken() {
		if (backflag == 1) {
			backflag = 0;
			return old_type;
		}
		if (inputfile.eof()) {
			old_type = Type::End;
			return Type::End;
		}
		if (bufferpos >= bufferlen) {
			inputfile.getline(buffer, sizeof buffer);
			bufferpos = 0;
			bufferlen = strlen(buffer);
			linenum++;
		}
		while (bufferpos < bufferlen && isspace(buffer[bufferpos]))bufferpos++;
		if (bufferpos >= bufferlen) {
			old_type= getNextToken();
			return old_type;
		}
		if (isalpha(buffer[bufferpos])) {
			string tmp;
			while (bufferpos < bufferlen && (isalnum(buffer[bufferpos]) || buffer[bufferpos] == '_')) {
				tmp += buffer[bufferpos];
				bufferpos++;
			}
			if (KeyWord.find(tmp) != KeyWord.end()) {
				Idname = tmp;
				old_type = KeyWord[tmp];
				return KeyWord[tmp];
			}
			else {
				Idname = tmp;
				old_type = Type::Ident;
				return Type::Ident;
			}
		}
		if (isdigit(buffer[bufferpos])) {
			if (bufferpos + 1 < bufferlen) {
				if (buffer[bufferpos] == '0' && (buffer[bufferpos + 1] == 'x' || buffer[bufferpos + 1] == 'b')) {
					if (buffer[bufferpos + 1] == 'x') {
						bufferpos += 2;
						ival = 0;
						while (ishexdigit(buffer[bufferpos])) {
							ival = ival * 16 + hexChar(buffer[bufferpos]);
							bufferpos++;
						}
						old_type = Type::Integer;
						return Type::Integer;
					}
					else {
						bufferpos += 2;
						ival = 0;
						while (buffer[bufferpos] == '0' || buffer[bufferpos] == 1) {
							ival = ival * 2 + buffer[bufferpos] - '0';
							bufferpos++;
						}
						old_type = Type::Integer;
						return Type::Integer;
					}
				}
				else {
					ival = 0;
					while (isdigit(buffer[bufferpos])) {
						ival = ival * 10 + buffer[bufferpos] - '0';
						bufferpos++;
					}
					if (buffer[bufferpos] == '.') {
						fval = (double)ival;
						double t = 0.1;
						while (isdigit(buffer[bufferpos])) {
							fval += t * (buffer[bufferpos] - '0');
							t *= 0.1;
							bufferpos++;
						}
						if (buffer[bufferpos] == 'E' || buffer[bufferpos] == 'e') {
							bufferpos++;
							int t = 0;
							int f = 1;
							if (buffer[bufferpos] == '-') {
								f = -1;
								bufferpos++;
							}
							while (isdigit(buffer[bufferpos])) {
								t = t * 10 + buffer[bufferpos++] - '0';
								bufferpos++;
							}
							t = t * f;
							if (t > 0) {
								while (t) {
									fval *= 10;
									t--;
								}
							}
							else {
								while (t) {
									fval /= 10;
									t++;
								}
							}
							old_type = Type::Float;
							return Type::Float;
						}
					}
					else {
						old_type = Type::Integer;
						return Type::Integer;
					}
				}
			}
			else {
				ival = buffer[bufferpos] - '0';
				bufferpos++;
				old_type = Type::Integer;
				return Type::Integer;
			}
		}
		while (bufferpos < bufferlen && isspace(buffer[bufferpos])) {
			bufferpos++;
		}
		if (bufferpos >= bufferlen) {
			old_type= getNextToken();
			return old_type;
		}
		bufferpos++;
		old_type = buffer[bufferpos - 1];
		return buffer[bufferpos - 1];

	}

};
class VirtualMachine {
public:
	long long ax, bx, cx, dx, ex, fx;
	double fa, fb, fc, fd, fe, ff;
	long long sp;//栈寄存器
};

Lexer lex;
struct Var {
	string name;
};
struct VarAttr {
	Lexer::Type type;
	string infunc;
};
struct Arg {
	Var var;
	VarAttr vattr;
};
unordered_map<string, vector<Arg>> funclist;
struct VarHash{
	size_t operator()(const Var& p)const {
		return hash<string>{} (p.name);
	}
};
struct VarEqual {
	bool operator()(const Var& l, const Var& r) const{
		return l.name == r.name;
	}
};

string code;
unordered_map<Var,VarAttr,VarHash,VarEqual> varlist;
void Error(string msg) {
	cout << lex.linenum << ":" << msg << endl;
	exit(0);
}
bool ParseUnits();
bool ParseFunc();
bool ParseStmts(string&);
bool ParseStmt(string&);
bool ParseExpr(string&);
bool ParseCExpr(string&);
bool ParseUnits() {
	if (ParseFunc()) {
		if (ParseUnits()) {
			return true;
		}
		else {
			return true;
		}
	}
	return true;
}
bool ParseFunc() {
	if (lex.getNextToken() == Lexer::Type::Fn) {
		auto t = lex.getNextToken();
		if (t == Lexer::Type::Ident) {
			auto name = lex.Idname;
			if (funclist.find(name) == funclist.end()) {
				vector<Arg> args;
				if (lex.getNextToken() != '(') {
					Error("lack of (");
				}
				else {
					while (true) {
						auto t = lex.getNextToken();
						if (t == Lexer::Type::Ident) {
							auto argname = lex.Idname;
							auto t = lex.getNextToken();

							if (t == ':') {
								auto t = lex.getNextToken();
								if (t >= Lexer::Type::Integer && t <= Lexer::Type::Char) {

									if (varlist.find({ argname }) != varlist.end()&&
										varlist[{argname}].infunc==name) {
										Error("already have " + argname + "in " + name);
									}
									varlist[{argname}] = { (Lexer::Type)t,name };
									t = lex.getNextToken();
									if (t == ',') {
										continue;
									}
									else {
										Error("lack of ,");
									}
								}
								else {
									Error("Type not exist");
								}
							}
							else {
								Error("lack of :");
							}
						}
						else {
							if (t == ')') {
								
								if (lex.getNextToken() == ':') {
									auto t = lex.getNextToken();
									if(t>=Lexer::Type::Integer&&t<=Lexer::Type::Char)
									{
										
										funclist.insert({ name, args });
										if (lex.getNextToken() == '{') {
											auto t = ParseStmts(name);
											if (t) {
												if (lex.getNextToken() == '}') {
													return true;
												}
												else {
													Error("lack of }");
												}
											}
											else {
												Error("body error");
											}
										}
										else {
											Error("lack of {");
										}
									}
									else {
										Error("lack of return Type");
									}
								}
								else {
									Error("lack of :");
								}
							}
							else {
								Error("lack of arg name");
							}
						}
					}
				}
			}
			else {
				Error("already have this function " + name);
				
			}
		}
		else {
			Error("funcname is needed");
		}
	}
	else {
		return false;
		
	}
	return false;
}
bool ParseStmts(string& funcname) {
	auto t = ParseStmt(funcname);
	if (t) {
		return ParseStmts(funcname);
	}
	return true;
}
bool ParseStmt(string& funcname) {
	auto t = lex.getNextToken();
	if (t == Lexer::Type::Let) {
		if (lex.getNextToken() != Lexer::Type::Ident) {
			Error("var name needed");
		}
		if (varlist.find({ lex.Idname }) != varlist.end() && varlist[{lex.Idname}].infunc == funcname) {
			Error(lex.Idname + " have existed");
		}
		if (lex.getNextToken() != ':') {
			Error(": is needed");
		}
		auto t = lex.getNextToken();
		if ((t >= Lexer::Type::Integer && t <= Lexer::Type::Char)==false) {
			Error("Type is needed");
		}
		if (lex.getNextToken() != '=') {
			Error("= is needed");
		}
		bool p = ParseExpr(funcname);
		if (p) {
			if (lex.getNextToken() == ';')return true;
			Error("; is needed");
			return false;
		}

	}
	if (t == Lexer::Type::Ident) {
		if (lex.getNextToken() != '=')Error("= is needed");
		if (ParseExpr(funcname)) {
			if (lex.getNextToken() != ';')Error("; is needed");
			return true;
		}
	}
	if (t == Lexer::Type::While) {
		auto t = ParseCExpr(funcname);
		if (t == false) {
			Error("bool expr error");
		}
		if (lex.getNextToken() != '{')Error("lack of {");
		if (ParseStmts(funcname)) {
			if (lex.getNextToken() != '}')Error("lack of }");
			return true;
		}
	}
	if (t == Lexer::Type::If) {
		auto t = ParseCExpr(funcname);
		if (t == false) {
			Error("bool expr error");
		}
		if (lex.getNextToken() != '{')Error("lack of {");
		t = ParseStmts(funcname);
		if (t == false)Error("stmts error");
		if (lex.getNextToken() != '}')Error("lack of }");
		if (lex.getNextToken() != Lexer::Type::Else) Error("{lack of Else");
		if (lex.getNextToken() != '{')Error("lack of {");
		t = ParseStmts(funcname);
		if (t == false)Error("stmts error");
		if (lex.getNextToken() != '}')Error("lack of }");
		return true;
	}
	lex.getBack();
	return false;
}
struct Enode {
	bool flag;
	enum {E,add_T,minus_T,T,mul_T,div_T,F,null,ID,NUM,CALL,RID}type;
	string idname;
	string code;
	union {
		double fval;
		long long ival;
	};
};
Enode E(string &funcname);
Enode T(string& funcname);
Enode _E(string& funcname);
Enode _T(string& funcname);
Enode F(string& funcname);
bool ParseExpr(string& funcname) {
	auto e = E(funcname);
	cout << e.code << endl;;
	return e.flag;
}
Enode E(string& funcname) {
	auto t = T(funcname);
	if (t.flag) {
		auto _e = _E(funcname);
		if (_e.type == Enode::null) return t;
		else {
			if (_e.type == Enode::add_T) {
				if (t.idname == "" && _e.idname == "") {
					t.type = Enode::NUM;
					t.ival += _e.ival;
				}
				else {
					if (t.idname !=""&&_e.idname!="") {
						t.code += "+ " + t.idname + " " + _e.idname + "\n";
						t.type = Enode::ID;
					}
					if (t.idname == "") {
						t.code += "+" + to_string(t.ival) + " " + _e.idname+"\n";
						t.idname = _e.idname;
						t.type = Enode::ID;
					}
					else {
						t.code += "+ " + t.idname + " " + to_string(_e.ival) + "\n";
						t.type = Enode::ID;
					}
				}
			}
			else {
				if (t.idname == "" && _e.idname == "") {
					t.type = Enode::NUM;
					t.ival -= _e.ival;
				}
				else {
					if (t.idname != "" && _e.idname != "") {
						t.code += "- " + t.idname + " " + _e.idname + "\n";
						t.type = Enode::ID;
					}
					if (t.idname == "") {
						t.code += "-" + to_string(t.ival) + " " + _e.idname + "\n";
						t.idname = _e.idname;
						t.type = Enode::ID;
					}
					else {
						t.code += "- " + t.idname + " " + to_string(_e.ival) + "\n";
						t.type = Enode::ID;
					}
				}
			}
			return t;
		}
	}
	return t;
}

Enode T(string& funcname) {
	auto f = F(funcname);
	if (f.flag) {
		auto _t = _T(funcname);
		if (_t.type == Enode::null) return f;
		else {
			if (_t.type == Enode::mul_T) {
				
				if (f.idname == "" && _t.idname == "") {
					f.ival = f.ival * _t.ival;
					f.type = Enode::NUM;
				}
				else {
					if (f.idname != "" && _t.idname != "") {
						f.code += "* " + f.idname + " " + _t.idname + " \n";
						f.type = Enode::ID;
					}
					if (f.idname == "") {
						f.idname = _t.idname;
						f.code += "* " + to_string(f.ival) + " " + _t.idname+"\n";
						f.type = Enode::ID;
					}
					else {
						f.code += "* " + to_string(_t.ival) + " " + f.idname+"\n";
						f.type = Enode::ID;
					}
				}
			}
			else {
				if (f.idname == "" && _t.idname == "") {
					f.ival = f.ival / _t.ival;
					f.type = Enode::NUM;
				}
				else {
					if (f.idname != "" && _t.idname != "") {
						f.type = Enode::ID;
						f.code = "/ " + f.idname + " " + _t.idname + "\n";
					}

					if (f.idname == "") {
						f.idname = _t.idname;
						f.code += "/ " + to_string(f.ival) + " " + _t.idname+"\n";
						f.type = Enode::ID;
					}
					else {
						f.code += "/ " + f.idname+" "+to_string(_t.ival)+"\n";
						f.type = Enode::ID;
					}
				}
			}
			return f;
		}
	}
	return f;
}
Enode _E(string& funcname) {
	auto ch = lex.getNextToken();
	if (ch=='+') {
		auto t = E(funcname);
		t.type = Enode::add_T;
		return t;
	}
	if (ch == '-') {
		auto t = E(funcname);
		t.type = Enode::minus_T;
		return t;
	}
	lex.bufferpos--;
	Enode tmp;
	tmp.flag = true;
	tmp.type = Enode::null;
	return  tmp;
}
Enode _T(string& funcname) {
	auto ch = lex.getNextToken();
	if (ch == '*') {
		auto t = T(funcname);
		t.type = Enode::mul_T;
		return t;
	}
	if (ch == '/') {
		auto t = T(funcname);
		t.type = Enode::div_T;
		return t;
	}
	lex.bufferpos--;
	Enode tmp;
	tmp.flag = true;
	tmp.type = Enode::null;
	return tmp;
}
Enode F(string& funcname) {
	auto t = lex.getNextToken();
	if (t == '(') {
		auto p = E(funcname);
		if (lex.getNextToken() != ')')Error("unmatch )");
		return p;
	}
	if (t == Lexer::Type::Ident) {
		return { true,Enode::ID,lex.Idname,"", 0 };
	}
	
	if (t == '-') {
		auto n = lex.getNextToken();
		if (n == Lexer::Type::Ident) {
			return { true,Enode::RID,lex.Idname,"",0 };
		}
		if (n == Lexer::Type::Integer) {
			Enode tmp;
			tmp.flag = true;
			tmp.type = Enode::NUM;
			tmp.idname = "";
			tmp.code = "";
			tmp.ival = lex.ival*(-1);
			return tmp;
		}
		Error("lack of id or num after -");
	}
	if (t == Lexer::Type::Integer) {
		Enode tmp;
		tmp.flag = true;
		tmp.type = Enode::NUM;
		tmp.ival = lex.ival;
		tmp.code = "";
		return tmp;
	}
	Enode tmp;
	tmp.flag = false;
	tmp.type = Enode::null;
	return tmp;
}
bool C(string&);
bool _C(string&);
bool B(string&);
bool G(string&);
bool _B(string&);
bool ParseCExpr(string& fnstr) {
	return C(fnstr);
}
bool C(string&fnstr) {
	auto t = B(fnstr);
	if (t) {
		auto r = _C(fnstr);
		if (r)return true;
		else return false;
	}
	return false;
}

bool _C(string& fnstr) {
	auto tk = lex.getNextToken();
	if (tk == Lexer::Type::Or) {
		auto t = C(fnstr);
		if (t)return true;
		else return false;
	}
	lex.getBack();
	return true;
}
bool B(string& fnstr) {
	auto g = G(fnstr);
	if (g) {
		auto b = _B(fnstr);
		if (b) return true;
		else return false;
	}
	return false;
}
bool _B(string& fnstr) {
	auto v = lex.getNextToken();
	if (v == Lexer::Type::And) {
		auto  b = B(fnstr);
		if (b)return true;
		else return false;
	}
	lex.getBack();
	return true;
}
bool G(string& fnstr) {
	auto ch = lex.getNextToken();
	if (ch == '(') {
		auto c = C(fnstr);
		if (lex.getNextToken() != ')')Error("unmatch (");
		return c;
	}
	if (ch == '!') {
		if (lex.getNextToken() != '(')Error("left brace need");
		auto c = C(fnstr);
		if (lex.getNextToken() != ')')Error("unmatch )");
		return c;
	}
	lex.getBack();
	auto L = ParseExpr(fnstr); 
	if (L == 0) {
		Error("E match failed");
	}
	auto t1 = lex.getNextToken();
	if (!(t1 == '>' || t1 == '<' || t1 == '='))Error("need cmp op");
	auto t2 = lex.getNextToken();
	if (t2 != '=') {
		if (t1 == '=')Error("only one  =");
		lex.getBack();
		if (t1 == '>') {
			auto R = E(fnstr);
			return R.flag;
		}
		if (t1 == '<') {
			auto R = E(fnstr);
			return R.flag;
		}
	}
	else {
		if (t1 == '=') {
			auto R = E(fnstr);
			return R.flag;
		}
		if (t1 == '>') {
			auto R = E(fnstr);
			return R.flag;
		}
		if (t1 == '<') {
			auto R = E(fnstr);
			return R.flag;
		}
	}
	return false;
}
int main(int argc, char** argv) {
	if (argc == 1) {
		cout << "need file" << endl;
		//exit(0);
	}
	
	//cout << argv[1]<<endl;
	lex = Lexer("test.gh");
	lex.open();
	int t = ParseUnits();
	cout << t << endl;
	
	return 0;
}
东边的西瓜皮
关注
configure: error: no acceptable C compiler found in $PATH解决方案
weixin_43178406的博客
12-29 4万+
本文主要介绍了configure: error: no acceptable C compiler found in $PATH解决方案，希望能对使用Linux的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
java compiler类_Java_Java Compiler 应用实例
weixin_30237677的博客
02-13 2816
转自：http://hejiangtao.iteye.com/blog/1399122一直在用JDK1.5， 一直搞不清楚JDK1.6有啥特性, 就翻了翻, 发现这个Compiler API(JSR 199)动态编译Java源文件功能很有意思. Compiler API如果和反射功能一起使用, 就可以实现java源代码的动态编译并执行这些代码，有点动态语言的特征. 利用这些API普通用户也可以方便...
webpack Compiler
qq_40409143的博客
03-22 2329
什么是Compiler Compiler 负责编译，贯穿webpack的整个声明周期，Compiler 对象包含了当前运行Webpack的配置，包括entry、output、loaders等配置，这个对象在启动Webpack时被实例化，而且是全局唯一的。Plugin可以通过该对象获取到Webpack的配置信息进行处理。我们可以在源码中看看Compiler是怎么定义的。 class Compiler extends Tapable { constructor(context) { super();
Arm Compiler 5.06__ARM编译器官网下载, 安装及使用说明( 保姆级教程, 官网下载和注册链接跳转异常问题, 附官网安装包 )
热门推荐
Rleco的博客
01-14 5万+
Keil MDK-Arm5.37不再默认安装 《 Arm Compiler 5.06》，而安装的只有最新的V6版本的编译器。
Compiler - 编译器
既然选择了远方 便只顾风雨兼程 - 永强
11-28 2944
Compiler - 编译器 intermediate representation，IR：中间表示 front end，FE：前端 middle end，ME：中端 back end，BE：后端 The first compiler was build by John Backum and his group between 1954 and 1957 at IBM. 编译器就是将高级语言翻译为低级语言的程序。 1. What is a Compiler? A compiler is a compute
compiler explorer
xuleisdjn的专栏
05-30 6250
虽然不常用，但还是记录下吧。以前了解过这个在线编辑网站，很久都没用。今天正好在没有编译环境的机器上学习代码。就又想起来他了，还是写一下吧。 网址如下：Compiler ExplorerCompiler Explorer is an interactive online compiler which shows the assembly output of compiled C++, Rust, Go (and many more) code.https://godbolt.org/ 很方便，最上方的A.
JavaCompiler
理工科的杜小甫的博客
06-13 7049
一、使用JavaCompiler接口来编译Java源程式 　　使用Java API来编译Java源程式有非常多方法，目前让我们来看一种最简单的方法，通过JavaCompiler进行编译。 　　我们能通过ToolProvider类的静态方法getSystemJavaCompiler来得到一个JavaCompiler接口的实例。 　　JavaCompiler compiler = ToolProv
NVDLA compiler
夏天Alex
04-14 3679
NVDLA简介 nvdia深度学习加速器(NVDLA)是一种免费开放式架构，具有可扩展性，高度可配置性，旨在简化集成和可移植性。NVDLA软件生态系统包括一个设备上的软件堆栈（开源版本的一部分），一个完整的培训基础架构，用于构建包含深度学习的新模型，以及将现有模型转换为可在设备上使用的形式的解析器软件。可以提供其自己的硬件平台以及软件内核： NVDLA可以加速神经网络推理工作，可分两步完成 针对DLA硬件优化训练有素的神经网络，并将图形转换为DLA HW指令。转换后的图形将保存到称为可加载的平面缓冲区
ARM 编译器 Arm Compiler for Embedded 6 相关工具链简介
DayDayUp
04-09 1万+
Arm Compiler 6 是 Arm 中用于 Arm Cortex® 和 Arm Neoverse™ 处理器的最先进的 C 和 C++ 编译工具链。Arm Compiler 6 与 Arm 架构一起开发。因此，Arm 编译器 6 经过优化，可为从小型传感器到 64 位设备的嵌入式裸机应用生成高效代码。Arm Compiler 6 将 Arm 优化的工具和库与基于 LLVM 的现代编译器框架相结合。
java compiler设置_java compiler 设置
weixin_29104059的博客
03-02 1698
如下图所示，我们在给工程设置 java compiler的时候，都是通过界面设置。在工程目录下.setting文件夹下生成了，org.eclipse.jdt.core.prefs的文件。选中Enable project specific settings#Sat Jun 12 11:01:27 CST 2010eclipse.preferences.version=1org.eclipse.j...
keil5compiler
06-22
标题中的"keil5compiler"指的是Keil uVision 5中用于编译ARM架构代码的编译器组件。这个压缩包提供的可能是Keil ARM Compiler的一个更新版本，用于解决特定的编译错误或提升性能。 描述中提到的"解决keil5.38编译器...
ARMCC Compiler Verdion 5编译器自用
08-27
ARMCC Compiler Version 5是ARM公司推出的一款针对嵌入式系统开发的专业C/C++编译器，尤其在微控制器（如ARM Cortex系列）领域广泛应用。它为开发者提供了高效、优化的编译工具链，能够将源代码转换为针对特定ARM...
Compiler Version 5编译器
05-31
标题提到的"Compiler Version 5编译器"指的是Keil的MDK-ARM（Microcontroller Development Kit for ARM）中的编译工具链，也被称为ARMC5。这个版本的编译器针对C和C++语言，提供了对ARM Cortex系列处理器的强大支持...
ARMCC Compiler Verdion 5编译器
04-03
ARMCC Compiler Version 5是ARM公司推出的一款针对嵌入式系统开发的专业C/C++编译器，尤其在微控制器（如ARM Cortex系列）领域广泛应用。它为开发者提供了高效、优化的编译工具链，能够将源代码转换为针对特定ARM...
kotlin-compiler-1.9.22
05-06
Kotlin-compiler-1.9.22是Kotlin编程语言的最新版本编译器，它为开发者带来了诸多改进和新特性，进一步提升了开发效率和代码质量。 一、Kotlin编译器基础 Kotlin编译器是将Kotlin源代码转换为可执行程序的关键组件...
杨辉三角——c语言
最新发布
aqua3535742358的博客
11-05 591
define N 10 //自己定义输出行数。
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
ChoSeitaku的博客
11-04 1051
表A，B都有序，可从第一个元素起依次比较A、B两表的元素，若元素值不等，则值小的值往后移，若元素值相等，则创建一个值等于两节点的元素值的新节点，使用尾插法插入到新的链表中，并将两个原表指针后移一位，直到其中一个链表遍历到表尾。一个工作指针cura用来遍历链表A，一个工作指针curb用来遍历链表B，一个工作指针curc用来建立链表C，一个指针new用来创建共同节点的新节点尾插到C链表上。循环结束后，如果curb指向NULL，表示链表B的curb都等于对应的cura，链表B是链表A的连续子序列。
每日OJ题_牛客_排序子序列_模拟_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-02 365
每日OJ题_牛客_排序子序列_模拟_C++_Java（根据题意用指针模拟即可）
C++ -- 模板进阶
zy1215058242的博客
11-02 834
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
Altera NCO Compiler用户指南
"Altera NCO Compiler用户指南" Altera NCO (Numerically Controlled Oscillator) Compiler用户指南是一份专门针对Altera公司的MegaCore功能的文档，版本为2.2.0，日期为2004年6月。这份手册详细介绍了如何使用NCO ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值