代码编辑器1.6.0

最新推荐文章于 2024-07-21 14:31:55 发布
最新推荐文章于 2024-07-21 14:31:55 发布
阅读量336 收藏 7
点赞数 4
分类专栏： FastCode 文章标签： 编辑器 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80029762/article/details/135318980
版权

 

#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 H										30
#define W										100
 
#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 (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 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 += (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 (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 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 += (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.6.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 doccopy (const char* from, const char* to) {
	FILE* fp									= fopen (from, "r");
	if (fp == NULL) {
		printf ("Fail!\n");
		return;
	}
	FILE* tp									= fopen (to, "w");
	char ch;
	ch = fgetc (fp);
	while (ch != EOF) {
		fputc (ch, tp);
		ch = fgetc (fp);
	}
	fclose (fp);
	fclose (tp);
	printf ("OKK!\n");
	return;
}
void output () {
	gotoxy (0, 0);
	node <vector <char> >* pt = py;
	char prts[W];
	for (iterator yy = 0; yy < H - 1 && 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 < W - 7 && 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[W - 7 - xx] = '\0';
		printf ("%s\n", prts);
		pt = pt -> next;
	}
	printf ("%126c", ' ');
	return;
}
void input () {
	int											ch;
	bool										lock = true;
	output ();
	while (true) {
		if (kbhit () != 0) {
			while (kbhit () != 0) {
				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[W];
							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[W];
							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[W];
							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[W];
							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[W];
							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[W];
							scanf ("%s", word);
							keyword[word] = 11;
							break;
						}
						case 'p':
						case 'P': {
							unsigned int				tcolor;
							char						word[W];
							scanf ("%s", word);
							scanf ("%d", &tcolor);
							keyword[word]				= (byte_t)tcolor;
							break;
						}
						case 'w':
						case 'W':
						case '$': {
							char						calls[W];
							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;
						}
						case 'm':
						case 'M':
						case '%': {
							char						from[64];
							char						to[64];
							getchar ();
							gets (from);
							gets (to);
							doccopy (from, to);
							system ("pause");
							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 > H - 2) {
					lines++;
					cnt--;
					py									= py -> next;
				}
				while (cnt < 0) {
					lines--;
					cnt++;
					py									= py -> pre;
				}
			}
			if (lock) {
				output ();
			}
		}
	}
	return;
}
int main (int argc, char** argv) {
	whelp ();
	rpath ();
	init (argc, argv);
	input ();
	return 0;
}

你好!蒋韦杰-（烟雨平生）
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
苹果手机python编辑器_‎App Store 上的“Python AI - 代码编辑器”
weixin_30213477的博客
01-13 1075
PythonAI 专业的手机版编程开发软件。含有丰富的编程基础、数据科学、机器学习、深度学习等教程与软件完美结合。【功能介绍】- 自动联想、自动缩进、代码颜色、横屏开发。- 内置浏览器、文本编辑器、运行脚本代码。- 输入脚本、可解析与执行脚本程序，支持input- 代码颜色及字体大小，左右移动光标，方便阅读与书写- 扩展键盘，提示信息、源码格式化、代码2to3- 内置基础学习资料【内置模块】- p...
微信Markdown编辑器 v1.6.0.zip
03-27
微信Markdown编辑器 v1.6.0.zip
wysiwyg html 编辑器,漂亮的富文本编辑器WYSIWYG
weixin_42206399的博客
06-10 595
插件描述： 接下来我要为大家介绍一款好看的富文本编辑器 wysiwyg 。先来看看官方对这款编辑器的相关功能描述吧。接下来我要为大家介绍一款好看的富文本编辑器 wysiwyg 。先来看看官方对这款编辑器的相关功能描述吧。1、在Mac和Wndows平台上能够自动针对常用操作绑定标准热键2、可以通过拖拽插入图片；支持图片上传(也可以获取移动设备上的照片)3、语音识别输入(仅限Chrome浏览器)4、允...
ipad上python编辑器_‎App Store 上的“Python AI - 代码编辑器”
weixin_39620065的博客
12-05 429
PythonAI 专业的手机版编程开发软件。含有丰富的编程基础、数据科学、机器学习、深度学习等教程与软件完美结合。【功能介绍】- 自动联想、自动缩进、代码颜色、横屏开发。- 内置浏览器、文本编辑器、运行脚本代码。- 输入脚本、可解析与执行脚本程序，支持input- 代码颜色及字体大小，左右移动光标，方便阅读与书写- 扩展键盘，提示信息、源码格式化、代码2to3- 内置基础学习资料【内置模块】- p...
CocosStudio UI编辑器（1.6.0）使用调研 （基于cocos2dx-3.2)
聚焦游戏和图形引擎开发技术
11-14 5060
CocosStudio UI编辑器（1.6.0）使用调研 （基于cocos2dx-3.2) 1. 游戏使用的分辨率适配模式 核心设计区域960*640, 对于宽屏使用fix height 640, 对于方屏（如ipad)使用fix width 960, 保证任意屏幕设计分辨率至少为960*640 例如： iphone5 设计分比率为 1136*640， ipad为960*720 因
## 自制java代码编辑器 关键字高亮,代码补全,排版自定义,系统硬盘操作
qq_28382487的博客
11-03 1117
  # 标题 ***1.自定义排版*** ***需要 javadocking.jar包,*** ***代码的jar包资源*** ***   [https://download.csdn.net/download/qq_28382487/10761535] (https://download.csdn.net/download/qq_28382487/10761535)  *** p...
前端开发 Atom 编辑器插件安装和配置
juddy123的博客
02-24 877
1.启动速度 启动速度是大家唯一吐槽 Atom 的地方吧。不过到现在的1.6.0版本的时候，我觉得已经比刚发布的时候好多了。 原生提供了命令来测试自己的启动消耗时间： 使用方式如下： cmd+shift+p打开命令面板，然后输入 timecope：view 命令就会出现下面的结果,可以查看启动时间和安装插件的加载时间: 2.插件列表和使用方法： 使用 ap
使用poi-tl根据富文本编辑器代码生成word下载功能
贤和知识点收藏
06-07 1449
poi-tl在线生成word文档
从实现原理谈谈低代码
朱小厮的博客
05-22 923
点击上方“朱小厮的博客”，选择“设为星标”后台回复"书"，获取后台回复“k8s”，可领取k8s资料我们在低代码领域探索了很多年，从2015 开始研发低代码前端渲染（amis），从 2018 年开研发后端低代码数据模型，发布了爱速搭低代码平台，这些年调研过了几乎所有市面上的相关技术和产品，发现虽然每家产品细节都不太一样，但在底层技术上却只有少数几种方案，因此我们认为不同产品...
torch.nn模块不能代码补全
weixin_64064486的博客
04-26 1149
问题背景 torch1.6.0的版本在pycharm，nn.后没有自动补全的相关提示网上都说对于1.6.0版本的pytorch再pycharm里是没有办法自动补全的，因此这算是一个暂时恒定的bug。 分析原因 pycharm的自动提示是根据第三方包的每个文件夹下的__init__.pyi文件来显示的，只有__init__.pyi中import了的API才会被pycharm自动提示。 解决方法 需要生成__init__.pyi，文件内容如下： from .module import Module
自己动手写编辑器——Lumia Sidebar
Phodal's zenthink
04-14 3205
似乎从一开始我们就是在模仿别人的editor，不知道这是不是必要的，但是在有时候觉得没有必要再造一个轮子，或者说我们应该考虑我们想要的功能到系统里，而不是和别人一样？ 最后效果 Mock atom编辑器到这里算是要告一段落了，献上截图一张。 Makefile 或许写脚本会比较好，但是还是没有Makefile给人的感觉爽 代码还是在github上，可能会有点大，中间还经
VSCode1.60.rar
09-06
《Visual Studio Code 1.60 - 跨平台代码编辑器的深度解析》 Visual Studio Code（简称VSCode）是一款由微软开发的免费且开源的代码编辑器，它以其强大的功能、高效的性能以及友好的用户界面深受全球开发者喜爱。...
MachWriteformac(文本编辑器)V1.6.0苹果电脑版
08-06
Mach Write for mac是一款可以在苹果电脑MAC OS平台上使用的功能强大的文本编辑器，它不仅跨 iOS 和 OS X 两大平台，还支持多种格式的文档编辑，如Rich Text格式、纯文本、PDF格式等等。不仅如此，这款软件还具有...
jdk1.6.0_24_win.zip
10-09
打开“系统属性” -> “高级” -> “环境变量”，在“系统变量”部分创建或编辑以下两个变量： - `JAVA_HOME`：设置为JDK的安装路径，例如`D:\Java\jdk1.6.0_24`。 - `PATH`：在原有值的末尾添加`%JAVA_HOME%\bin;...
JDK1.6.0_23
01-24
1. **语言增强**：JDK1.6引入了一些语言层面的改进，如增强的for循环（也称为foreach循环），枚举类型，泛型，注解（Annotations）等，使得代码更加简洁和可读。 2. **性能优化**：此版本对JVM进行了大量优化，提升...
Typora 1.5.8 版本安装下载教程 (轻量级 Markdown 编辑器)，图文步骤详解，免费领取（软件可激活使用）
m0_59470317的博客
07-18 1344
Typora是一款基于Markdown语法的轻量级文本编辑器，它的主要目标是为用户提供一个简洁、高效的写作环境。实时预览：Typora支持实时预览功能，当用户在编辑区输入Markdown语法时，右侧的预览窗口会立即显示渲染后的效果，使用户可以直观地看到文章的最终呈现效果。所见即所得：Typora采用了所见即所得的编辑模式，用户在编辑过程中可以直接看到文章的排版效果，无需担心格式问题。支持多种主题：Typora提供了多种主题供用户选择，用户可以根据自己的喜好选择合适的主题，使写作过程更加愉悦。图片插入。
Atlassian Intelligence工具集解析：从自然语言到JQL处理，从虚拟代理到AI摘要、编辑器中的生成式AI等，全方位提升团队协作效率
最新发布
weixin_49715102的博客
07-21 757
通过人机协作，用户可以卸下繁琐、重复的任务，专注于自己的实际技能，并执行更有影响力的工作。编辑器中的生成式AI通过重组、改写内容或提示您的额外问题来阐明您的内容，从而提示审查并简化您的问题。Rovo还理解搜索不是一个孤立的操作，它允许用户在Confluence中搜索资产的同时，查看相关的Jira工单或来自其他工具的信息。借助AI驱动的图表洞察，团队可以查看Atlassian Analytics仪表板，只需单击一个按钮，即可收到快速摘要、趋势评论，以及使数据更具可操作性的建议。这也不是他们的问题。
【乐吾乐2D可视化组态编辑器】快捷键
le5le_iot的博客
07-18 776
乐吾乐2D可视化组态编辑器快捷键
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 238
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Kubernetes 1.6.0 集群搭建全攻略
"这篇文档是关于如何搭建Kubernetes 1.6.0集群的详细步骤，包括了所需软件版本如Docker 1.12.6、Etcd 3.1.5和Flannel 0.7vxlan网络。文中强调了使用TLS认证通信以及RBAC（Role-Based Access Control）授权，并提到了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值