mirror of https://github.com/minexew/Shrine.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
658 lines
15 KiB
658 lines
15 KiB
#help_index "DolDoc/Misc" |
|
|
|
U0 EdReplaceTroubleOne(CDoc *doc,U8 *st_original,U8 *st_safe,I64 num, |
|
Bool to_safe,Bool sel) |
|
{ |
|
U8 buf[STR_LEN]; |
|
StrPrint(buf,st_safe,num); |
|
if (to_safe) |
|
EdReplace(doc,st_original,buf,sel); |
|
else |
|
EdReplace(doc,buf,st_original,sel); |
|
} |
|
|
|
U0 EdReplaceTroubleAll(CDoc *doc,Bool to_safe,Bool sel) |
|
{ |
|
I64 i=0; |
|
EdReplaceTroubleOne(doc,"#assert" ,"//<@%d@>" ,i++,to_safe,sel); |
|
EdReplaceTroubleOne(doc,"#define" ,"//<@%d@>" ,i++,to_safe,sel); |
|
EdReplaceTroubleOne(doc,"#include","//<@%d@>" ,i++,to_safe,sel); |
|
//#if will match #if,#ifdef,#ifndef,#ifaot and #ifjit |
|
EdReplaceTroubleOne(doc,"#if" ,"//<@%d@>" ,i++,to_safe,sel); |
|
EdReplaceTroubleOne(doc,"#endif" ,"//<@%d@>" ,i++,to_safe,sel); |
|
//Convert #exe to union because we want that indent pattern. |
|
EdReplaceTroubleOne(doc,"#exe" ,"union @%d@",i++,to_safe,sel); |
|
EdReplaceTroubleOne(doc,"'{'" ,"'<@%d@>'" ,i++,to_safe,sel); |
|
EdReplaceTroubleOne(doc,"'}'" ,"'<@%d@>'" ,i++,to_safe,sel); |
|
} |
|
|
|
#define C_INDENT_SPACES 2 |
|
#define ASM_RENUM_SPACING 5 |
|
|
|
#define EF_REINDENT 0 |
|
#define EF_CMP_CHK 1 |
|
#define EF_RENUM_ASM 2 |
|
#define EF_CTRL_SLIDER 3 |
|
#define EF_CH_SC 4 |
|
|
|
I64 PopUpEdFmt() |
|
{ |
|
I64 i; |
|
CDoc *doc=DocNew; |
|
DocPrint(doc,"$$LTBLUE$$$$MU,\"Compile Check\",LE=EF_CMP_CHK$$\n" |
|
"$$MU,\"Reindent HolyC Fun (Beware braces in strings.)\"," |
|
"LE=EF_REINDENT$$\n" |
|
"$$MU,\"Renum Asm Local @@ Labels for Fun\",LE=EF_RENUM_ASM$$\n" |
|
"$$MU,\"Insert Template Code: Ctrl Slider\",LE=EF_CTRL_SLIDER$$\n" |
|
"$$MU,\"Insert ASCII/Scan Code Hex Codes for key pressed\"," |
|
"LE=EF_CH_SC$$\n\n" |
|
"$$MU,\"CANCEL\",LE=DOCM_CANCEL$$\n\n" |
|
"$$GREEN$$<ALT-BACKSPACE>$$FG$$ to undo if not happy\n" |
|
"with the ress.\n"); |
|
i=PopUpMenu(doc); |
|
DocDel(doc); |
|
return i; |
|
} |
|
|
|
class CRILex |
|
{ |
|
CCmpCtrl *cc1,*cc2; |
|
CQueVectU8 *indent; |
|
I64 depth,exp_depth,one_shot; |
|
Bool was_new_line,is_not_cont; |
|
}; |
|
|
|
I64 EdRILex(CRILex *rx) |
|
{ |
|
rx->is_not_cont=FALSE; |
|
I64 i; |
|
CLexFile *tmpf; |
|
do { |
|
Lex(rx->cc1); |
|
Lex(rx->cc2); |
|
i=PrsKeyWord(rx->cc2); |
|
if (rx->cc1->token=='\n' && rx->cc2->token==';' || rx->cc2->token=='{' || |
|
rx->cc2->token=='}' || rx->cc2->token==':' || rx->cc2->token==')' && |
|
!rx->exp_depth || i==KW_ELSE || i==KW_CATCH || i==KW_DO) |
|
rx->is_not_cont=TRUE; |
|
if (rx->was_new_line && (rx->cc1->token!=':' || i==KW_CASE || |
|
i==KW_DFT || i==KW_START || i==KW_END)) { |
|
tmpf=rx->cc2->lex_include_stk; |
|
while (tmpf->next) |
|
tmpf=tmpf->next; |
|
QueVectU8Put(rx->indent,tmpf->cur_entry->y,rx->depth+rx->one_shot); |
|
rx->one_shot=0; |
|
} |
|
if (rx->cc2->token=='\n') |
|
rx->was_new_line=TRUE; |
|
else |
|
rx->was_new_line=FALSE; |
|
} while (rx->cc1->token=='\n'); |
|
return rx->cc1->token; |
|
} |
|
|
|
U0 EdRIExp(CRILex *rx) |
|
{ |
|
if (rx->cc1->token=='(') { |
|
if (!rx->exp_depth++) |
|
rx->depth+=3; |
|
EdRILex(rx); |
|
while (rx->cc1->token && rx->cc1->token!=')') |
|
EdRIExp(rx); |
|
if (!--rx->exp_depth) { |
|
rx->depth-=3; |
|
if (rx->depth<0) rx->depth=0; |
|
} |
|
} else if (rx->cc1->token=='[') { |
|
if (!rx->exp_depth++) |
|
rx->depth+=3; |
|
EdRILex(rx); |
|
while (rx->cc1->token && rx->cc1->token!=']') |
|
EdRIExp(rx); |
|
if (!--rx->exp_depth) { |
|
rx->depth-=3; |
|
if (rx->depth<0) rx->depth=0; |
|
} |
|
} |
|
EdRILex(rx); |
|
} |
|
|
|
U0 EdRIStmt(CRILex *rx,Bool indent) |
|
{ |
|
I64 i; |
|
Bool cont; |
|
if (rx->cc1->token=='{') { |
|
rx->depth++; |
|
EdRILex(rx); |
|
while (rx->cc1->token && rx->cc1->token!='}') |
|
EdRIStmt(rx,FALSE); |
|
if (--rx->depth<0) rx->depth=0; |
|
EdRILex(rx); |
|
} else { |
|
if (indent) rx->depth++; |
|
do { |
|
cont=FALSE; |
|
switch (PrsKeyWord(rx->cc1)) { |
|
case KW_IF: |
|
EdRILex(rx); |
|
EdRIExp(rx); |
|
EdRIStmt(rx,TRUE); |
|
if (PrsKeyWord(rx->cc1)==KW_ELSE) { |
|
EdRILex(rx); |
|
if (PrsKeyWord(rx->cc1)==KW_IF && rx->cc2->token!='\n') |
|
EdRIStmt(rx,FALSE); |
|
else |
|
EdRIStmt(rx,TRUE); |
|
} |
|
break; |
|
case KW_TRY: |
|
EdRILex(rx); |
|
EdRIStmt(rx,TRUE); |
|
if (PrsKeyWord(rx->cc1)==KW_CATCH) { |
|
EdRILex(rx); |
|
EdRIStmt(rx,TRUE); |
|
} |
|
break; |
|
case KW_LOCK: |
|
EdRILex(rx); |
|
EdRIStmt(rx,TRUE); |
|
break; |
|
case KW_FOR: |
|
case KW_WHILE: |
|
EdRILex(rx); |
|
EdRIExp(rx); |
|
EdRIStmt(rx,TRUE); |
|
break; |
|
case KW_ASM: |
|
case KW_CLASS: |
|
case KW_UNION: |
|
if (EdRILex(rx)==TK_IDENT) |
|
EdRILex(rx); |
|
EdRIStmt(rx,TRUE); |
|
break; |
|
case KW_DO: |
|
EdRILex(rx); |
|
EdRIStmt(rx,TRUE); |
|
if (PrsKeyWord(rx->cc1)==KW_WHILE) { |
|
EdRILex(rx); |
|
EdRIExp(rx); |
|
} |
|
if (rx->cc1->token==';') |
|
EdRILex(rx); |
|
break; |
|
case KW_SWITCH: |
|
EdRILex(rx); |
|
EdRIExp(rx); |
|
if (rx->cc1->token=='{') { |
|
rx->depth++; |
|
EdRILex(rx); |
|
i=0; |
|
while (rx->cc1->token && rx->cc1->token!='}') { |
|
switch (PrsKeyWord(rx->cc1)) { |
|
case KW_START: |
|
rx->depth+=i; i=0; |
|
while (EdRILex(rx) && rx->cc1->token!=':'); |
|
EdRILex(rx); |
|
i++; |
|
break; |
|
case KW_END: |
|
rx->depth+=i; i=0; |
|
if (--rx->depth<0) rx->depth=0; |
|
while (EdRILex(rx) && rx->cc1->token!=':'); |
|
EdRILex(rx); |
|
break; |
|
case KW_CASE: |
|
case KW_DFT: |
|
rx->depth+=i; i=0; |
|
while (EdRILex(rx) && rx->cc1->token!=':'); |
|
EdRILex(rx); |
|
break; |
|
default: |
|
if (rx->cc1->token) |
|
EdRIStmt(rx,TRUE); |
|
} |
|
} |
|
if (--rx->depth<0) rx->depth=0; |
|
EdRILex(rx); |
|
} |
|
break; |
|
default: |
|
if (rx->cc1->token==TK_IDENT && rx->cc1->hash_entry && |
|
rx->cc1->hash_entry->type&(HTT_OPCODE|HTT_ASM_KEYWORD)) { |
|
// rx->one_shot=4-rx->depth; |
|
do EdRILex(rx); |
|
while (rx->cc2->token && rx->cc2->token!='\n'); |
|
rx->is_not_cont=TRUE; |
|
} else { |
|
while (rx->cc1->token && rx->cc1->token!=';' && |
|
rx->cc1->token!=':') { |
|
if (rx->cc2->token=='\n' && !rx->is_not_cont) |
|
rx->one_shot=3; |
|
EdRILex(rx); |
|
} |
|
if (rx->cc1->token==':') |
|
cont=TRUE; |
|
EdRILex(rx); |
|
} |
|
} |
|
} while (cont && rx->cc1->token!='}'); |
|
if (indent && --rx->depth<0) |
|
rx->depth=0; |
|
} |
|
} |
|
|
|
CQueVectU8 *EdRICode(CDoc *doc) |
|
{ |
|
CQueVectU8 *res; |
|
CRILex *rx=CAlloc(sizeof(CRILex)); |
|
|
|
rx->cc1=CmpCtrlNew(,CCF_KEEP_NEW_LINES|CCF_DONT_FREE_BUF,doc->filename.name); |
|
Free(rx->cc1->lex_include_stk->full_name); |
|
LexAttachDoc(rx->cc1,rx->cc1->lex_include_stk,doc,, |
|
doc->cur_entry,doc->cur_col); |
|
|
|
rx->cc2=CmpCtrlNew(,CCF_KEEP_NEW_LINES|CCF_DONT_FREE_BUF,doc->filename.name); |
|
Free(rx->cc2->lex_include_stk->full_name); |
|
LexAttachDoc(rx->cc2,rx->cc2->lex_include_stk,doc,, |
|
doc->cur_entry,doc->cur_col); |
|
|
|
rx->indent=QueVectU8New(doc->cur_entry->y); |
|
|
|
Lex(rx->cc1); |
|
EdRIStmt(rx,FALSE); |
|
|
|
CmpCtrlDel(rx->cc1); |
|
CmpCtrlDel(rx->cc2); |
|
res=rx->indent; |
|
Free(rx); |
|
return res; |
|
} |
|
|
|
U0 EdRemFunLeadingSpace(CDoc *doc) |
|
{ |
|
Bool unlock=DocLock(doc), |
|
start_of_line=TRUE; |
|
U8 *ptr; |
|
I64 ch,levels=1; |
|
CDocEntry *doc_e,*doc_e2; |
|
|
|
EdGoToFun(doc,FALSE,FALSE); |
|
doc_e=doc->cur_entry->next; |
|
do { |
|
doc_e2=doc_e->next; |
|
if (doc_e!=doc && doc_e!=doc->cur_entry && |
|
!(doc_e->de_flags&(DOCEG_DONT_EDIT-DOCEF_SCROLLING_X))) |
|
switch (doc_e->type_u8) { |
|
case DOCT_TEXT: |
|
ptr=doc_e->tag; |
|
if (start_of_line) { |
|
while (*ptr==CH_SPACE) |
|
ptr++; |
|
if (*ptr) |
|
start_of_line=FALSE; |
|
ptr=StrNew(ptr,doc->mem_task); |
|
Free(doc_e->tag); |
|
doc_e->tag=ptr; |
|
} |
|
if (!*ptr) |
|
DocEntryDel(doc,doc_e); |
|
else { |
|
while (ch=*ptr++) |
|
if (ch=='{') |
|
levels++; |
|
else if (ch=='}') { |
|
if (!--levels) |
|
break; |
|
} |
|
if (!levels) goto ls_done; |
|
} |
|
break; |
|
case DOCT_TAB: |
|
if (start_of_line) |
|
DocEntryDel(doc,doc_e); |
|
break; |
|
case DOCT_NEW_LINE: |
|
start_of_line=TRUE; |
|
break; |
|
default: |
|
start_of_line=FALSE; |
|
} |
|
doc_e=doc_e2; |
|
} while (doc_e!=doc->cur_entry); |
|
ls_done: |
|
DocRecalc(doc); |
|
DocCenter(doc); |
|
if (unlock) |
|
DocUnlock(doc); |
|
} |
|
|
|
class CRenum |
|
{ |
|
CRenum *next,*last; |
|
U8 label[sizeof(CEdFindText.find_text)]; |
|
}; |
|
|
|
I64 EdRAGetU8(CDoc *doc) |
|
{ |
|
I64 res=-1; |
|
while (doc->cur_entry!=doc && |
|
doc->cur_entry->type&DOCET_SEL && res<0) { |
|
res=EdCurU8(doc); |
|
EdCursorRight(doc); |
|
} |
|
return res; |
|
} |
|
|
|
U0 EdRACollect(CDoc *doc,CRenum *head) |
|
{ |
|
I64 ch,i; |
|
CRenum *tmpr; |
|
U8 buf[sizeof(CEdFindText.find_text)]; |
|
ch=EdRAGetU8(doc); |
|
while (ch>=0) { |
|
if (ch!='@') |
|
ch=EdRAGetU8(doc); |
|
else { |
|
ch=EdRAGetU8(doc); |
|
if (ch=='@') { |
|
ch=EdRAGetU8(doc); |
|
StrCpy(buf,"@@"); |
|
i=2; |
|
while (ch>=0 && i<sizeof(CEdFindText.find_text)) { |
|
if (Bt(char_bmp_alpha_numeric,ch)) |
|
buf[i++]=ch; |
|
else |
|
break; |
|
ch=EdRAGetU8(doc); |
|
} |
|
if (i<sizeof(CEdFindText.find_text)) { |
|
buf[i++]=0; |
|
while (ch>=0 && Bt(char_bmp_white_space,ch)) |
|
ch=EdRAGetU8(doc); |
|
if (ch==':') { |
|
ch=EdRAGetU8(doc); |
|
tmpr=MAlloc(sizeof(CRenum)); |
|
StrCpy(tmpr->label,buf); |
|
QueIns(tmpr,head->last); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
//This is needed because we moved the |
|
//cursor and it didn't recalc. |
|
DocRecalc(doc); |
|
} |
|
|
|
U0 EdRenumAsm(CDoc *doc) |
|
{ |
|
Bool unlock=DocLock(doc); |
|
I64 num=0; |
|
CRenum head,*tmpr,*tmpr1; |
|
U8 buf[sizeof(CEdFindText.find_text)], |
|
buf2[sizeof(CEdFindText.find_text)]; |
|
|
|
QueInit(&head); |
|
EdSelFun(doc,TRUE); |
|
EdRACollect(doc,&head); |
|
|
|
tmpr=head.next; |
|
while (tmpr!=&head) { |
|
tmpr1=tmpr->next; |
|
num+=ASM_RENUM_SPACING; |
|
StrPrint(buf,"@#%02d",num); |
|
EdReplace(doc,tmpr->label,buf,TRUE,TRUE,TRUE); |
|
Free(tmpr); |
|
tmpr=tmpr1; |
|
} |
|
|
|
while (num) { |
|
StrPrint(buf, "@#%02d",num); |
|
StrPrint(buf2,"@@%02d",num); |
|
EdReplace(doc,buf,buf2,TRUE,TRUE,TRUE); |
|
num-=ASM_RENUM_SPACING; |
|
} |
|
EdSelAll(doc,FALSE); |
|
DocRecalc(doc); |
|
DocCenter(doc); |
|
if (unlock) |
|
DocUnlock(doc); |
|
} |
|
|
|
U0 EdCodeTools2(CDoc *doc,I64 tool_action,Bool beep=TRUE) |
|
{ |
|
Bool okay,unlock=DocLock(doc),start_of_line=TRUE; |
|
CDocEntry *doc_e,*doc_ne; |
|
I64 i,start_y,end_y,x,r,goto_line_num; |
|
U8 *b,*st,*st2,*prj_file; |
|
CTask *task=NULL; |
|
CJob *tmpc; |
|
CQueVectU8 *indent; |
|
|
|
DocRecalc(doc); |
|
goto_line_num=doc->cur_entry->y+1; |
|
|
|
DocCaptureUndo(doc,TRUE); |
|
switch (tool_action) { |
|
case EF_CMP_CHK: |
|
okay=FALSE; |
|
if (doc->flags&DOCF_PLAIN_TEXT) |
|
DocFlagsToggle(doc,DOCF_PLAIN_TEXT); |
|
DocWrite(doc); |
|
task=Spawn(&SrvCmdLine,NULL,"Srv",,Fs); |
|
st2=DirCur; |
|
st=MStrPrint("Cd(\"%s\");",st2); |
|
tmpc=TaskExe(task,Fs,st,1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER); |
|
Free(st2); |
|
Free(st); |
|
WinHorz(Fs->win_left,Fs->win_right, task); |
|
WinVert(Fs->win_top, Fs->win_bottom,task); |
|
if (JobResScan(tmpc,&r)) { |
|
st=DirFile(doc->filename.name,,"PRJ.Z"); |
|
prj_file=FileNameAbs(st,FUF_Z_OR_NOT_Z); |
|
Free(st); |
|
if (FileFind(prj_file)) { |
|
st2=DirFile(prj_file), |
|
st=MStrPrint("Cd(\"%s\");",st2); |
|
Free(st2); |
|
tmpc=TaskExe(task,Fs,st,1<<JOBf_WAKE_MASTER| |
|
1<<JOBf_FOCUS_MASTER|1<<JOBf_FREE_ON_COMPLETE); |
|
Free(st); |
|
st=MStrPrint("\"$$WW,1$$\";Cmp(\"%s\",\"SysTmp\",\"SysTmp\");", |
|
prj_file); |
|
tmpc=TaskExe(task,Fs,st,1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER); |
|
Free(st); |
|
if (JobResScan(tmpc,&r)) |
|
if (!r) { |
|
tmpc=TaskExe(task,Fs, |
|
"Load(\"SysTmp\",LDF_JUST_LOAD);", |
|
1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER); |
|
if (JobResScan(tmpc,&r)) |
|
okay=TRUE; |
|
} |
|
tmpc=TaskExe(task,Fs,"Del(\"SysTmp.*\");", |
|
1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER); |
|
JobResScan(tmpc,&r); |
|
} else { |
|
Free(prj_file); |
|
st=DirFile(doc->filename.name,"Load","HC.Z"); |
|
prj_file=FileNameAbs(st,FUF_Z_OR_NOT_Z); |
|
Free(st); |
|
if (FileFind(prj_file)) |
|
st=MStrPrint("\"$$WW,1$$\";ExeFile(\"%s\",CCF_JUST_LOAD);",prj_file); |
|
else |
|
st=MStrPrint("\"$$WW,1$$\";ExeFile(\"%s\",CCF_JUST_LOAD);", |
|
doc->filename.name); |
|
tmpc=TaskExe(task,Fs,st,1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER); |
|
Free(st); |
|
if (JobResScan(tmpc,&r) && r) |
|
okay=TRUE; |
|
} |
|
Free(prj_file); |
|
} |
|
if (!okay) { |
|
PopUpOk("Has Errors"); |
|
while (LBts(&sys_semas[SEMA_FIX],0)) |
|
Yield; |
|
ToFileLine(dbg.fix_file_line,&st,&i); |
|
LBtr(&sys_semas[SEMA_FIX],0); |
|
if (!StrCmp(st,doc->filename.name)) |
|
goto_line_num=i; |
|
Free(st); |
|
} |
|
break; |
|
case EF_REINDENT: |
|
start_y=doc->cur_entry->y; |
|
EdReplaceTroubleAll(doc,TRUE,FALSE); |
|
DocGoToLine(doc,start_y+1); |
|
if (EdGoToFun(doc,FALSE,FALSE)) { |
|
start_y=doc->cur_entry->y; |
|
indent=EdRICode(doc); |
|
DocUnlock(doc); |
|
if (beep) { |
|
Snd(86); Sleep(150); Snd; |
|
Sleep(100); |
|
Snd(86); Sleep(150); Snd; |
|
} |
|
DocLock(doc); |
|
EdRemFunLeadingSpace(doc); |
|
DocGoToLine(doc,start_y+1); |
|
doc_e=doc->cur_entry; |
|
end_y=start_y+indent->total_cnt; |
|
while (start_y<=doc_e->y<end_y) { |
|
if (doc_e!=doc && doc_e!=doc->cur_entry && |
|
!(doc_e->de_flags&(DOCEG_DONT_EDIT-DOCEF_SCROLLING_X))) { |
|
if (doc_e->type_u8==DOCT_NEW_LINE|| |
|
doc_e->type_u8==DOCT_SOFT_NEW_LINE) |
|
start_of_line=TRUE; |
|
else { |
|
if (start_of_line) { |
|
i=QueVectU8Get(indent,doc_e->y)*C_INDENT_SPACES; |
|
x=doc_e->x+1; |
|
while (i>8) { |
|
doc_ne=DocEntryNewBase(doc, |
|
DOCT_TAB|doc->settings_head.dft_text_attr<<8,, |
|
x,doc_e->y,doc_e->page_line_num); |
|
MemCpy(&doc_ne->settings, |
|
&doc_e->settings,sizeof(CDocSettings)); |
|
QueIns(doc_ne,doc_e->last); |
|
i-=8; |
|
x+=8; |
|
} |
|
if (i>0) { |
|
b=MAlloc(i+1,doc->mem_task); |
|
MemSet(b,CH_SPACE,i); |
|
b[i]=0; |
|
doc_ne=DocEntryNewBase(doc, |
|
DOCT_TEXT|doc->settings_head.dft_text_attr<<8,, |
|
x,doc_e->y,doc_e->page_line_num); |
|
doc_ne->tag=b; |
|
doc_ne->max_col=1; |
|
MemCpy(&doc_ne->settings, |
|
&doc_e->settings,sizeof(CDocSettings)); |
|
QueIns(doc_ne,doc_e->last); |
|
} |
|
} |
|
start_of_line=FALSE; |
|
} |
|
} |
|
doc_e=doc_e->next; |
|
} |
|
QueVectU8Del(indent); |
|
} |
|
start_y=doc->cur_entry->y; |
|
EdReplaceTroubleAll(doc,FALSE,FALSE); |
|
DocGoToLine(doc,start_y+1); |
|
break; |
|
case EF_RENUM_ASM: |
|
if (EdGoToFun(doc,FALSE,TRUE)) { |
|
if (EdCurU8(doc)=='{') { |
|
EdCursorRight(doc); |
|
DocRecalc(doc); |
|
} else if (EdCurU8(doc)==':') { |
|
EdCursorRight(doc); |
|
if (EdCurU8(doc)==':') |
|
EdCursorRight(doc); |
|
DocRecalc(doc); |
|
} |
|
DocUnlock(doc); |
|
if (beep) { |
|
Snd(86); Sleep(150); Snd; |
|
Sleep(100); |
|
Snd(86); Sleep(150); Snd; |
|
} |
|
DocLock(doc); |
|
EdRenumAsm(doc); |
|
} |
|
break; |
|
} |
|
|
|
DocRecalc(doc); |
|
DocGoToLine(doc,goto_line_num); |
|
|
|
DocUnlock(doc); |
|
if (!unlock) |
|
DocLock(doc); |
|
if (task) |
|
Kill(task,FALSE); |
|
} |
|
|
|
U0 EdPopUpChSC(I64 *_ch,I64 *_sc) |
|
{ |
|
I64 sc; |
|
"Press A Key\n"; |
|
DocPut->flags|=DOCF_SIZE_MIN; |
|
do GetMsg(_ch,&sc,1<<MSG_KEY_DOWN); |
|
while (sc.u8[0]==SC_SHIFT || sc.u8[0]==SC_CTRL || sc.u8[0]==SC_ALT); |
|
*_sc=sc; |
|
} |
|
|
|
U0 EdChSC(CDoc *doc) |
|
{ |
|
I64 ch,sc; |
|
U8 buf[STR_LEN]; |
|
StrPrint(buf,"EdPopUpChSC(%d,%d);",&ch,&sc); |
|
PopUp(buf,Fs); |
|
if (ch==CH_BACKSPACE) |
|
DocPrint(doc,"CH_BACKSPACE,0x%X",sc); |
|
else if (ch=='\n') |
|
DocPrint(doc,"'\n',0x%X",sc); |
|
else if (CH_CTRLA<=ch<=CH_CTRLZ) |
|
DocPrint(doc,"CH_CTRL%C,0x%X",ch+'@',sc); |
|
else if (ch=='$$') |
|
DocPrint(doc,"'$$$$',0x%X",sc); |
|
else if (ch=='\\') |
|
DocPrint(doc,"'\\\\',0x%X",sc); |
|
else if (ch=='\'') |
|
DocPrint(doc,"'\\\'',0x%X",sc); |
|
else if (ch==CH_ESC) |
|
DocPrint(doc,"CH_ESC,0x%X",sc); |
|
else if (ch==CH_SHIFT_ESC) |
|
DocPrint(doc,"CH_SHIFT_ESC,0x%X",sc); |
|
else if (ch==CH_SPACE) |
|
DocPrint(doc,"CH_SPACE,0x%X",sc); |
|
else if (ch==CH_SHIFT_SPACE) |
|
DocPrint(doc,"CH_SHIFT_SPACE,0x%X",sc); |
|
else if (Bt(char_bmp_displayable,ch)) |
|
DocPrint(doc,"'%c',0x%X",ch,sc); |
|
else |
|
DocPrint(doc,"0x%X,0x%X",ch,sc); |
|
} |
|
|
|
U0 EdCodeTools(CDoc *doc) |
|
{ |
|
I64 tool_action=PopUpEdFmt; |
|
switch (tool_action) { |
|
case EF_CMP_CHK: |
|
case EF_REINDENT: |
|
case EF_RENUM_ASM: |
|
EdCodeTools2(doc,tool_action); |
|
break; |
|
case EF_CTRL_SLIDER: |
|
TemplateCtrlSlider(doc); |
|
break; |
|
case EF_CH_SC: |
|
EdChSC(doc); |
|
break; |
|
} |
|
}
|
|
|