740 lines
19 KiB
C++
740 lines
19 KiB
C++
#help_index "DolDoc"
|
|
|
|
I64 PrsDocFlagSingle(CLex *lx,I64 *_de_flags,U32 *_type,Bool turn_on)
|
|
{
|
|
I64 result=-1;
|
|
CHashGeneric *temph;
|
|
if (lx->token==TK_IDENT && (temph=HashFind(lx->cur_str,doldoc.hash,DHT_DOC_FLAG))) {
|
|
result=temph->user_data0;
|
|
if (result<64) {
|
|
BEqu(_de_flags,result,turn_on);
|
|
switch (result) {
|
|
case DOCEf_SELECTED:
|
|
case DOCEf_UNDERLINE:
|
|
case DOCEf_INVERT:
|
|
case DOCEf_BLINK:
|
|
BEqu(_type,result,turn_on);
|
|
break;
|
|
}
|
|
}
|
|
Lex(lx); //skip flag
|
|
}
|
|
return result;
|
|
}
|
|
|
|
I64 PrsDocFlags(CLex *lx,I64 *_de_flags,U32 *_type)
|
|
{
|
|
I64 result=-1;
|
|
Bool turn_on;
|
|
while (TRUE) {
|
|
if (lx->token=='+')
|
|
turn_on=TRUE;
|
|
else if (lx->token=='-')
|
|
turn_on=FALSE;
|
|
else
|
|
break;
|
|
Lex(lx);
|
|
result=PrsDocFlagSingle(lx,_de_flags,_type,turn_on);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
I64 DocBinPtrRst(CDoc *doc,CDocEntry *doc_e)
|
|
{
|
|
U8 *st,*st2;
|
|
CDoc *doc2;
|
|
CDocBin *tempb,*tempb2;
|
|
I64 i,bin_num=0;
|
|
if (doc_e->de_flags&DOCEF_HAS_BIN && doc_e->bin_ptr_link && StrLen(doc_e->bin_ptr_link)) {
|
|
bin_num=doc_e->bin_num;
|
|
st=StrNew(doc_e->bin_ptr_link);
|
|
st2=StrNew(st);
|
|
StrLastRem(st,",",st2);
|
|
i=Str2I64(st2);
|
|
if (i>0||*st2) {
|
|
doc2=DocRead(st);
|
|
if (i>0 && (tempb2=DocBinFindNum(doc2,i)) ||
|
|
i==0 && (tempb2=DocBinFindTag(doc2,st2))) {
|
|
i=1;
|
|
if (bin_num>0) {
|
|
if (tempb=DocBinFindNum(doc,bin_num)) {
|
|
i=tempb->use_cnt;
|
|
DocBinDel(doc,tempb);
|
|
}
|
|
} else
|
|
bin_num=doc->cur_bin_num++;
|
|
tempb=MAllocIdentical(tempb2,doc->mem_task);
|
|
tempb->use_cnt=i;
|
|
tempb->data=MAllocIdentical(tempb2->data,doc->mem_task);
|
|
tempb->num=bin_num;
|
|
doc_e->bin_data=tempb;
|
|
if (doc_e->de_flags&DOCEF_TAG && doc_e->tag && *doc_e->tag)
|
|
tempb->tag=StrNew(doc_e->tag,doc->mem_task);
|
|
else
|
|
tempb->tag=NULL;
|
|
QueIns(tempb,doc->bin_root.last);
|
|
} else
|
|
bin_num=0;
|
|
DocDel(doc2);
|
|
} else
|
|
bin_num=0;
|
|
Free(st2);
|
|
Free(st);
|
|
doc_e->bin_num=bin_num;
|
|
}
|
|
return bin_num;
|
|
}
|
|
|
|
U8 *Doc2PlainText(CDoc *doc,CDocEntry *doc_e)
|
|
{//TODO: break strs
|
|
I64 i,j,attr=doc_e->attr,
|
|
t1,f1,de_flags,type;
|
|
U8 *buf,*buf2;
|
|
|
|
if (doc_e->type_u8==DOCT_FOREGROUND && doc->flags&DOCF_COLOR_NAMES && 0<=attr<NUM_COLORS) {
|
|
buf=StrNew(DefineSub(attr,"ST_COLORS"));
|
|
attr=DOC_DFT;
|
|
} else
|
|
buf=StrNew(DefineSub(doc_e->type_u8,"ST_DOC_CMDS"));
|
|
if (doc_e->type_u8!=DOCT_ERROR) {
|
|
f1=doldoc.dft_de_flags[doc_e->type_u8];
|
|
t1=doc_e->type_u8|doldoc.dft_type_flags[doc_e->type_u8];
|
|
|
|
de_flags=doc_e->de_flags&~(DOCG_BL_IV_UL|DOCEF_SELECTED|DOCEF_HIGHLIGHT|DOCEF_WORD_WRAP|DOCEF_SKIP|DOCEF_FILTER_SKIP);
|
|
for (i=0;i<DOCEf_NUM_FLAGS;i++)
|
|
if (Bt(&f1,i)!=Bt(&de_flags,i)) {
|
|
if (Bt(&de_flags,i)) {
|
|
if (!(1<<i&DOCEG1_HAS_ARG)) {
|
|
buf2=MStrPrint("%s+%Z",buf,i,"ST_DOC_FLAGS");
|
|
Free(buf); buf=buf2;
|
|
}
|
|
} else {
|
|
buf2=MStrPrint("%s-%Z",buf,i,"ST_DOC_FLAGS");
|
|
Free(buf); buf=buf2;
|
|
}
|
|
}
|
|
type=doc_e->type&~DOCET_SELECTED;
|
|
for (i=DOCEt_BLINK;i<=DOCEt_UNDERLINE;i++)
|
|
if (Bt(&t1,i)!=Bt(&type,i)) {
|
|
if (Bt(&type,i))
|
|
buf2=MStrPrint("%s+%Z",buf,i,"ST_DOC_FLAGS");
|
|
else
|
|
buf2=MStrPrint("%s-%Z",buf,i,"ST_DOC_FLAGS");
|
|
Free(buf); buf=buf2;
|
|
}
|
|
buf2=MStrPrint("%s,",buf);
|
|
Free(buf); buf=buf2;
|
|
nobound_switch (doc_e->type_u8) {
|
|
sub_switch_start:
|
|
case DOCT_DATA:
|
|
buf2=MStrPrint("%s%d,",buf,doc_e->len);
|
|
break;
|
|
case DOCT_HEX_ED:
|
|
buf2=MStrPrint("%s%d,",buf,doc_e->len);
|
|
Free(buf); buf=buf2;
|
|
buf2=MStrPrint("%s%d,",buf,doc_e->hex_ed_width);
|
|
break;
|
|
sub_switch_end:
|
|
Free(buf); buf=buf2;
|
|
break;
|
|
|
|
case DOCT_FOREGROUND:
|
|
case DOCT_BACKGROUND:
|
|
case DOCT_DFT_FOREGROUND:
|
|
case DOCT_DFT_BACKGROUND:
|
|
if (doc->flags&DOCF_COLOR_NAMES && 0<=attr<NUM_COLORS) {
|
|
buf2=MStrPrint("%s%Z,",buf,doc_e->attr,"ST_COLORS");
|
|
Free(buf); buf=buf2;
|
|
break;
|
|
}
|
|
case DOCT_PAGE_LEN:
|
|
case DOCT_LEFT_MARGIN:
|
|
case DOCT_RIGHT_MARGIN:
|
|
case DOCT_HEADER:
|
|
case DOCT_FOOTER:
|
|
case DOCT_INDENT:
|
|
case DOCT_WORD_WRAP:
|
|
case DOCT_HIGHLIGHT:
|
|
case DOCT_UNDERLINE:
|
|
case DOCT_INVERT:
|
|
case DOCT_BLINK:
|
|
case DOCT_SHIFTED_X:
|
|
case DOCT_SHIFTED_Y:
|
|
if (attr!=DOC_DFT) {
|
|
buf2=MStrPrint("%s%d,",buf,doc_e->attr);
|
|
Free(buf); buf=buf2;
|
|
}
|
|
case DOCT_NUM_TYPES-1: //nobound_switch
|
|
break;
|
|
}
|
|
de_flags=doc_e->de_flags & DOCEG1_HAS_ARG;
|
|
while (de_flags) {
|
|
j=Bsf(de_flags);
|
|
Btr(&de_flags,j);
|
|
nobound_switch (j) {
|
|
case DOCEf_TAG:
|
|
if (doc_e->type_u8==DOCT_DATA || doc_e->type_u8==DOCT_MACRO &&
|
|
(doc_e->de_flags&DOCEF_LEFT_MACRO && !StrCmp(doc_e->tag,doc_e->left_macro) ||
|
|
doc_e->de_flags&DOCEF_RIGHT_MACRO && !StrCmp(doc_e->tag,doc_e->right_macro)) ||
|
|
doc_e->de_flags&DOCEF_LST && !StrCmp(doc_e->tag,"[]") && doc_e->de_flags&DOCEF_DEFINE) {
|
|
buf2=buf;
|
|
buf=NULL;
|
|
} else {
|
|
if (doc_e->type_u8==DOCT_CHECK_BOX) {
|
|
if (StrLen(doc_e->tag)>=4)
|
|
buf2=doc_e->tag+4;
|
|
else
|
|
buf2="";
|
|
} else if (doc_e->de_flags & DOCEF_TREE) {
|
|
if (StrLen(doc_e->tag)>=3)
|
|
buf2=doc_e->tag+3;
|
|
else
|
|
buf2="";
|
|
} else
|
|
buf2=doc_e->tag;
|
|
if (Bt(&doldoc.dft_de_flags[doc_e->type_u8],DOCEf_TAG))
|
|
buf2=MStrPrint("%s\"%$$Q\",",buf,buf2);
|
|
else
|
|
buf2=MStrPrint("%sT=\"%$$Q\",",buf,buf2);
|
|
}
|
|
break;
|
|
case DOCEf_AUX_STR:
|
|
buf2=MStrPrint("%sA=\"%$$Q\",",buf,doc_e->aux_str);
|
|
break;
|
|
case DOCEf_DEFINE:
|
|
buf2=MStrPrint("%sD=\"%$$Q\",",buf,doc_e->define_str);
|
|
break;
|
|
case DOCEf_HTML_LINK:
|
|
buf2=MStrPrint("%sHTML=\"%$$Q\",",buf,doc_e->html_link);
|
|
break;
|
|
case DOCEf_LEFT_EXP:
|
|
buf2=MStrPrint("%sLE=%d,",buf,doc_e->left_exp);
|
|
break;
|
|
case DOCEf_LEFT_MACRO:
|
|
buf2=MStrPrint("%sLM=\"%$$Q\",",buf,doc_e->left_macro);
|
|
break;
|
|
case DOCEf_RIGHT_EXP:
|
|
buf2=MStrPrint("%sRE=%d,",buf,doc_e->right_exp);
|
|
break;
|
|
case DOCEf_RIGHT_MACRO:
|
|
buf2=MStrPrint("%sRM=\"%$$Q\",",buf,doc_e->right_macro);
|
|
break;
|
|
case DOCEf_HAS_BIN:
|
|
buf2=MStrPrint("%sBI=%d,",buf,doc_e->bin_num);
|
|
break;
|
|
case DOCEf_BIN_PTR_LINK:
|
|
buf2=MStrPrint("%sBP=\"%$$Q\",",buf,doc_e->bin_ptr_link);
|
|
break;
|
|
case DOCEf_RAW_TYPE:
|
|
if (doc_e->type_u8==DOCT_CHECK_BOX&&doc_e->raw_type!=RT_I8 ||
|
|
doc_e->type_u8!=DOCT_CHECK_BOX&&doc_e->raw_type!=RT_I64)
|
|
buf2=MStrPrint("%sRT=%Z,",buf,doc_e->raw_type,"ST_RAW_TYPES");
|
|
break;
|
|
case DOCEf_SHIFTED_X:
|
|
j=doc_e->type.u16[1]&0x1F;
|
|
if (j&0x10) j|=0xFFFFFFF0;
|
|
buf2=MStrPrint("%sSX=%d,",buf,j);
|
|
break;
|
|
case DOCEf_SHIFTED_Y:
|
|
j=doc_e->type>>21 &0x1F;
|
|
if (j&0x10) j|=0xFFFFFFF0;
|
|
buf2=MStrPrint("%sSY=%d,",buf,j);
|
|
break;
|
|
case DOCEf_SCROLLING_X:
|
|
buf2=MStrPrint("%sSCX=%d,",buf,doc_e->scroll_len);
|
|
break;
|
|
case DOCEf_USER_DATA:
|
|
buf2=MStrPrint("%sU=0x%X,",buf,doc_e->user_data);
|
|
break;
|
|
case DOCEf_NUM_FLAGS-1: //nobound_switch
|
|
break;
|
|
}
|
|
Free(buf); buf=buf2;
|
|
}
|
|
buf[StrLen(buf)-1]=0; //Kill last comma
|
|
}
|
|
buf2=StrNew(buf,doc->mem_task); //exact allocation
|
|
Free(buf);
|
|
return buf2;
|
|
}
|
|
|
|
CDocEntry *PrsDollarCmd(CDoc *doc,U8 *st)
|
|
{//Uses $LK-UL,"Lex",A="MN:Lex"$() to parse a string and make Doc entries.
|
|
I64 i,j,de_flags,processed_flags,attr=DOC_DFT;
|
|
U8 *ptr,*st2;
|
|
CDocEntry *doc_e=NULL;
|
|
CHashGeneric *temph;
|
|
CLex *lx=LexNew(st,LF_DONT_FREE_BUF);
|
|
CHashTable *old_hash_table_lst=lx->htc.hash_table_lst;
|
|
try {
|
|
lx->htc.hash_table_lst=NULL;
|
|
if (Lex(lx)==TK_IDENT) {
|
|
if (temph=HashFind(lx->cur_str,doldoc.hash,DHT_DOC_CMD|DHT_COLOR)) {
|
|
if (temph->type&DHT_DOC_CMD)
|
|
i=temph->user_data0;
|
|
else {//DHT_COLOR
|
|
i=DOCT_FOREGROUND;
|
|
attr=temph->user_data0;
|
|
}
|
|
} else
|
|
goto pd_err;
|
|
Lex(lx); //skip cmd code
|
|
doc_e=CAlloc(sizeof(CDocEntry),doc->mem_task);
|
|
doc_e->type=i;
|
|
doc_e->de_flags=doldoc.dft_de_flags[i];
|
|
doc_e->type|=doldoc.dft_type_flags[i];
|
|
doc_e->raw_type=RT_I64;
|
|
j=PrsDocFlags(lx,&doc_e->de_flags,&doc_e->type);
|
|
lx->htc.hash_table_lst=old_hash_table_lst;
|
|
nobound_switch (i) {
|
|
case DOCT_DATA:
|
|
while (lx->token==',')
|
|
Lex(lx);
|
|
if (lx->token)
|
|
doc_e->len=LexExpressionI64(lx);
|
|
else
|
|
goto pd_err;
|
|
break;
|
|
case DOCT_CHECK_BOX:
|
|
doc_e->raw_type=RT_I8;
|
|
break;
|
|
case DOCT_HEX_ED:
|
|
while (lx->token==',')
|
|
Lex(lx);
|
|
if (lx->token)
|
|
doc_e->len=LexExpressionI64(lx);
|
|
else
|
|
goto pd_err;
|
|
while (lx->token==',')
|
|
Lex(lx);
|
|
if (lx->token)
|
|
doc_e->hex_ed_width=LexExpressionI64(lx);
|
|
else
|
|
goto pd_err;
|
|
break;
|
|
case DOCT_PAGE_LEN:
|
|
case DOCT_LEFT_MARGIN:
|
|
case DOCT_RIGHT_MARGIN:
|
|
case DOCT_HEADER:
|
|
case DOCT_FOOTER:
|
|
case DOCT_INDENT:
|
|
case DOCT_FOREGROUND:
|
|
case DOCT_BACKGROUND:
|
|
case DOCT_DFT_FOREGROUND:
|
|
case DOCT_DFT_BACKGROUND:
|
|
case DOCT_WORD_WRAP:
|
|
case DOCT_HIGHLIGHT:
|
|
case DOCT_UNDERLINE:
|
|
case DOCT_INVERT:
|
|
case DOCT_BLINK:
|
|
case DOCT_SHIFTED_X:
|
|
case DOCT_SHIFTED_Y:
|
|
while (lx->token==',')
|
|
Lex(lx);
|
|
if (lx->token)
|
|
doc_e->attr=LexExpressionI64(lx);
|
|
else
|
|
doc_e->attr=attr;
|
|
break;
|
|
#assert DOCT_ERROR==DOCT_NUM_TYPES-1
|
|
case DOCT_ERROR:
|
|
goto pd_err;
|
|
}
|
|
|
|
processed_flags=0;
|
|
while (TRUE) {
|
|
lx->htc.hash_table_lst=NULL;
|
|
while (lx->token==',')
|
|
Lex(lx);
|
|
lx->htc.hash_table_lst=old_hash_table_lst;
|
|
j=PrsDocFlagSingle(lx,&doc_e->de_flags,&doc_e->type,TRUE);
|
|
if (!(de_flags=~processed_flags & doc_e->de_flags & DOCEG1_HAS_ARG))
|
|
break;
|
|
if (lx->token=='=')
|
|
Lex(lx);
|
|
else
|
|
j=Bsf(de_flags);
|
|
if (j<0 || Bts(&processed_flags,j))
|
|
goto pd_err;
|
|
nobound_switch (j) {//TODO: Might check for expression errors
|
|
case DOCEf_TAG:
|
|
if (!doc_e->tag) {
|
|
//If a $$MA,LM=""$$, Tag is filled when the LM is processed.
|
|
//if doc_e->df_flags&DOCEF_LST, Tag is filled when the Define is processed.
|
|
//(The dft_flag1.tag calls this after.)
|
|
if (lx->token==TK_STR) {
|
|
st2=LexExtStr(lx);
|
|
if (i==DOCT_CHECK_BOX) {
|
|
st=MStrPrint("[X] %s",st2);
|
|
Free(st2);
|
|
doc_e->min_col=1;
|
|
} else if (doc_e->de_flags & DOCEF_LST) {
|
|
if (*st2!='[') {
|
|
st=MStrPrint("[%s]",st2);
|
|
Free(st2);
|
|
} else
|
|
st=st2;
|
|
doc_e->min_col=1;
|
|
} else if (doc_e->de_flags & DOCEF_TREE) {
|
|
st=MStrPrint("+] %s",st2);
|
|
Free(st2);
|
|
doc_e->min_col=1;
|
|
} else
|
|
st=st2;
|
|
doc_e->tag=StrNew(st,doc->mem_task);
|
|
Free(st);
|
|
} else
|
|
goto pd_err;
|
|
}
|
|
break;
|
|
case DOCEf_AUX_STR:
|
|
if (lx->token==TK_STR) {
|
|
st2=LexExtStr(lx);
|
|
doc_e->aux_str=StrNew(st2,doc->mem_task);
|
|
Free(st2);
|
|
//$AN,"Anchor",A="DataTagWidth"$
|
|
if (i==DOCT_DATA) {
|
|
if (ptr=StrMatch(":",doc_e->aux_str))
|
|
doc_e->min_col=ptr-doc_e->aux_str+1;
|
|
doc_e->tag=MAlloc(doc_e->len+doc_e->min_col+2,doc->mem_task); //+2 because "_\0"
|
|
}
|
|
} else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_DEFINE:
|
|
if (lx->token==TK_STR) {
|
|
st2=LexExtStr(lx);
|
|
doc_e->define_str=StrNew(st2,doc->mem_task);
|
|
Free(st2);
|
|
if (doc_e->de_flags&DOCEF_LST && !doc_e->tag)
|
|
doc_e->tag=StrNew("[]",doc->mem_task);
|
|
} else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_HTML_LINK:
|
|
if (lx->token==TK_STR) {
|
|
st2=LexExtStr(lx);
|
|
doc_e->html_link=StrNew(st2,doc->mem_task);
|
|
Free(st2);
|
|
} else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_LEFT_EXP:
|
|
if (lx->token)
|
|
doc_e->left_exp=LexExpression(lx);
|
|
else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_LEFT_MACRO:
|
|
if (lx->token==TK_STR) {
|
|
st2=LexExtStr(lx);
|
|
doc_e->left_macro=StrNew(st2,doc->mem_task);
|
|
Free(st2);
|
|
if (i==DOCT_MACRO && !doc_e->tag)
|
|
doc_e->tag=StrNew(doc_e->left_macro,doc->mem_task);
|
|
} else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_RIGHT_EXP:
|
|
if (lx->token)
|
|
doc_e->right_exp=LexExpression(lx);
|
|
else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_RIGHT_MACRO:
|
|
if (lx->token==TK_STR) {
|
|
st2=LexExtStr(lx);
|
|
doc_e->right_macro=StrNew(st2,doc->mem_task);
|
|
Free(st2);
|
|
if (i==DOCT_MACRO && !doc_e->tag)
|
|
doc_e->tag=StrNew(doc_e->right_macro,doc->mem_task);
|
|
} else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_HAS_BIN:
|
|
if (lx->token)
|
|
doc_e->bin_num=LexExpressionI64(lx);
|
|
else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_BIN_PTR_LINK:
|
|
if (lx->token==TK_STR) {
|
|
st2=LexExtStr(lx);
|
|
doc_e->bin_ptr_link=StrNew(st2,doc->mem_task);
|
|
Free(st2);
|
|
if (!DocBinPtrRst(doc,doc_e))
|
|
doc_e->type=DOCT_ERROR;
|
|
} else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_RAW_TYPE:
|
|
if (lx->token==TK_IDENT) {
|
|
j=DefineMatch(lx->cur_str,"ST_RAW_TYPES");
|
|
if (j<0)
|
|
goto pd_err;
|
|
doc_e->raw_type=j;
|
|
Lex(lx);
|
|
} else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_SHIFTED_X:
|
|
if (lx->token)
|
|
doc_e->type|=(LexExpressionI64(lx) & 0x1F)<<16;
|
|
else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_SHIFTED_Y:
|
|
if (lx->token)
|
|
doc_e->type|=(LexExpressionI64(lx) & 0x1F)<<21;
|
|
else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_SCROLLING_X:
|
|
if (lx->token)
|
|
doc_e->scroll_len=LexExpressionI64(lx);
|
|
else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_USER_DATA:
|
|
if (lx->token)
|
|
doc_e->user_data=LexExpression(lx);
|
|
else
|
|
goto pd_err;
|
|
break;
|
|
case DOCEf_NUM_FLAGS-1: //nobound_switch
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
pd_err:
|
|
if (!doc_e)
|
|
doc_e=CAlloc(sizeof(CDocEntry),doc->mem_task);
|
|
doc_e->type=DOCT_ERROR;
|
|
doc_e->de_flags=0;
|
|
}
|
|
if (doc_e->de_flags & DOCEF_LST && !(doc_e->de_flags & DOCEF_DATA_IS_PTR)) {
|
|
DocDataScan(doc,doc_e);
|
|
DocDataFmt(doc,doc_e);
|
|
}
|
|
LexDel(lx);
|
|
} catch {
|
|
Fs->catch_except=TRUE;
|
|
if (!doc_e)
|
|
doc_e=CAlloc(sizeof(CDocEntry),doc->mem_task);
|
|
doc_e->type=DOCT_ERROR;
|
|
doc_e->de_flags=0;
|
|
}
|
|
return doc_e;
|
|
}
|
|
|
|
public U0 DocInsEntry(CDoc *doc,CDocEntry *doc_e)
|
|
{//Insert entry into doc, updating its vals.
|
|
U8 *dst;
|
|
Bool unlock=DocLock(doc);
|
|
CDocEntry *doc_ce=doc->cur_entry,*doc_ne;
|
|
|
|
doc_e->x=doc_ce->x;
|
|
doc_e->y=doc_ce->y;
|
|
doc_e->page_line_num=doc_ce->page_line_num;
|
|
MemCpy(&doc_e->settings,&doc_ce->settings,sizeof(CDocSettings));
|
|
if (doc->cur_data_col>0 &&
|
|
doc_ce->type_u8==DOCT_TEXT &&
|
|
!(doc_ce->de_flags&(DOCEF_TAG_CB|DOCEF_DEFINE|
|
|
DOCEF_HTML_LINK|DOCEF_BIN_PTR_LINK)) &&
|
|
doc->cur_data_col<doc_ce->max_col) {
|
|
dst=doc_ce->tag+doc->cur_data_col;
|
|
doc_ne=DocEntryNew(doc,doc_ce,StrNew(dst,doc->mem_task));
|
|
*dst=0;
|
|
doc_ne->type=DOCT_TEXT|doc_ce->type&0xFFFFFF00;
|
|
doc_ce->max_col=doc->cur_data_col;
|
|
QueIns(doc_ne,doc_ce);
|
|
doc->cur_data_col=0;
|
|
doc_ce=doc_ne;
|
|
}
|
|
if (doc_ce->type_u8==DOCT_TEXT && doc->cur_data_col>=doc_ce->max_col) {
|
|
QueIns(doc_e,doc_ce);
|
|
doc->cur_entry=doc_e->next;
|
|
} else {
|
|
QueIns(doc_e,doc_ce->last);
|
|
doc->cur_entry=doc_ce;
|
|
}
|
|
doc->cur_data_col=doc->cur_entry->min_col;
|
|
DocRemSoftNewLines(doc,doc->cur_entry);
|
|
if (unlock)
|
|
DocUnlock(doc);
|
|
}
|
|
|
|
#help_index "DolDoc/Output"
|
|
CDocEntry *DocPutS(CDoc *doc,U8 *st)
|
|
{//Don't use this. Use $LK-UL,"DocPrint",A="MN:DocPrint"$().
|
|
//Does not handle partial Doc entries
|
|
//Returns last newly created dollar-sign CDocEntry.
|
|
U8 *ptr=st,*ptr2,*st2,*ptr3,*ptr4,*src,
|
|
*char_bitmap;
|
|
Bool unlock;
|
|
I64 ch,j;
|
|
CDocEntry *doc_e=NULL,*result=NULL,*doc_ce;
|
|
if (!st || !doc && !(doc=DocPut) || doc->doc_signature!=DOC_SIGNATURE_VAL)
|
|
return NULL;
|
|
unlock=DocLock(doc);
|
|
if (doc->flags & DOCF_PLAIN_TEXT_WITH_TABS)
|
|
char_bitmap=chars_bitmap_zero_cr_nl_cursor;
|
|
else if (doc->flags & DOCF_PLAIN_TEXT)
|
|
char_bitmap=chars_bitmap_zero_tab_ff_cr_nl_cursor;
|
|
else
|
|
char_bitmap=chars_bitmap_zero_tab_ff_cr_nl_cursor_dollar;
|
|
doc_ce=doc->cur_entry;
|
|
while (*ptr) {
|
|
ptr2=ptr;
|
|
do ch=*ptr++;
|
|
while (!Bt(char_bitmap,ch) || ch==CH_CURSOR && doc->flags&DOCF_NO_CURSOR);
|
|
ptr--;
|
|
if (!ch) {
|
|
if (j=ptr-ptr2) {
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_TEXT | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_TEXT];
|
|
if (doc->flags & DOCF_NO_CURSOR) {
|
|
src=MAlloc(j+1);
|
|
MemCpy(src,ptr2,j+1);
|
|
StrUtil(src,SUF_REM_CTRL_CHARS);
|
|
j=StrLen(src);
|
|
} else
|
|
src=ptr2;
|
|
doc_e->tag=MAlloc(j+1,doc->mem_task);
|
|
MemCpy(doc_e->tag,src,j+1);
|
|
doc_e->max_col=j;
|
|
DocInsEntry(doc,doc_e);
|
|
if (doc->flags & DOCF_NO_CURSOR)
|
|
Free(src);
|
|
}
|
|
} else {
|
|
if (j=ptr-ptr2) {
|
|
*ptr=0;
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_TEXT | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_TEXT];
|
|
if (doc->flags & DOCF_NO_CURSOR) {
|
|
src=MAlloc(j+1);
|
|
MemCpy(src,ptr2,j+1);
|
|
ptr3=src;
|
|
ptr4=src;
|
|
while (*ptr3)
|
|
if (*ptr3!=CH_CURSOR)
|
|
*ptr4++=*ptr3++;
|
|
else
|
|
ptr3++;
|
|
*ptr4=0;
|
|
j=ptr4-src;
|
|
} else
|
|
src=ptr2;
|
|
doc_e->tag=MAlloc(j+1,doc->mem_task);
|
|
MemCpy(doc_e->tag,src,j+1);
|
|
doc_e->max_col=j;
|
|
DocInsEntry(doc,doc_e);
|
|
if (doc->flags & DOCF_NO_CURSOR)
|
|
Free(src);
|
|
*ptr=ch;
|
|
}
|
|
switch (ch) {
|
|
case CH_CURSOR:
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_CURSOR | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_CURSOR];
|
|
DocInsEntry(doc,doc_e);
|
|
ptr++;
|
|
break;
|
|
case CH_FORM_FEED:
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_PAGE_BREAK | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_PAGE_BREAK];
|
|
DocInsEntry(doc,doc_e);
|
|
ptr++;
|
|
break;
|
|
case '\t':
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_TAB | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_TAB];
|
|
DocInsEntry(doc,doc_e);
|
|
ptr++;
|
|
break;
|
|
case '$$':
|
|
ptr++; //skip first dollar
|
|
ptr2=ptr;
|
|
while (*ptr && *ptr!='$$')
|
|
ptr++;
|
|
if (*ptr) {
|
|
*ptr=0; //zero second dollar
|
|
if (ptr-1==ptr2 && *ptr2==CH_CURSOR) {
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_CURSOR | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_CURSOR];
|
|
DocInsEntry(doc,doc_e);
|
|
ptr2++;
|
|
}
|
|
if (ptr==ptr2) {
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_TEXT | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->max_col=1;
|
|
if (doc->flags & DOCF_DBL_DOLLARS)
|
|
doc_e->tag=StrNew("$$$$",doc->mem_task);
|
|
else
|
|
doc_e->tag=StrNew("$$",doc->mem_task);
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_TEXT];
|
|
DocInsEntry(doc,doc_e);
|
|
} else {
|
|
st2=MAlloc(ptr-ptr2+1);
|
|
ptr3=ptr2;
|
|
ptr4=st2;
|
|
while (ch=*ptr3++) {
|
|
if (ch==CH_CURSOR) {
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_CURSOR | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_CURSOR];
|
|
DocInsEntry(doc,doc_e);
|
|
} else if (ch==CH_FORM_FEED) {
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_PAGE_BREAK | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_PAGE_BREAK];
|
|
DocInsEntry(doc,doc_e);
|
|
} else
|
|
*ptr4++=ch;
|
|
}
|
|
*ptr4=0;
|
|
if (doc_e=PrsDollarCmd(doc,st2)) {
|
|
result=doc_e;
|
|
DocInsEntry(doc,doc_e);
|
|
}
|
|
Free(st2);
|
|
}
|
|
*ptr++='$$';
|
|
}
|
|
break;
|
|
default:
|
|
doc_e=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
|
|
doc_e->type=DOCT_NEW_LINE | doc->settings_root.dft_text_attr<<8;
|
|
doc_e->de_flags=doldoc.dft_de_flags[DOCT_NEW_LINE];
|
|
DocInsEntry(doc,doc_e);
|
|
if (ch=='\r')
|
|
while (*ptr=='\r')
|
|
ptr++;
|
|
if (*ptr=='\n')
|
|
ptr++;
|
|
while (*ptr=='\r')
|
|
ptr++;
|
|
}
|
|
}
|
|
}
|
|
if (unlock)
|
|
DocUnlock(doc);
|
|
return result;
|
|
}
|
|
|
|
public CDocEntry *DocPrint(CDoc *doc,U8 *fmt,...)
|
|
{//You must not print partial doc cmds.
|
|
U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
|
|
CDocEntry *result=DocPutS(doc,buf);
|
|
Free(buf);
|
|
return result;
|
|
}
|