#include <windows.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <stdio.h>
#include <string>
#include <map>
#define pass
#define PASS
#define UP 72
#define DOWN 80
#define LEFT 75
#define RIGHT 77
#define H 29
#define W 114
#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\
</> : pass\n\
<m,M> str1 str2 : move str1 to str2\n\
<d,D> str : move cpp to str\n\
<:> : compile\n\
--------------------\n\
<F1> == <h,H,?>\n\
<F2> == <o,O>\n\
<F3> == <:>\n\
<F4> compile\n\
<F5> run\n\
<F6> run\n\
<F7> run py\n\
Ctrl + a ~ z : ...\n\
"
#ifndef min
#define min(a, b) ({ \
typeof(a) x = (a); \
typeof(b) y = (b); \
x < y ? x : y; \
})
#endif
#ifndef max
#define max(a, b) ({ \
typeof(a) x = (a); \
typeof(b) y = (b); \
x > y ? x : y; \
})
#endif
#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;
}
};
struct Pos {
char ch;
byte_t cl;
};
list <vector <char> > doc;
node <vector <char> >* ty;
iterator tx;
node <vector <char> >* py;
iterator px;
short cnt;
bool lock;
size_t lines;
char name[W];
char path[W];
bool isat[256];
Pos preout[H][W];
Pos thisout[H][W];
std::map <std::string, byte_t> keyword;
void whelp ();
void rpath ();
void rdocu (int argc, char* argv);
void init (int argc, char** argv);
void save ();
void doccopy (const char* from, const char* to);
void cppcopy (const char* to);
void output ();
bool cfn (int ch);
bool cctrl (int ch);
bool ccom (int ch);
void input ();
int main (int argc, char** argv) {
whelp ();
rpath ();
init (argc, argv);
input ();
return 0;
}
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 rdocu (int argc, char* argv) {
int ch;
vector <char> tv;
FILE* fp = fopen (argv, "r");
printf ("Loading...\n");
iterator nt = strlen (argv) - 1;
for (; nt > 0; nt--) {
if (argv[nt - 1] == '\\')
break;
}
if (argc != 1) {
for (iterator it = 0; argv[nt] != '\0'; it++) {
name[it] = argv[nt];
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) {
do {
tv += ' ';
} while (tv.size () % 4 != 0);
} 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);
return;
}
void init (int argc, char** argv) {
printf ("init...\n");
system ("title FastCode 1.6.4");
system ("mode con lines=31 cols=120");
if (argc != 1) {
rdocu (argc, argv[1]);
} else {
printf ("Input name:");
gets (name);
FILE* fp = fopen (name, "r");
if (fp) {
fclose (fp);
rdocu (argc, name);
} else {
vector <char> tv;
doc += tv;
}
}
char ts[W];
sprintf (ts, "title %s", name);
system (ts);
ty = doc.begin () -> next;
tx = 0;
py = doc.begin () -> next;
px = 0;
lock = true;
for (iterator yi = 0; yi < H - 1; yi++) {
for (iterator xi = 0; xi < W - 7; xi++) {
preout[yi][xi].cl = 15;
preout[yi][xi].ch = ' ';
}
}
for (iterator yi = 0; yi < H - 1; yi++) {
for (iterator xi = 0; xi < W - 7; xi++) {
thisout[yi][xi].cl = 15;
thisout[yi][xi].ch = ' ';
}
}
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 cppcopy (const char* to) {
FILE* fp = fopen (name, "r");
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 () {
node <vector <char> >* pt = py;
for (iterator yy = 0; yy < H - 1 && pt != doc.end (); yy++) {
byte_t cl;
iterator xx;
std::string ks;
bool isinc = false;
bool isstr = false;
bool isch = false;
bool isnum = false;
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) {
for (iterator it = 0; it < ks.size(); it++) {
if (pt == ty && xx + px - ks.size() + it == tx)
thisout[yy][xx + px - ks.size() + it].cl = 240;
else
thisout[yy][xx + px - ks.size() + it].cl = keyword[ks];
}
}
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 == '#')) {
cl = 10;
isinc = true;
} else if ((!isinc) && (!isch) && (isstr || putch == '\"')) {
cl = 11;
if (pt -> v[xx + px] == '\"')
isstr = !isstr;
} else if ((!isinc) && (!isstr) && (isch || putch == '\'')) {
cl = 14;
if (pt -> v[xx + px] == '\'')
isch = !isch;
} else if ((!isinc) && (!isstr) && (!isch) && (isnum) && (putch >= '0' && putch <= '9')) {
cl = 11;
} else if (isat[(int)putch] == true) {
cl = 9;
} else {
cl = 15;
}
if (pt == ty && xx + px == tx) {
cl = 240;
}
thisout[yy][xx].cl = cl;
thisout[yy][xx].ch = putch;
}
cl = 15;
if (pt == ty && tx == pt -> v.size ()) {
cl = 240;
}
thisout[yy][xx].cl = cl;
thisout[yy][xx].ch = ' ';
pt = pt -> next;
}
pt = py;
gotoxy (0, 0);
for (iterator yy = 0; yy < H - 1 && pt != doc.end(); yy++) {
color (112);
printf ("%4d ", (int)(lines + yy));
for (iterator xx = 0; xx < W - 6; xx++) {
gotoxy ((short)(xx + 5), (short)yy);
if (thisout[yy][xx].ch != preout[yy][xx].ch || thisout[yy][xx].cl != preout[yy][xx].cl) {
color (thisout[yy][xx].cl);
printf ("%c", thisout[yy][xx].ch);
}
}
color (12);
if (pt -> v.size() > W - 8)
printf (" > ");
else
printf (" ");
printf ("\n");
pt = pt -> next;
}
color (15);
printf ("%114c", ' ');
memcpy (preout, thisout, sizeof (preout));
for (iterator yi = 0; yi < H - 1; yi++) {
for (iterator xi = 0; xi < W - 7; xi++) {
thisout[yi][xi].cl = 15;
thisout[yi][xi].ch = ' ';
}
}
return;
}
bool cfn (int ch) {
if (ch == 0) {
char prt[W + 7];
memset(prt, '\b', sizeof(prt));
prt[W + 6] = '\0';
printf("%s", prt);
ch = getch ();
switch (ch) {
case 59: {
printf (helps);
system ("pause");
break;
}
case 60: {
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 61: {
save ();
char calls[W];
sprintf (calls, "%s -o3 %s", path, name);
printf ("%s\n", calls);
system (calls);
system ("3.exe");
system ("pause");
break;
}
case 62: {
save ();
char calls[W];
sprintf (calls, "%s -o3 %s", path, name);
printf ("%s\n", calls);
system (calls);
system ("pause");
break;
}
case 63: {
system ("start 3.exe");
system ("pause");
break;
}
case 64: {
system ("3.exe");
system ("pause");
break;
}
case 65: {
save ();
system (name);
system ("pause");
break;
}
default:
break;
}
for (iterator yi = 0; yi < H - 1; yi++) {
for (iterator xi = 0; xi < W - 7; xi++) {
preout[yi][xi].cl = 15;
preout[yi][xi].ch = ' ';
}
}
system ("cls");
return true;
}
return false;
}
bool cctrl (int ch) {
if (ch == 1) {
ty -> v.insert (tx, 'a');
tx++;
ty -> v.insert (tx, 'u');
tx++; ty -> v.insert (tx, 't');
tx++;
ty -> v.insert (tx, 'o');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 2) {
ty -> v.insert (tx, 'b');
tx++;
ty -> v.insert (tx, 'o');
tx++;
ty -> v.insert (tx, 'o');
tx++;
ty -> v.insert (tx, 'l');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 4) {
ty -> v.insert (tx, 'd');
tx++;
ty -> v.insert (tx, 'o');
tx++;
ty -> v.insert (tx, 'u');
tx++;
ty -> v.insert (tx, 'b');
tx++;
ty -> v.insert (tx, 'l');
tx++;
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 5) {
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, 'x');
tx++;
ty -> v.insert (tx, 't');
tx++;
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, 'r');
tx++;
ty -> v.insert (tx, 'n');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 6) {
ty -> v.insert (tx, 'f');
tx++;
ty -> v.insert (tx, 'l');
tx++;
ty -> v.insert (tx, 'o');
tx++;
ty -> v.insert (tx, 'a');
tx++;
ty -> v.insert (tx, 't');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 12) {
ty -> v.insert (tx, 'l');
tx++;
ty -> v.insert (tx, 'o');
tx++;
ty -> v.insert (tx, 'n');
tx++;
ty -> v.insert (tx, 'g');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 15) {
ty -> v.insert (tx, 'o');
tx++;
ty -> v.insert (tx, 'p');
tx++;
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, 'r');
tx++;
ty -> v.insert (tx, 'a');
tx++;
ty -> v.insert (tx, 't');
tx++;
ty -> v.insert (tx, 'o');
tx++;
ty -> v.insert (tx, 'r');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 18) {
ty -> v.insert (tx, 'r');
tx++;
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, 'g');
tx++;
ty -> v.insert (tx, 'i');
tx++;
ty -> v.insert (tx, 's');
tx++;
ty -> v.insert (tx, 't');
tx++;
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, 'r');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 19) {
ty -> v.insert (tx, 's');
tx++;
ty -> v.insert (tx, 'i');
tx++;
ty -> v.insert (tx, 'g');
tx++;
ty -> v.insert (tx, 'n');
tx++;
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, 'd');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 20) {
ty -> v.insert (tx, 't');
tx++;
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, 'm');
tx++;
ty -> v.insert (tx, 'p');
tx++;
ty -> v.insert (tx, 'l');
tx++;
ty -> v.insert (tx, 'a');
tx++;
ty -> v.insert (tx, 't');
tx++;
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
} else if (ch == 21) {
ty -> v.insert (tx, 'u');
tx++;
ty -> v.insert (tx, 'n');
tx++;
ty -> v.insert (tx, 's');
tx++;
ty -> v.insert (tx, 'i');
tx++;
ty -> v.insert (tx, 'g');
tx++;
ty -> v.insert (tx, 'n');
tx++;
ty -> v.insert (tx, 'e');
tx++;
ty -> v.insert (tx, 'd');
tx++;
ty -> v.insert (tx, ' ');
tx++;
return true;
}
return false;
}
bool ccom (int ch) {
if (ch == 10) {
char prt[W + 7];
memset(prt, '\b', sizeof(prt));
prt[W + 6] = '\0';
printf("%sFastCode:> ", 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 ();
exit (0);
}
case '!': {
exit (0);
}
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 'd':
case 'D':
case ':': {
save ();
char calls[W];
sprintf (calls, "%s -o3 %s", path, name);
printf("%s\n", calls);
system (calls);
system ("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 'u':
case 'U':
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 'b':
case 'B':
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 'e':
case 'E':
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 'f':
case 'F':
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[W];
char to[W];
getchar ();
gets (from);
gets (to);
doccopy (from, to);
system ("pause");
break;
}
case 'a':
case 'A':
case ';': {
char to[W];
getchar ();
gets (to);
save ();
cppcopy (to);
system ("pause");
break;
}
default:
break;
}
CONSOLE_CURSOR_INFO cursor_info = {1, 0};
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cursor_info);
system ("cls");
for (iterator yi = 0; yi < H - 1; yi++) {
for (iterator xi = 0; xi < W - 7; xi++) {
preout[yi][xi].cl = 15;
preout[yi][xi].ch = ' ';
}
}
return true;
}
return false;
}
void input () {
int ch;
output ();
while (true) {
if (kbhit () != 0) {
while (kbhit () != 0) {
ch = getch ();
if (cfn (ch)) {
pass;
} else if (cctrl (ch)) {
pass;
} else 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) {
do {
ty -> v.insert (tx, ' ');
tx++;
} while (tx % 4 != 0);
} else if (ccom (ch)) {
pass;
} 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 (ch == 27) {
save ();
return;
} 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;
}代码编辑器1.6.4
最新推荐文章于 2024-07-21 11:20:00 发布
369
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
