代码编辑器1.5.0

已于 2023-12-31 19:04:00 修改
阅读量529 收藏 8
点赞数 20
分类专栏： FastCode 文章标签： 编辑器
于 2023-12-31 15:08:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80029762/article/details/135315975
版权

 

源代码:

#include <windows.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <stdio.h>
#include <string>
#include <map>

#define UP								72
#define DOWN							80
#define LEFT							75
#define RIGHT							77

#define	helps "\
<Ctrl+Enter>		:	command\n\
<h,H,?>			:	help\n\
<s,S>			:	save\n\
<q,Q>			:	quit and save\n\
<!>			:	quit\n\
<o,O>			:	compile\n\
<t,T,^>			:	top\n\
<l,L,y,Y,@> num		:	y = num\n\
<x,X> num		:	x = num\n\
<k,K> str			:	str = keyword\n\
<p,P> str num		:	str = color (num)\n\
<w,W,$> + Enter+ str	:	system (str)\n\
<c,C,=>			:	copy\n\
<v,V,~>			:	paste\n\
< < > str			:	find(str)\n\
< > > str			:	find(str)\n\
<-> num			:	erase(num)\n\
<{> num,begin,step		:	{begin,begin+step,begin+step*2,...}\n\
<\"> num,begin,step		:	\"begin,begin+step,begin+step*2,...\"\n\
<|> num,begin,step,+	:\n\
<|> num,begin,step,-	:\n\
"

#define min(a, b)						((a) < (b) ? (a) : (b))
#define max(a, b)						((a) > (b) ? (a) : (b))
#define color(tc)						SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), tc)
#define gotoxy(xx, yy)																			\
	do{																							\
		COORD position = {xx, yy};																\
		SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), position);					\
	}while(false)

typedef signed char						int8;
typedef signed short					int16;
typedef signed long						int32;
typedef signed long long				int64;
typedef unsigned char					uint8;
typedef unsigned short					uint16;
typedef unsigned long					uint32;
typedef unsigned long long				uint64;
typedef unsigned char					byte_t;
typedef unsigned short					word_t;
typedef unsigned long					iterator;
typedef void*							pointer_t;

template <typename type> class vector {
	public:
		type* p;
		size_t Len;
		size_t Size;
		vector () {
			p = NULL;
			Len = 0;
			Size = 0;
		}
		~vector () {
			delete[] p;
		}
		size_t size () {
			return Size;
		}
		size_t len () {
			return Len;
		}
		void exp () {
			Len = (Len << 1) + 1;
			if (p == NULL) {
				p = new type [ Len ];
			} else {
				type *tp = new type [ Len ];
				for (size_t it = 0; it < Size; it++) tp[ it ] = p[ it ];
				delete[] p;
				p = tp;
			}
			return;
		}
		void exp (size_t ts) {
			while (ts >= Len) exp ();
			return;
		}
		type& operator [] (size_t it) {
			if (it >= Len) exp (it);
			return p[ it ];
		}
		type at (size_t it) {
			if (it >= Len) exp (it);
			return p[ it ];
		}
		void push_back (type x) {
			if (Size == Len) exp ();
			p[ Size++ ] = x;
			return;
		}
		void push_back (vector <type> vc) {
			for (size_t i = 0; i < vc.size(); i++) push_back (vc[i]);
			return;
		}
		void pop_back () {
			if (Size > 0) Size--;
			return;
		}
		void pop_back (size_t ts) {
			if (Size >= ts) Size -= ts;
			else Size = 0;
			return;
		}
		void insert (size_t it, type x) {
			if (Size == Len) exp ();
			for (size_t it_t = Size; it_t > it; it_t--) p[ it_t ] = p[it_t - 1];
			p[ it ] = x;
			Size++;
			return;
		}
		void erase (size_t it) {
			Size--;
			for (size_t it_t = it; it_t < Size; it_t++) p[ it_t ] = p[it_t + 1];
			return;
		}
		void reverse () {
			for (size_t it = 0; it < (Size >> 1); it++) {
				type tt = p[ it ];
				p[ it ] = p[Size - it - 1];
				p[Size - it - 1] = tt;
			}
			return;
		}
		void operator ++ () {
			if (Size == Len) exp ();
			Size++;
			return;
		}
		void operator ++ (int) {
			if (Size == Len) exp ();
			Size++;
			return;
		}
		void operator += (type x) {
			if (Size == Len) exp ();
			p[ Size++ ] = x;
			return;
		}
		void operator += (vector <type> vc) {
			for (size_t i = 0; i < vc.size(); i++) push_back (vc[i]);
			return;
		}
		void operator -- () {
			if (Size > 0) Size--;
			return;
		}
		void operator -- (int) {
			if (Size > 0) Size--;
			return;
		}
		void operator -= (size_t ts) {
			if (Size >= ts) Size -= ts;
			else Size = 0;
			return;
		}
		void operator = (vector <type> vc) {
			for (size_t i = 0; i < vc.size(); i++) push_back (vc[i]);
			return;
		}
};
template <typename type> struct node {
	type v;
	node <type>* pre;
	node <type>* next;
	node () {
		pre = next = NULL;
	}
};
template <typename type> class list {
	public:
		node <type>* head;
		node <type>* tail;
		list () {
			head = new node <type>;
			tail = new node <type>;
			head -> next = tail;
			tail -> pre = head;
		}
		~list () {
			node <type>* fn = head;
			node <type>* sn = head;
			while (fn !=NULL) {
				sn = sn -> next;
				delete fn;
				fn = sn;
			}
		}
		node <type>* begin () {
			return head;
		}
		node <type>* end () {
			return tail;
		}
		void push_back (type x) {
			node <type>* tn = new node <type>;
			tn -> v = x;
			tn -> pre = tail -> pre;
			tn -> next = tail;
			tail -> pre -> next = tn;
			tail -> pre = tn;
			return;
		}
		void push_back (list <type> tl) {
			node <type>* tn = tl.begin();
			tn = tn -> next;
			while (tn != tl.end()) {
				push_back(tn -> v);
				tn = tn -> next;
			}
			return;
		}
		void pop_back () {
			node <type>* tn = tail -> pre;
			if (tn != head) {
				tail -> pre = tn -> pre;
				tn -> pre -> next = tail;
				delete tn;
			}
			return;
		}
		void insert (node <type>* in, type x) {
			node <type>* tn = new node <type>;
			tn -> v = x;
			tn -> pre = in;
			tn -> next = in -> next;
			in -> next -> pre = tn;
			in -> next = tn;
			return;
		}
		void erase (node <type>* en) {
			node <type>* tn = en -> next;
			if (tn != tail) {
				en -> next = tn -> next;
				tn -> next -> pre = en;
				delete tn;
			}
			return;
		}
		void operator += (type x) {
			node <type>* tn = new node <type>;
			tn -> v = x;
			tn -> pre = tail -> pre;
			tn -> next = tail;
			tail -> pre -> next = tn;
			tail -> pre = tn;
			return;
		}
		void operator += (list <type> tl) {
			node <type>* tn = tl.begin();
			tn = tn -> next;
			while (tn != tl.end()) {
				push_back(tn -> v);
				tn = tn -> next;
			}
			return;
		}
		void operator -- () {
			node <type>* tn = tail -> pre;
			if (tn != head) {
				tail -> pre = tn -> pre;
				tn -> pre -> next = tail;
				delete tn;
			}
			return;
		}
		void operator = (list <type> tl) {
			node <type>* tn = tl.begin();
			tn = tn -> next;
			while (tn != tl.end()) {
				push_back(tn -> v);
				tn = tn -> next;
			}
			return;
		}
};

list <vector <char> >					doc;
node <vector <char> >*					ty;
iterator								tx;
node <vector <char> >*					py;
iterator								px;
short									cnt;
size_t									lines;
char									name[64];
char									path[64];
bool									isat[256];
std::map <std::string, byte_t>			keyword;

void whelp () {
	FILE* fp = fopen ("FCDOC\\help.txt", "w");
	fprintf (fp, helps);
	fclose (fp);
	return;
}
void rpath () {
	FILE* fp = fopen ("FCDOC\\path.txt", "r");
	if (fp == NULL) {
		printf ("Input path:");
		gets (path);
		FILE* sf = fopen ("path.txt", "w");
		fprintf (sf, "%s", path);
		fclose (sf);
	} else {
		fscanf (fp, "%s", path);
	}
	fclose (fp);
}
void init (int argc, char** argv) {
	printf ("init...\n");
	system ("title FastCode 1.5.0");
	system ("mode con lines=32 cols=132");
	if (argc != 1) {
		int ch;
		vector <char> tv;
		FILE* fp = fopen (argv[1], "r");
		printf ("Loadind...\n");
		iterator nt = strlen (argv[1]) - 1;
		for (; nt > 0; nt--)
			if (argv[1][nt] == '\\')
				break;
		for (iterator it = 0; argv[1][nt] != '\0'; it++)
			name[it] = argv[1][++nt];
		ch = fgetc (fp);
		while (ch != EOF) {
			if (ch == 10) {
				node <vector <char> >* tn = new node <vector <char> >;
				for (iterator it = 0; it < tv.size(); it++)
					tn -> v.push_back (tv[it]);
				tn -> pre = doc.tail -> pre;
				tn -> next = doc.tail;
				doc.tail -> pre -> next = tn;
				doc.tail -> pre = tn;
				while (tv.size () != 0)
					tv.pop_back ();
			} else if (ch == 9) {
				tv += ' ';
				tv += ' ';
				tv += ' ';
				tv += ' ';
			} else {
				tv += ch;
			}
			printf ("%c", ch);
			ch = fgetc(fp);
		}
		if (tv.size () != 0) {
			node <vector <char> >* tn = new node <vector <char> >;
			for (iterator it = 0; it < tv.size(); it++)
				tn -> v.push_back (tv[it]);
			tn -> pre = doc.tail -> pre;
			tn -> next = doc.tail;
			doc.tail -> pre -> next = tn;
			doc.tail -> pre = tn;
		}
		fclose(fp);
	} else {
		printf ("Input name:");
		vector <char> tv;
		doc += tv;
		gets (name);
	}
	char ts[64];
	sprintf (ts, "title %s", name);
	system (ts);
	ty = doc.begin () -> next;
	tx = 0;
	py = doc.begin () -> next;
	px = 0;
	CONSOLE_CURSOR_INFO cursor_info = {1, 0};
	SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info);
	isat['~']							= true;
	isat['!']							= true;
	isat['%']							= true;
	isat['^']							= true;
	isat['&']							= true;
	isat['*']							= true;
	isat['(']							= true;
	isat[')']							= true;
	isat['-']							= true;
	isat['+']							= true;
	isat['=']							= true;
	isat['{']							= true;
	isat['}']							= true;
	isat['[']							= true;
	isat[']']							= true;
	isat['|']							= true;
	isat[':']							= true;
	isat[';']							= true;
	isat['<']							= true;
	isat['>']							= true;
	isat[',']							= true;
	isat['.']							= true;
	isat['?']							= true;
	isat['/']							= true;
	keyword["alignas"]					= 11;
	keyword["alignof"]					= 11;
	keyword["and"]						= 11;
	keyword["and_eq"]					= 11;
	keyword["asm"]						= 11;
	keyword["auto"]						= 11;
	keyword["bitand"]					= 11;
	keyword["bitor"]					= 11;
	keyword["bool"]						= 11;
	keyword["break"]					= 11;
	keyword["case"]						= 11;
	keyword["catch"]					= 11;
	keyword["char"]						= 11;
	keyword["char16_t"]					= 11;
	keyword["char32_t"]					= 11;
	keyword["class"]					= 11;
	keyword["compl"]					= 11;
	keyword["const"]					= 11;
	keyword["constexpr"]				= 11;
	keyword["const_cast"]				= 11;
	keyword["continue"]					= 11;
	keyword["decltype"]					= 11;
	keyword["default"]					= 11;
	keyword["delete"]					= 11;
	keyword["do"]						= 11;
	keyword["double"]					= 11;
	keyword["dynamic_cast"]				= 11;
	keyword["else"]						= 11;
	keyword["enum"]						= 11;
	keyword["explicit"]					= 11;
	keyword["export"]					= 11;
	keyword["extern"]					= 11;
	keyword["false"]					= 11;
	keyword["float"]					= 11;
	keyword["for"]						= 11;
	keyword["friend"]					= 11;
	keyword["goto"]						= 11;
	keyword["if"]						= 11;
	keyword["inline"]					= 11;
	keyword["int"]						= 11;
	keyword["long"]						= 11;
	keyword["mutable"]					= 11;
	keyword["namespace"]				= 11;
	keyword["new"]						= 11;
	keyword["noexcept"]					= 11;
	keyword["not"]						= 11;
	keyword["not_eq"]					= 11;
	keyword["nullptr"]					= 11;
	keyword["operator"]					= 11;
	keyword["or"]						= 11;
	keyword["or_eq"]					= 11;
	keyword["private"]					= 11;
	keyword["protected"]				= 11;
	keyword["public"]					= 11;
	keyword["register"]					= 11;
	keyword["reinterpret_cast"]			= 11;
	keyword["return"]					= 11;
	keyword["short"]					= 11;
	keyword["signed"]					= 11;
	keyword["sizeof"]					= 11;
	keyword["static"]					= 11;
	keyword["static_assert"]			= 11;
	keyword["static_cast"]				= 11;
	keyword["struct"]					= 11;
	keyword["switch"]					= 11;
	keyword["template"]					= 11;
	keyword["this"]						= 11;
	keyword["thread_local"]				= 11;
	keyword["throw"]					= 11;
	keyword["true"]						= 11;
	keyword["try"]						= 11;
	keyword["typedef"]					= 11;
	keyword["typeid"]					= 11;
	keyword["typeof"]					= 11;
	keyword["typename"]					= 11;
	keyword["union"]					= 11;
	keyword["unsigned"]					= 11;
	keyword["using"]					= 11;
	keyword["virtual"]					= 11;
	keyword["void"]						= 11;
	keyword["volatile"]					= 11;
	keyword["wchar_t"]					= 11;
	keyword["while"]					= 11;
	keyword["xor"]						= 11;
	keyword["xor_eq"]					= 11;
	system ("cls");
	return;
}
void save () {
	FILE* fp = fopen(name, "w");
	node <vector <char> >* sp = doc.begin () -> next;
	while (sp != doc.end ()) {
		for (iterator it = 0; it < sp -> v.size(); it++)
			fputc (sp -> v[it], fp);
		fputc ('\n', fp);
		sp = sp -> next;
	}
	fclose(fp);
	return;
}
void output () {
	gotoxy (0, 0);
	node <vector <char> >* pt = py;
	char prts[128];
	for (iterator yy = 0; yy < 31 && pt != doc.end (); yy++) {
		iterator xx;
		bool isinc	= false;
		bool isstr	= false;
		bool isch	= false;
		bool isnum	= false;
		std::string	ks;
		color(112);
		printf ("%4d ", (int)(lines + yy));
		for (xx = 0; xx < 121 && xx + px < pt -> v.size (); xx++) {
			char putch = pt -> v.at(xx + px);
			if ((!isinc) && (!isstr) && (!isch)) {
				if ((putch >= 'A' && putch <= 'Z') || (putch >= 'a' && putch <= 'z') || (putch >= '0' && putch <= '9') || putch == '_')
					ks += putch;
				else {
					if (keyword[ks] != 0) {
						memset (prts, '\b', sizeof(prts));
						prts[ks.size ()] = '\0';
						printf (prts);
						for (iterator it = 0; it < ks.size(); it++) {
							if (pt == ty && xx + px - ks.size() + it == tx)
								color (240);
							else
								color(keyword[ks]);
							printf ("%c", ks[it]);
						}
					}
					ks = "";
				}
			} else ks = "";
			if (putch == ' ' || isat[(int)putch] == true || xx + px == 0)
				isnum = true;
			else if(putch < '0' || putch > '9')
				isnum = false;
			if ((!isstr) && (!isch)  && (isinc || putch == '#'))  {
				color (10);
				isinc = true;
			} else if ((!isinc) && (!isch)  && (isstr || putch == '\"')) {
				color (11);
				if (pt -> v[xx + px] == '\"')
					isstr = !isstr;
			} else if ((!isinc) && (!isstr) && (isch  || putch == '\'')) {
				color (14);
				if (pt -> v[xx + px] == '\'')
					isch  = !isch;
			} else if ((!isinc) && (!isstr) && (!isch) && (isnum) && (putch >= '0' && putch <= '9'))
				color (11);
			else if (isat[(int)putch] == true)
				color(9);
			else
				color (15);
			if (pt == ty && xx + px == tx)
				color (240);
			printf ("%c", putch);
		}
		if (pt == ty && tx == pt -> v.size ())
			color (240);
		else
			color (15);
		printf (" ");
		color (15);
		memset(prts, ' ', sizeof (prts));
		prts[121 - xx] = '\0';
		printf ("%s\n", prts);
		pt = pt -> next;
	}
	printf ("%126c", ' ');
	return;
}
void input () {
	int		ch;
	bool	lock = true;
	while (true) {
		if (lock)
			output ();
		ch = getch ();
		if (ch == 8) {
			if (tx == 0) {
				if (ty -> pre != doc.begin ()) {
					ty = ty -> pre;
					tx = ty -> v.size();
					for (iterator it = 0; it < ty -> next -> v.size (); it++)
						ty -> v += ty -> next -> v[it];
					doc.erase (ty);
					cnt--;
				}
			} else {
				ty -> v.erase (tx - 1);
				tx--;
			}
		} else if (ch == 9) {
			iterator it = 4;
			while (it--) {
				ty -> v.insert (tx, ' ');
				tx++;
			}
		} else if (ch == 10) {
			char prt[128];
			memset(prt, '\b', sizeof(prt));
			prt[127] = '\0';
			printf("%s:", prt);
			ch = getchar ();
			switch (ch) {
				case 'h':
				case 'H':
				case '?': {
					printf (helps);
					system ("pause");
					break;
				}
				case 's':
				case 'S': {
					save ();
					break;
				}
				case 'q':
				case 'Q': {
					save ();
					return;
				}
				case '!': {
					return;
				}
				case 'o':
				case 'O': {
					save ();
					char						calls[128];
					sprintf (calls, "%s -o3 %s", path, name);
					printf("%s\n", calls);
					system (calls);
					system ("start 3.exe");
					system ("pause");
					break;
				}
				case 't':
				case 'T':
				case '^': {
					tx							= 0;
					cnt							= 0;
					lines						= 0;
					ty							= doc.begin () -> next;
					py							= doc.begin () -> next;
					break;
				}
				case 'l':
				case 'L':
				case 'y':
				case 'Y':
				case '@': {
					unsigned int	linenum;
					scanf ("%d", &linenum);
					tx							= 0;
					cnt							= 0;
					lines						= 0;
					ty							= doc.begin () -> next;
					py							= doc.begin () -> next;
					for (iterator it = 0; it < linenum; it++) {
						if (ty -> next != doc.end ()) {
							ty					= ty -> next;
							py					= py -> next;
							lines++;
						}
					}
					break;
				}
				case 'x':
				case 'X': {
					unsigned int				colnum;
					scanf ("%d", &colnum);
					tx = colnum;
					if (tx < 0)
						tx = 0;
					if (tx > ty -> v.size())
						tx = ty -> v.size();
					break;
				}
				case '<': {
					int							len;
					bool						okk;
					char						word[128];
					getchar ();
					gets (word);
					len = strlen(word);
					while (ty -> pre != doc.begin()) {
						tx = 0;
						ty = ty -> pre;
						cnt--;
						for (; (signed int)tx < (signed int)ty -> v.size() - len; tx++) {
							okk = true;
							for (iterator it = 0; it < len; it++) {
								if (word[it] != ty -> v[tx + it]) {
									okk = false;
									break;
								}
							}
							if (okk) {
								goto FL_END;
							}
						}
					}
					break;
					FL_END:
					break;
				}
				case '>': {
					int							len;
					bool						okk;
					char						word[128];
					getchar ();
					gets (word);
					len = strlen(word);
					while (ty -> next != doc.end()) {
						tx = 0;
						ty = ty -> next;
						cnt++;
						for (; (signed int)tx < (signed int)ty -> v.size() - len; tx++) {
							okk = true;
							for (iterator it = 0; it < len; it++) {
								if (word[it] != ty -> v[tx + it]) {
									okk = false;
									break; 
								}
							}
							if (okk) {
								goto FR_END;
							}
						}
					}
					break;
					FR_END:
					break;
				}
				case '-': {
					int							num;
					scanf ("%d", &num);
					for (iterator it = 0; it < num; it++) {
						if (tx > 0) {
							tx--;
							ty -> v.erase (tx);
						}
					}
					break;
				}
				case '{': {
					int							num;
					int							step;
					int							begin;
					char 						word[128];
					scanf ("%d,%d,%d", &num, &begin, &step);
					for (iterator it = 0; it < num; it++) {
						sprintf (word, "%d", it * step + begin);
						for (iterator i = 0; word[i] != '\0'; i++) {
							ty -> v.insert (tx, word[i]);
							tx++;
						}
						ty -> v.insert (tx, ',');
						tx++;
						ty -> v.insert (tx, ' ');
						tx++;
					}
					break;
				}
				case '\"': {
					int							num;
					int							step;
					char						begin;
					scanf ("%d,%c,%d", &num, &begin, &step);
					for (iterator it = 0; it < num; it++) {
						ty -> v.insert (tx, (char)(it * step) + begin);
						tx++;
					}
					break;
				}
				case '|': {
					int							num;
					int							deln;
					int							step;
					int							begin;
					char						ch;
					char						str[128];
					node <vector <char> >*		tn = ty;
					scanf ("%d,%d,%d,%c", &num, &begin, &step, &ch);
					if (ch == '-') {
						scanf ("%d", &deln);
						tx -= deln;
						while (tx < 0) {
							tx++;
							deln--;
						}
					} else if (ch == '+') {
						getchar ();
						gets (str);
					}
					for (iterator it = 0; it < num; it++) {
						if (ch == '-') {
							for (iterator it = 0; it < deln; it++)
								tn -> v.erase (tx);
						} else if (ch == '+') {
							for (iterator l = 0; str[l] != '\0'; l++)
								tn -> v.insert (l + tx, str[l]);
						}
						for (iterator l = 0; l < step; l++) {
							if (tn -> next != doc.end())
								tn = tn -> next;
							else
								goto LF_END;
						}
					}
					break;
					LF_END:
					break;
				}
				case '/': {
					ty -> v.insert (0, '#');
					ty -> v.insert (0, '/');
					ty -> v.insert (0, '/');
					tx = 0;
					break;
				}
				case 'k':
				case 'K': {
					char						word[128];
					scanf ("%s", word);
					keyword[word] = 11;
					break;
				}
				case 'p':
				case 'P': {
					unsigned int				tcolor;
					char						word[128];
					scanf ("%s", word);
					scanf ("%d", &tcolor);
					keyword[word] = (byte_t)tcolor;
					break;
				}
				case 'w':
				case 'W':
				case '$': {
					char						calls[128];
					getchar ();
					gets (calls);
					system (calls);
					system ("pause");
					break;
				}
				case 'c':
				case 'C':
				case '=': {
					std::string					TempBin;
					HGLOBAL						hMemBin = NULL;
					PCHAR						LockBin = NULL;
					node <vector <char> >*		tn = doc.begin () -> next;
					OpenClipboard(NULL);
					EmptyClipboard();
					while (tn != doc.end ()) {
						for (iterator it = 0; it < tn -> v.size (); it++)
							TempBin += tn -> v[it];
						TempBin += '\n';
						tn = tn -> next;
					}
					hMemBin = GlobalAlloc(GMEM_MOVEABLE, TempBin.size() + 1);
					LockBin = (PCHAR)GlobalLock(hMemBin);
					RtlMoveMemory(LockBin, TempBin.c_str(), TempBin.size() + 1);
					GlobalUnlock(hMemBin);
					LockBin = NULL;
					SetClipboardData(CF_TEXT, hMemBin);
					CloseClipboard();
					break;
				}
				case 'v':
				case 'V':
				case '~': {
					lock = !lock;
					break;
				}
				default:
					break;
			}
			CONSOLE_CURSOR_INFO cursor_info = {1, 0};
			SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info);
			system ("cls");
		} else if (ch == 13) {
			node <vector <char> >* tn = new node <vector <char> >;
			for (iterator it = tx; it < ty -> v.size (); it++) tn -> v += ty -> v[it];
			ty -> v -= (ty -> v.size() - tx);
			tn -> pre = ty;
			tn -> next = ty -> next;
			ty -> next -> pre = tn;
			ty -> next = tn;
			ty = ty -> next;
			tx = 0;
			cnt++;
		} else if (lock && ch == '(')  {
			ty -> v.insert (tx, (char)ch);
			tx++;
			ty -> v.insert (tx, ')');
		} else if (lock && ch == '[')  {
			ty -> v.insert (tx, (char)ch);
			tx++;
			ty -> v.insert (tx, ']');
		} else if (lock && ch == '{')  {
			ty -> v.insert (tx, (char)ch);
			tx++;
			ty -> v.insert (tx, '}');
		} else if (lock && ch == '\"') {
			ty -> v.insert (tx, (char)ch);
			tx++;
			ty -> v.insert (tx, '\"');
		} else if (lock && ch == '\'') {
			ty -> v.insert (tx, (char)ch);
			tx++;
			ty -> v.insert (tx, '\'');
		} else if (ch == 224) {
			ch = getch ();
			switch (ch) {
				case UP: {
					if (ty -> pre != doc.begin ()) {
						ty = ty -> pre;
						tx = min (tx, ty -> v.size ());
						cnt--;
					}
					break;
				}
				case DOWN: {
					if (ty -> next != doc.end ()) {
						ty = ty -> next;
						tx = min (tx, ty -> v.size ());
						cnt++;
					}
					break;
				}
				case LEFT: {
					if (tx > 0)
						tx--;
					break;
				}
				case RIGHT: {
					if (tx < ty -> v.size ())
						tx++;
					break;
				}
			}
		} else {
			ty -> v.insert (tx, (char)ch);
			tx++;
		}
		while (cnt > 30) {
			lines++;
			cnt--;
			py = py -> next;
		}
		while (cnt < 0) {
			lines--;
			cnt++;
			py = py -> pre;
		}
	}
	return;
}
int main (int argc, char** argv) {
	whelp ();
	rpath ();
	init (argc, argv);
	input ();
	return 0;
}

 更新到第五个版本了,真不容易啊

之前都忘记说各个版本所更新的功能了,就在这里讲讲吧

FastCode1.1:黑屏白字,只有文本编辑功能,保存功能

FastCode1.2:代码高亮显示

FastCode1.3:编译命令及其他简单命令

FastCode1.4:自定义关键字

FastCode1.5:填充指令

使用示例:

编译:

'{'填充:

向上查找:

帮助文档:

<Ctrl+Enter>        :    command
<h,H,?>            :    help
<s,S>            :    save
<q,Q>            :    quit and save
<!>            :    quit
<o,O>            :    compile
<t,T,^>            :    top
<l,L,y,Y,@> num        :    y = num
<x,X> num        :    x = num
<k,K> str            :    str = keyword
<p,P> str num        :    str = color (num)
<w,W,$> + Enter+ str    :    system (str)
<c,C,=>            :    copy
<v,V,~>            :    paste
< < > str            :    find(str)
< > > str            :    find(str)
<-> num            :    erase(num)
<{> num,begin,step        :    {begin,begin+step,begin+step*2,...}
<"> num,begin,step        :    "begin,begin+step,begin+step*2,..."
<|> num,begin,step,+    :
<|> num,begin,step,-    :
 

你好!蒋韦杰-（烟雨平生）
关注
  • 20
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
百度编辑器ueditor-dev-1.5.0官方最新版utf8-net.rar
01-16
作为一个重要的更新，1.5.0版确保了与各种浏览器和平台的兼容性，同时提升了编辑器的稳定性和效率。 **2. UTF-8编码支持** “utf8-net”这部分可能指的是编辑器对UTF-8字符编码的支持。UTF-8是一种广泛使用的...
sdcms 2.0beta2 asp版本 升级百度编辑器1.2.0 到 1.5.0
03-28
1. **下载新版本**: 首先需要从官方渠道或者可靠的资源库下载百度编辑器1.5.0的最新版本，确保文件完整无误。在这个例子中，文件名为"sd_cms_update_ueditor"，可能包含编辑器的新版本文件。 2. **备份原有文件**: ...
百度编辑器ueditor-dev-1.5.0官方最新版gbk-net.rar
01-16
综上所述，UEditor 1.5.0官方最新版是一个功能强大且易用的富文本编辑器，尤其适用于需要处理中文内容的网站和应用程序。通过其丰富的特性，开发者可以轻松创建出符合业务需求的高质量在线编辑体验。
百度编辑器ueditor-dev-1.5.0 utf8-php 编译版
06-13
百度编辑器拥有活跃的开发者社区，提供详细的文档、示例代码和常见问题解答，帮助开发者解决在使用过程中遇到的问题。此外，社区还分享了许多定制案例和插件，进一步丰富了编辑器的功能。 总的来说，ueditor-dev-...
Editor.md Markdown编辑器 v1.5.0.zip
03-21
Editor.md是一款基于Markdown语法的开源在线编辑器，其版本v1.5.0在源码分享社区中备受瞩目。Markdown是一种轻量级的标记语言，允许用户通过简单的文本格式来创建结构化的文档，如网页、博客文章、报告等，而Editor....
又缩水Unity7月闪促限时4折活动模块化角色模板编辑器场景美术插件拖尾怪物3D模型UI载具AI对话TPS飞机RPG和FPS202407
taddycs的博客
07-18 435
太平洋时间 2024 年 7 月 17 日 8：00：00 至 2024 年 7 月 24 日 7：59：00（太平洋时间）这次Unity商店促销又缩水了，前几年有限时限量1折，然后3折4折5折，今年只有4折。带AI功能的对话系统，支持chatGPT等语言模型、环境材质贴图包、流体模拟。RPG魅魔角色动作包、带细节的草丛植被工具、DOTS星球地形生成。物理汽车控制器、Q版自定义表情飞龙包、仿生异形巢穴结构素材。写实元素龙模型、科幻材质包、自然渲染带细节草丛2021版。
Atlassian Intelligence工具集解析：从自然语言到JQL处理，从虚拟代理到AI摘要、编辑器中的生成式AI等，全方位提升团队协作效率
weixin_49715102的博客
07-21 755
通过人机协作，用户可以卸下繁琐、重复的任务，专注于自己的实际技能，并执行更有影响力的工作。编辑器中的生成式AI通过重组、改写内容或提示您的额外问题来阐明您的内容，从而提示审查并简化您的问题。Rovo还理解搜索不是一个孤立的操作，它允许用户在Confluence中搜索资产的同时，查看相关的Jira工单或来自其他工具的信息。借助AI驱动的图表洞察，团队可以查看Atlassian Analytics仪表板，只需单击一个按钮，即可收到快速摘要、趋势评论，以及使数据更具可操作性的建议。这也不是他们的问题。
webgoat-server-8.2.2.zip
07-21
解压即可得到webgoat-server-8.2.2.jar
人工智能行业深度报告：WAIC2024，国产AI+应用“百花齐放”
07-21
2024年世界人工智能大会（WAIC 2024）上，国产AI+应用生态呈现“百花齐放”的局面 1. WAIC 2024：国产 AI+应用生态“百花齐放” 多家厂商携大模型及AI应用成果亮相展会，涵盖金山办公、科大讯飞、华为、商汤等知名企业。 OpenAI 禁令加速推动国产 AI 生态，国产大模型性能持续提升，缩小与海外差距。 预计未来国产 AI+行业应用将迎来“百花齐放”局面，商业空间加速打开。 2. 国产大模型加速迭代，代表性厂商生态加速构建 科大讯飞 发布星火 V4.0 大模型，全面对标 GPT-4 Turbo，多模态能力显著提升。 星火医疗和教育垂类模型能力升级，赋能行业应用落地。 推出星火企业智能平台，赋能企业构建岗位专属助手。 华为 发布盘古大模型 5.0 系列，包括不同参数规模，适用于多种场景。 推出盘古具身智能大模型，推动人形机器人技术升级。 盘古 5.0 赋能华为小艺升级，在多个行业落地应用。 商汤 发布“日日新 5.5”模型，交互体验对标 GPT-4o，多模态能力实现突破。 推出面向 C 端用户的可控人物视频生成模型 Vimi。 率先实现原生多模态大模型车端部署
java毕设&课设-基于web的实验室管理系统（自动排课功能的实现）.zip
07-21
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
丽珠集团000513.SZ公司首次覆盖报告：创新药与高壁垒制剂齐推进，多元化布局促发展.pdf
07-21
丽珠集团000513.SZ公司首次覆盖报告：创新药与高壁垒制剂齐推进，多元化布局促发展
线性预测房屋价格加清洗评估加分析-项目实战5-分析房屋价格数据-ipynb格式-Python语法-用Jupyter打开
07-21
线性预测房屋价格加清洗评估加分析-项目实战5-分析房屋价格数据-ipynb格式-Python语法-用Jupyter notebook打开 用来练习多元线性回归及预测和清洗评估和分析，整个流程特别清晰，每个步骤均用Makedown编辑器进行编辑文字，每一步都给出了清晰的代码以及压缩包中给出了相应的数据集，可以按照步骤一步一步进行模仿，理解其中的思维逻辑，然后上手进行操作，在操作的过程中不断思考，等能力有了很大提升之后，就可以慢慢独立思考从事项目了 最后祝您变得更强
骨科高值耗材：全面集采后，如何看骨科赛道投资机会？.pdf
07-21
骨科高值耗材：全面集采后，如何看骨科赛道投资机会？
mingw+cmake+QT的GeographicLib库
07-21
mingw+cmake+QT的GeographicLib库
高级语言程序设计大作业C++基于Qt编写的俄罗斯方块游戏源代码+实验报告，面向对象
07-21
高级语言程序设计大作业C++基于Qt编写的俄罗斯方块游戏源代码+实验报告，面向对象 开发软件 Qtcreator12.04
pythom剧情游戏.zip
最新发布
07-21
pythom剧情游戏
AI人工智能行业调研研究报告 苹果公司发布首份人工智能报告，AI视觉是研究新方向 共37页.pdf
07-21
AI人工智能行业调研研究报告 苹果公司发布首份人工智能报告，AI视觉是研究新方向 共37页
机动目标跟踪的自适应卡尔曼滤波算法实现.zip
07-21
机动目标跟踪的自适应卡尔曼滤波算法实现.zip
深入Java NIO：释放IO性能的新维度
07-21
Java是一种广泛使用的编程语言，由Sun Microsystems公司（现属于Oracle公司）在1995年首次发布。它是一种面向对象的语言，意味着它将现实世界中的事物抽象为对象，这些对象具有属性（数据）和方法（行为）。Java语言设计目标包括跨平台性、网络编程能力、健壮性、安全性和简单性。 ### Java的主要特点： 1. **跨平台性**：Java的口号是“一次编写，到处运行”（Write Once, Run Anywhere，简称WORA）。这得益于Java的运行时环境，即Java虚拟机（JVM），它允许Java程序在任何安装了JVM的平台上运行，而不需要重新编译。 2. **面向对象**：Java是一种面向对象的语言，支持封装、继承和多态等特性。 3. **健壮性**：Java设计时注重安全性和错误处理，例如通过强类型检查和异常处理机制。 4. **多线程**：Java内置了对多线程编程的支持，允许开发者创建同时执行的多个线程。 5. **网络编程**：Java提供了丰富的网络通信API，使得开发网络应用变得容易。 6. **安全性**：Java提供了一个安全
guacamole1.5.0
07-27
很抱歉，我无法回答关于guacamole 1.5.0的问题。根据提供的引用内容，最新版本是guacamole-server 1.1.0 \[1\]，并且引用中没有提到guacamole 1.5.0的相关信息。如果你对guacamole 1.5.0有任何疑问，建议你查阅官方文档或者参考其他可靠的资源来获取相关信息。 #### 引用[.reference_title] - *1* [Guacamole系列一：服务端安装](https://blog.csdn.net/gaozhi0/article/details/105429872)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [超详细讲解搭建guacamole实现远程桌面](https://blog.csdn.net/asd372506589/article/details/106399868)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [【Guacamole中文文档】二、用户指南—— 2.Guacamole源码安装](https://blog.csdn.net/weixin_39974140/article/details/123044694)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值