Initial (manual) import

TempleOSCD/Adam/DolDoc/DocBin.HC

@@ -0,0 +1,142 @@
+#help_index "DolDoc/Bin"
+
+CDocBin *DocBinFindNum(CDoc *haystack_doc,I64 needle_num)
+{
+  CDocBin *b=haystack_doc->bin_head.next;
+  while (b!=&haystack_doc->bin_head) {
+    if (b->num==needle_num)
+      return b;
+    b=b->next;
+  }
+  return NULL;
+}
+
+CDocBin *DocBinFindTag(CDoc *haystack_doc,U8 *needle_tag)
+{
+  CDocBin *b;
+  if (needle_tag) {
+    b=haystack_doc->bin_head.next;
+    while (b!=&haystack_doc->bin_head) {
+      if (b->tag && !StrCmp(b->tag,needle_tag))
+	return b;
+      b=b->next;
+    }
+  }
+  return NULL;
+}
+
+U0 DocBinsValidate(CDoc *doc)
+{
+  Bool unlock=DocLock(doc);
+  CDocBin *b,*b1;
+  CDocEntry *doc_e,*doc_e2;
+  I64 renum_num=0;
+  b=doc->bin_head.next;
+  while (b!=&doc->bin_head) {
+    b->use_cnt=0;
+    b->tmp_use_cnt=0;
+    b->renum_num=-1;
+    Free(b->tag);
+    b->tag=NULL;
+    b=b->next;
+  }
+  doc_e=doc->head.next;
+  while (doc_e!=doc) {
+    doc_e2=doc_e->next;
+    if (doc_e->de_flags & DOCEF_HAS_BIN) {
+      if (b=doc_e->bin_data=DocBinFindNum(doc,doc_e->bin_num)) {
+	if (doc_e->de_flags & DOCEF_BIN_PTR_LINK)
+	  b->tmp_use_cnt=I32_MAX;
+	if (!b->use_cnt++)
+	  b->renum_num=++renum_num;
+	doc_e->bin_num=b->renum_num;
+	if (!b->tag && doc_e->de_flags&DOCEF_TAG && doc_e->tag && *doc_e->tag)
+	  b->tag=StrNew(doc_e->tag,doc->mem_task);
+      } else {
+	RawPrint(3000,"Bin Not Found");
+	doc_e->type=doc_e->de_flags=0;
+	doc_e->type_u8=DOCT_ERROR;
+      }
+    }
+    doc_e=doc_e2;
+  }
+
+  b=doc->bin_head.next;
+  doc->cur_bin_num=1;
+  while (b!=&doc->bin_head) {
+    b1=b->next;
+    if (!b->use_cnt) {
+      QueRem(b);
+      Free(b->data);
+      Free(b);
+    } else {
+      b->num=b->renum_num;
+      if (b->num>=doc->cur_bin_num)
+	doc->cur_bin_num=b->num+1;
+    }
+    b=b1;
+  }
+  if (unlock)
+    DocUnlock(doc);
+}
+
+U0 DocBinDel(CDoc *doc,CDocBin *b)
+{
+  if (doc && b && b->use_cnt) {
+    b->use_cnt--;
+    if (!b->use_cnt) {
+      QueRem(b);
+      Free(b->tag);
+      Free(b->data);
+      Free(b);
+    }
+  } else
+    RawPrint(3000,"DocBinDel");
+}
+
+I64 DocBinPtrRst(CDoc *doc,CDocEntry *doc_e)
+{
+  U8 *st,*st2;
+  CDoc *doc2;
+  CDocBin *tmpb,*tmpb2;
+  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  && (tmpb2=DocBinFindNum(doc2,i)) ||
+	    i==0 && (tmpb2=DocBinFindTag(doc2,st2))) {
+	i=1;
+	if (bin_num>0) {
+	  if (tmpb=DocBinFindNum(doc,bin_num)) {
+	    i=tmpb->use_cnt;
+	    DocBinDel(doc,tmpb);
+	  }
+	} else
+	  bin_num=doc->cur_bin_num++;
+	tmpb=MAllocIdent(tmpb2,doc->mem_task);
+	tmpb->use_cnt=i;
+	tmpb->data=MAllocIdent(tmpb2->data,doc->mem_task);
+	tmpb->num=bin_num;
+	doc_e->bin_data=tmpb;
+	if (doc_e->de_flags&DOCEF_TAG && doc_e->tag && *doc_e->tag)
+	  tmpb->tag=StrNew(doc_e->tag,doc->mem_task);
+	else
+	  tmpb->tag=NULL;
+	QueIns(tmpb,doc->bin_head.last);
+      } else
+	bin_num=0;
+      DocDel(doc2);
+    } else
+      bin_num=0;
+    Free(st2);
+    Free(st);
+    doc_e->bin_num=bin_num;
+  }
+  return bin_num;
+}

TempleOSCD/Adam/DolDoc/DocChar.HC

@@ -0,0 +1,652 @@
+#help_index "DolDoc/Editor"
+
+public I64 EdCurU8(CDoc *doc)
+{//Return cur U8. See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
+  Bool unlock=DocLock(doc);
+  CDocEntry *doc_ce=doc->cur_entry;
+  I64 res=-1;
+  if (doc_ce->type_u8==DOCT_TEXT &&
+	doc_ce->min_col<=doc->cur_col<doc_ce->max_col)
+    res=doc_ce->tag[doc->cur_col];
+  else if (doc_ce->type_u8==DOCT_TAB)
+    res='\t';
+  else if (doc_ce->type_u8==DOCT_NEW_LINE ||
+	doc_ce->type_u8==DOCT_SOFT_NEW_LINE)
+    res='\n';
+  if (unlock)
+    DocUnlock(doc);
+  return res;
+}
+
+public U0 EdCursorLeft(CDoc *doc,I64 sc=I64_MIN)
+{//Move cursor left. Might need a call to $LK,"DocRecalc",A="MN:DocRecalc"$().
+//See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
+  U8 *dst;
+  Bool unlock=DocLock(doc);
+  CDocEntry *doc_ce=doc->cur_entry,*original_ce=doc_ce,*doc_ne;
+  I64 cc=doc->cur_col,y=doc_ce->y;
+  if (sc!=I64_MIN) sc=sc.u32[0];
+  if (sc>=0 && sc&SCF_CTRL) {
+    while (doc_ce->last!=doc && (doc_ce->last->y==y ||
+	  doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP)))
+      doc_ce=doc_ce->last;  //TODO: sel? recurse?
+    cc=doc_ce->min_col;
+  } else {
+    if (cc>doc_ce->min_col) {
+      if (IsEditableText(doc_ce) && cc<doc_ce->max_col) {
+	dst=doc_ce->tag+cc;
+	doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+	*dst=0;
+	doc_ce->max_col=cc;
+	QueIns(doc_ne,doc_ce);
+      }
+      cc--;
+      if (IsEditableText(doc_ce) && cc>doc_ce->min_col) {
+	dst=doc_ce->tag+cc;
+	doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+	*dst=0;
+	doc_ce->max_col=cc;
+	QueIns(doc_ne,doc_ce);
+	doc_ce=doc_ne;
+	cc=doc_ce->min_col;
+      }
+      if (sc>=0)
+	BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+    } else {
+      cc=doc_ce->min_col;
+      while (doc_ce->last!=doc &&
+	    (doc_ce->last->type_u8==DOCT_SOFT_NEW_LINE ||
+	    doc_ce->last->type_u8==DOCT_INDENT ||
+	    doc_ce->last->de_flags&(DOCEF_SKIP|DOCEF_FILTER_SKIP))) {
+	doc_ce=doc_ce->last;
+	if (sc>=0)
+	  BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+      }
+      if (doc_ce->last!=doc) {
+	doc_ce=doc_ce->last;
+	if (doc_ce->max_col>doc_ce->min_col) {
+	  cc=doc_ce->max_col-1;
+	  if (IsEditableText(doc_ce) && cc>doc_ce->min_col) {
+	    dst=doc_ce->tag+cc;
+	    doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+	    *dst=0;
+	    doc_ce->max_col=cc;
+	    QueIns(doc_ne,doc_ce);
+	    doc_ce=doc_ne;
+	    cc=doc_ce->min_col;
+	  }
+	} else
+	  cc=doc_ce->max_col;
+	if (sc>=0)
+	  BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+      }
+    }
+  }
+  doc->cur_col=cc;
+  doc->cur_entry=doc_ce;
+  if (doc_ce!=original_ce)
+    DocFormBwd(doc);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 EdCursorRight(CDoc *doc,I64 sc=I64_MIN)
+{//Move cursor right. Might need a call to $LK,"DocRecalc",A="MN:DocRecalc"$().
+//See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
+  Bool unlock=DocLock(doc);
+  U8 *dst;
+  CDocEntry *doc_ce=doc->cur_entry,*original_ce=doc_ce,*doc_ne;
+  I64 cc=doc->cur_col,y=doc_ce->y,old_de_flags,old_color;
+  if (sc!=I64_MIN) sc=sc.u32[0];
+  if (sc>=0 && sc&SCF_CTRL) {
+    while (doc_ce!=doc && doc_ce->next->y==y &&
+	  doc_ce->next->type_u8!=DOCT_SOFT_NEW_LINE && doc_ce->next!=doc &&
+	  (doc_ce->next->type_u8!=DOCT_NEW_LINE || !(doc->flags & DOCF_FORM)) ||
+	  doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP))
+      doc_ce=doc_ce->next;
+    if (doc_ce->max_col>doc_ce->min_col)
+      cc=doc_ce->max_col-1;
+    else
+      cc=doc_ce->min_col;
+  } else {
+    if (cc<doc_ce->max_col) {
+      if (IsEditableText(doc_ce) && cc>doc_ce->min_col) {
+	dst=doc_ce->tag+cc;
+	doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+	*dst=0;
+	doc_ce->max_col=cc;
+	QueIns(doc_ne,doc_ce);
+	doc_ce=doc_ne;
+	cc=doc_ce->min_col;
+      }
+      cc++;
+      old_de_flags=doc_ce->de_flags;
+      old_color=doc_ce->type;
+      if (sc>=0)
+	BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+      if (IsEditableText(doc_ce) && cc<doc_ce->max_col) {
+	dst=doc_ce->tag+cc;
+	doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+	*dst=0;
+	doc_ne->type=DOCT_TEXT | old_color & -0x100;
+	doc_ne->de_flags=old_de_flags|doldoc.dft_de_flags[DOCT_TEXT];
+	doc_ce->max_col=cc;
+	QueIns(doc_ne,doc_ce);
+	doc_ce=doc_ne;
+	cc=doc_ce->min_col;
+      } else if (cc>=doc_ce->max_col) {
+	doc_ce=doc_ce->next;
+	cc=doc_ce->min_col;
+      }
+    } else {
+      if (doc_ce!=doc) {
+	if (cc<=doc_ce->min_col && sc>=0)
+	  BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+	doc_ce=doc_ce->next;
+	while (doc_ce!=doc && doc_ce->de_flags&(DOCEF_SKIP|DOCEF_FILTER_SKIP)) {
+	  if (sc>=0)
+	    BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+	  doc_ce=doc_ce->next;
+	}
+	cc=doc_ce->min_col;
+	if (doc_ce->type_u8==DOCT_SOFT_NEW_LINE) {
+	  if (sc>=0)
+	    BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+	  doc_ce=doc_ce->next;
+	  cc=doc_ce->min_col;
+	}
+      }
+    }
+  }
+  doc->cur_col=cc;
+  doc->cur_entry=doc_ce;
+  if (doc_ce!=original_ce)
+    DocFormFwd(doc);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 EdLineUp(CDoc *doc,I64 sc=I64_MIN)
+{//Move cursor up. Might need a call to $LK,"DocRecalc",A="MN:DocRecalc"$().
+//See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
+  Bool unlock=DocLock(doc);
+  U8 *dst;
+  I64 y,x;
+  CDocEntry *doc_ce=doc->cur_entry,*doc_ne;
+
+  if (sc!=I64_MIN) sc=sc.u32[0];
+  if (doc_ce->type_u8==DOCT_HEX_ED) {
+    doc->cur_col=doc->cur_col-doc_ce->hex_ed_width*3;
+    if (doc->cur_col>=0) {
+      if (unlock)
+	DocUnlock(doc);
+      return;
+    } else
+      doc->cur_col=0;
+  }
+  x=doc->x; y=doc->y;
+  if (IsEditableText(doc_ce)) {
+    if (doc_ce->min_col<doc->cur_col<doc_ce->max_col-1) {
+      dst=doc_ce->tag+doc->cur_col;
+      doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+      *dst=0;
+      doc_ne->x=doc_ce->x+doc->cur_col;
+      doc_ce->max_col=doc->cur_col;
+      QueIns(doc_ne,doc_ce);
+    } else if (doc->cur_col==doc_ce->min_col && doc_ce->last!=doc)
+      doc_ce=doc_ce->last;
+  } else if (doc_ce->last!=doc)
+    doc_ce=doc_ce->last;
+  if (sc>=0)
+    BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+  doc->cur_entry=doc_ce;
+  DocFormBwd(doc);
+  doc_ce=doc->cur_entry;
+  while (doc_ce->last!=doc && (doc_ce->y>=y ||
+	doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP))) {
+    doc_ce=doc_ce->last;
+    if (sc>=0)
+      BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+  }
+  y=doc_ce->y;
+  doc->y=y;
+  while (doc_ce!=doc && (doc_ce->y>=y && doc_ce->x>=x ||
+	doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP))) {
+    if (sc>=0)
+      BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+    doc_ce=doc_ce->last;
+  }
+
+  if (doc_ce==doc || doc_ce->y<y)
+    doc_ce=doc_ce->next;
+  else {
+    if (!IsEditableText(doc_ce)) {
+      if (sc>=0)
+	BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+    } else {
+      if (doc_ce->next->x==x) {
+	doc_ce=doc_ce->next;
+	if (doc->flags & DOCF_FORM)
+	  while (doc_ce->next->x==x &&
+		(!Bt(doldoc.type_flags_form,doc_ce->type_u8) &&
+		!(doc_ce->de_flags&DOCEF_LINK)||
+		doc_ce->de_flags&DOCEF_SKIP_IN_FORM))
+	    doc_ce=doc_ce->next;
+      }
+    }
+  }
+  if (doc_ce->de_flags&DOCEF_TAG) {
+    doc->cur_col=x-doc_ce->x;
+    if (IsEditableText(doc_ce)) {
+      if (doc->cur_col>doc_ce->max_col)
+	doc->cur_col=doc_ce->max_col;
+    } else if (doc->cur_col>=doc_ce->max_col)
+      doc->cur_col=doc_ce->max_col-1;
+    if (doc->cur_col<doc_ce->min_col)
+      doc->cur_col=doc_ce->min_col;
+  } else {
+    if (doc_ce->type_u8==DOCT_HEX_ED) {
+      doc->cur_col=RoundI64((doc_ce->len-1)*3,doc_ce->hex_ed_width*3);
+      if (doc->cur_col<0)
+	doc->cur_col=0;
+    } else
+      doc->cur_col=doc_ce->min_col;
+  }
+  if (IsEditableText(doc_ce) && doc_ce->x<x) {
+    if (doc->cur_col<doc_ce->max_col-1) {
+      dst=doc_ce->tag+doc->cur_col;
+      doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+      *dst=0;
+      if (sc>=0) {
+	if (sc&SCF_SHIFT)
+	  doc_ne->type=doc_ce->type | DOCET_SEL;
+	else
+	  doc_ne->type=doc_ce->type & ~DOCET_SEL;
+      }
+      doc_ne->x=doc_ce->x+doc->cur_col;
+      doc_ce->max_col=doc->cur_col;
+      QueIns(doc_ne,doc_ce);
+      doc_ce=doc_ne;
+      doc->cur_col=doc_ce->min_col;
+    }
+  }
+  doc->cur_entry=doc_ce;
+  DocFormFwd(doc);
+  doc->x=doc->cur_entry->x+doc->cur_col;
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 EdLineDown(CDoc *doc,I64 sc=I64_MIN)
+{//Move cursor down. Might need a call to $LK,"DocRecalc",A="MN:DocRecalc"$().
+//See $LK,"EdRenumAsm",A="MN:EdRenumAsm"$ for an example.
+  Bool unlock=DocLock(doc);
+  U8 *dst;
+  I64 y,x,old_de_flags=0,old_color;
+  CDocEntry *doc_ce=doc->cur_entry,*doc_ne,*doc_ce2;
+  if (sc!=I64_MIN) sc=sc.u32[0];
+  if (doc_ce->type_u8==DOCT_HEX_ED) {
+    doc->cur_col=doc->cur_col+doc_ce->hex_ed_width*3;
+    if (doc->cur_col>=doc_ce->len*3) {
+      doc->cur_entry=doc_ce=doc_ce->next;
+      doc->cur_col=doc_ce->min_col;
+      doc->x=doc_ce->x+doc->cur_col;
+      doc->y=doc_ce->y;
+    }
+    if (unlock)
+      DocUnlock(doc);
+    return;
+  }
+  x=doc->x; y=doc->y;
+  if (IsEditableText(doc_ce)) {
+    if (doc->cur_col>doc_ce->min_col && doc->cur_col<doc_ce->max_col-1) {
+      dst=doc_ce->tag+doc->cur_col;
+      doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+      *dst=0;
+      if (sc>=0) {
+	if (sc&SCF_SHIFT)
+	  doc_ne->type=doc_ce->type | DOCET_SEL;
+	else
+	  doc_ne->type=doc_ce->type & ~DOCET_SEL;
+      }
+      doc_ne->x=doc_ce->x+doc->cur_col;
+      doc_ce->max_col=doc->cur_col;
+      QueIns(doc_ne,doc_ce);
+      doc_ce=doc_ne;
+      doc->cur_col=doc_ce->min_col;
+    }
+  }
+  doc_ce2=doc_ce;
+  while (doc_ce!=doc && (doc_ce->y<=y ||
+	doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP)))
+    doc_ce=doc_ce->next;
+  y=doc_ce->y;
+  doc->y=y;
+  while (doc_ce!=doc && (doc_ce->y<=y && doc_ce->x<=x ||
+	doc_ce->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP))) {
+    old_de_flags=doc_ce->de_flags;
+    old_color=doc_ce->type;
+    doc_ce=doc_ce->next;
+  }
+  if (doc_ce->last!=doc && (doc_ce->x>x && doc_ce->last->y>=y || doc_ce->y>y)) {
+    doc_ce=doc_ce->last;
+    doc->cur_entry=doc_ce;
+    if (!((doc_ce->type_u8==DOCT_NEW_LINE ||
+	  doc_ce->type_u8==DOCT_SOFT_NEW_LINE ||
+	  doc_ce->type_u8==DOCT_INDENT) &&
+	  (doc_ce->last->type_u8==DOCT_NEW_LINE ||
+	  doc_ce->last->type_u8==DOCT_SOFT_NEW_LINE ||
+	  doc_ce->last->type_u8==DOCT_INDENT)))
+      DocFormBwd(doc);
+    doc_ce=doc->cur_entry;
+  }
+  while (doc_ce2!=doc && (doc_ce2!=doc_ce || IsEditableText(doc_ce))) {
+    if ((doc_ce2->y<y || doc_ce2->x<x ||
+	  doc_ce2->de_flags & (DOCEF_SKIP|DOCEF_FILTER_SKIP) ||
+	  doc_ce2->x==x && !doc_ce2->max_col &&
+	  Bt(doldoc.type_flags_nontag_invis,doc_ce2->type_u8)) && sc>=0)
+      BEqu(&doc_ce2->type,DOCEt_SEL,sc&SCF_SHIFT);
+    if (doc_ce2==doc_ce) break;
+    doc_ce2=doc_ce2->next;
+  }
+  if (doc_ce->de_flags&DOCEF_TAG) {
+    doc->cur_col=x-doc_ce->x;
+    if (IsEditableText(doc_ce)) {
+      if (doc->cur_col>doc_ce->max_col)
+	doc->cur_col=doc_ce->max_col;
+    } else if (doc->cur_col>=doc_ce->max_col)
+      doc->cur_col=doc_ce->max_col-1;
+    if (doc->cur_col<doc_ce->min_col)
+      doc->cur_col=doc_ce->min_col;
+  } else
+    doc->cur_col=doc_ce->min_col;
+  if (IsEditableText(doc_ce)&&doc_ce->min_col<doc->cur_col<doc_ce->max_col-1) {
+    dst=doc_ce->tag+doc->cur_col;
+    doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+    *dst=0;
+    doc_ne->type=DOCT_TEXT | old_color & -0x100;
+    doc_ne->de_flags=old_de_flags|doldoc.dft_de_flags[DOCT_TEXT];
+    doc_ce->max_col=doc->cur_col;
+    doc_ne->x=doc_ce->x+doc->cur_col;
+    QueIns(doc_ne,doc_ce);
+    doc_ce=doc_ne;
+    doc->cur_col=doc_ce->min_col;
+  }
+  doc->cur_entry=doc_ce;
+  DocFormFwd(doc);
+  if (!(doc->flags & DOCF_FORM))
+    while (doc_ce!=doc && doc_ce!=doc->cur_entry) {
+      if (sc>=0)
+	BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+      doc_ce=doc_ce->next;
+    }
+  doc->x=doc->cur_entry->x+doc->cur_col;
+  if (unlock)
+    DocUnlock(doc);
+}
+
+U0 EdCharDel(CDoc *doc)
+{
+  Bool unlock=DocLock(doc);
+  CDocEntry *doc_ce=doc->cur_entry;
+
+  if (doc_ce==doc) {
+    if (unlock)
+      DocUnlock(doc);
+    return;
+  }
+  if (doc_ce->max_col!=0 &&
+	(IsEditableText(doc_ce)||doc_ce->type_u8==DOCT_DATA)) {
+    if (doc_ce->type_u8==DOCT_DATA && doc_ce->de_flags & DOCEF_HAS_TERMINATOR &&
+	  doc->cur_col==doc_ce->max_col-1) {
+      if (unlock)
+	DocUnlock(doc);
+      return;
+    }
+    if (doc->cur_col<doc_ce->max_col)
+      StrCpy(doc_ce->tag+doc->cur_col,doc_ce->tag+doc->cur_col+1);
+    if (doc->cur_col>=doc_ce->max_col-1) {
+      doc->cur_entry=doc_ce->next;
+      doc->cur_col=doc->cur_entry->min_col;
+    }
+    DocRemSoftNewLines(doc,doc->cur_entry);
+    if (unlock)
+      DocUnlock(doc);
+    return;
+  }
+  doc->cur_entry=doc_ce->next;
+  doc->cur_col=doc->cur_entry->min_col;
+  if (!(doc_ce->de_flags&DOCEF_FILTER_SKIP))
+    DocEntryDel(doc,doc_ce);
+  DocRemSoftNewLines(doc,doc->cur_entry);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+U0 ChkDollarBufSize(CDoc *doc)
+{
+  U8 *b;
+  if (doc->dollar_buf_ptr>=doc->dollar_buf_size-2) {
+    doc->dollar_buf_size<<=1;
+    b=MAlloc(doc->dollar_buf_size,doc->mem_task);
+    MemCpy(b,doc->dollar_buf,doc->dollar_buf_ptr);
+    Free(doc->dollar_buf);
+    doc->dollar_buf=b;
+  }
+}
+
+U0 EdCharIns(I64 ch,I64 sc,CDoc *doc)
+{
+  Bool unlock=DocLock(doc);
+  U8 *st,*src,*dst;
+  CDocEntry *doc_ce=doc->cur_entry,*doc_ne;
+  I64 i,j,m,y=doc_ce->y;
+
+  if (doc->flags & DOCF_IN_DOLLAR) {
+    if (!Bt(char_bmp_printable,ch))
+      goto ic_done;
+    ChkDollarBufSize(doc);
+    doc->dollar_buf[doc->dollar_buf_ptr++]=ch;
+    if (ch=='$$') {
+      if (doc->dollar_buf_ptr==2) {
+	doc->flags&=~DOCF_IN_DOLLAR;
+	doc->dollar_buf_ptr=0;
+	goto ic_cont;
+      } else {
+	doc->dollar_buf[doc->dollar_buf_ptr]=0;
+	doc->flags&=~DOCF_IN_DOLLAR;
+	DocPrint(doc,"%s",doc->dollar_buf);
+	doc->dollar_buf_ptr=0;
+	goto ic_done;
+      }
+    } else
+      goto ic_done;
+  }
+  if (ch=='$$' && !(doc->flags & (DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS))) {
+    doc->flags|=DOCF_IN_DOLLAR;
+    doc->dollar_buf_ptr=0;
+    doc->dollar_buf[doc->dollar_buf_ptr++]=ch;
+    goto ic_done;
+  }
+  if (ch=='\r') goto ic_done;
+
+    ic_cont:
+  if ((ch==CH_SPACE || ch=='\n') &&
+	!(sc & (SCF_CTRL|SCF_SHIFT)) &&
+	doc_ce->de_flags &
+	(DOCEF_LINK|DOCEF_TREE|DOCEF_LST|DOCEF_CHECK_COLLAPSABLE|
+	DOCEF_LEFT_MACRO|DOCEF_LEFT_EXP|DOCEF_LEFT_CB|DOCEF_LEFT_IN_STR |
+	DOCEF_RIGHT_MACRO|DOCEF_RIGHT_EXP|DOCEF_RIGHT_CB|DOCEF_RIGHT_IN_STR)) {
+    doc->cmd_U8=ch;
+    DocEntryRun(doc,doc_ce,FALSE);
+    DocLock(doc);
+    goto ic_done;
+  }
+  if (doc_ce->type_u8==DOCT_HEX_ED) {
+    if (doc_ce->de_flags&DOCEF_DEREF_DATA &&
+	  !(doc_ce->de_flags&DOCEF_REMALLOC_DATA))
+      st=doc_ce->data;
+    else
+      st=&doc_ce->data;
+    i=doc->cur_col;
+    j=i%(doc_ce->hex_ed_width*3);
+    m=i/(doc_ce->hex_ed_width*3)*doc_ce->hex_ed_width;
+    if (j>=doc_ce->hex_ed_width<<1)
+      st[j-doc_ce->hex_ed_width<<1+m]=ch;
+    else {
+      ch=ToUpper(ch)-'0';
+      if (ch>9) {
+	ch+='0'-'A'+10;
+	if (!(10<=ch<=15))
+	  goto ic_done;
+      }
+      m=j>>1+m;
+      if (j & 1)
+	st[m]=st[m] & 0xF0| ch;
+      else
+	st[m]=st[m] & 0xF | ch<<4;
+    }
+    doc->cur_col++;
+    goto ic_done;
+  }
+  if (doc->flags & DOCF_OVERSTRIKE) {
+    if (Bt(char_bmp_displayable,ch)) {
+ic_overstrike:
+      if (IsEditableText(doc_ce)) {
+	if (doc->cur_col<doc_ce->max_col) {
+	  if (doc_ce->tag[doc->cur_col]) {
+	    doc_ce->tag[doc->cur_col++]=ch;
+	    goto ic_done;
+	  }
+	} else {
+	  doc_ce=doc_ce->next;
+	  doc->cur_entry=doc_ce;
+	  doc->cur_col=doc_ce->min_col;
+	  goto ic_overstrike;
+	}
+      } else if (doc_ce->type_u8==DOCT_DATA) {
+	if (doc_ce->de_flags & DOCEF_HAS_TERMINATOR) {
+	  if (doc_ce->tag[doc->cur_col] &&
+		doc->cur_col<doc_ce->min_col+doc_ce->len) {
+	    doc_ce->tag[doc->cur_col++]=ch;
+	    if ( ! doc_ce->tag[doc->cur_col]) {
+	      doc_ce->tag[doc->cur_col]='_';
+	      doc_ce->tag[doc->cur_col+1]=0;
+	    }
+	  } else if (doc_ce->de_flags & DOCEF_REMALLOC_DATA)
+	    goto ic_not_overstrike;
+	} else if (doc_ce->tag[doc->cur_col])
+	  doc_ce->tag[doc->cur_col++]=ch;
+	goto ic_done;
+      }
+      doc_ne=DocEntryNewTag(doc,doc_ce,&ch);
+      doc_ne->type=DOCT_TEXT | doc->settings_head.dft_text_attr<<8;
+      doc_ne->de_flags=doldoc.dft_de_flags[DOCT_TEXT];
+      QueIns(doc_ne,doc_ce->last);
+    } else if (ch=='\n') {
+      while (doc->cur_entry->next!=doc && doc->cur_entry->y==y)
+	doc->cur_entry=doc->cur_entry->next;
+      doc->cur_col=doc->cur_entry->min_col;
+    } else if (ch=='\t') {
+      if (doc->flags&DOCF_FORM)
+	goto ic_form_tab;
+    }
+    goto ic_done;
+  }
+ic_not_overstrike:
+  if (ch=='\n') {
+    if (sc&SCF_CTRL && !(sc&SCF_SHIFT)) {
+      doc_ne=DocEntryNewBase(doc,
+	    DOCT_PAGE_BREAK|doc->settings_head.dft_text_attr<<8);
+    } else {
+      doc_ne=DocEntryNewBase(doc,
+	    DOCT_NEW_LINE|doc->settings_head.dft_text_attr<<8);
+    }
+    DocInsEntry(doc,doc_ne);
+  } else if (ch=='\t') {
+    if (doc->flags&DOCF_FORM &&
+	  (Bt(doldoc.type_flags_form,doc->cur_entry->type_u8) ||
+	  doc->cur_entry->de_flags&DOCEF_LINK) &&
+	  !(doc->cur_entry->de_flags&DOCEF_SKIP_IN_FORM)) {
+ic_form_tab:
+      doc->cur_entry=doc->cur_entry->next;
+      doc->cur_col=doc->cur_entry->min_col;
+      DocFormFwd(doc);
+      goto ic_done;
+    } else {
+      doc_ne=DocEntryNewBase(doc,DOCT_TAB|doc->settings_head.dft_text_attr<<8);
+      DocInsEntry(doc,doc_ne);
+    }
+  } else {
+    if (Bt(char_bmp_displayable,ch)) {
+      if (doc_ce->type_u8==DOCT_DATA) {
+	while (TRUE) {
+	  i=doc_ce->len+doc_ce->min_col;
+	  if (doc_ce->de_flags & DOCEF_HAS_TERMINATOR)
+	    i++;
+	  if (doc_ce->max_col<i) {
+	    st=doc_ce->tag;
+	    doc_ce->max_col++;
+	    for (i=doc_ce->max_col;i>doc->cur_col;i--)
+	      st[i]=st[i-1];
+	    st[doc->cur_col++]=ch;
+	    break;
+	  } else if (doc_ce->de_flags & DOCEF_REMALLOC_DATA) {
+	    st=MAlloc(doc_ce->max_col+8,doc->mem_task);
+	    MemCpy(st,doc_ce->tag,doc_ce->max_col+1);
+	    Free(doc_ce->tag);
+	    doc_ce->tag=st;
+	    doc_ce->len=MSize(st)-doc_ce->min_col-2; //See $LK,"DataTagWidth",A="FA:::/Adam/DolDoc/DocPlain.HC,DataTagWidth"$
+	    Free(doc_ce->data);
+	    doc_ce->data=MAlloc(doc_ce->len+2,doc->mem_task);
+	  } else
+	    break;
+	}
+      } else if (IsEditableText(doc_ce)) {
+	dst=st=MAlloc(doc_ce->max_col+2,doc->mem_task);
+	src=doc_ce->tag;
+	i=doc->cur_col;
+	while (i-->0)
+	  *dst++=*src++;
+	*dst++=ch;
+	while (*dst++=*src++);
+	Free(doc_ce->tag);
+	doc_ce->tag=st;
+	doc_ce->max_col++;
+	doc->cur_col++;
+      } else {
+	doc_ne=DocEntryNewTag(doc,doc_ce,&ch);
+	doc_ne->type=DOCT_TEXT | doc->settings_head.dft_text_attr<<8;
+	doc_ne->de_flags=doldoc.dft_de_flags[DOCT_TEXT];
+	doc_ne->x=doc_ce->x+1;
+	QueIns(doc_ne,doc_ce->last);
+      }
+    }
+  }
+ic_done:
+  DocRemSoftNewLines(doc,doc->cur_entry);
+  if (doc->cur_entry->de_flags & DOCEF_UPDATE_DATA &&
+	(doc->cur_entry->type_u8==DOCT_DATA ||
+	doc->cur_entry->type_u8==DOCT_CHECK_BOX))
+    DocDataScan(doc,doc->cur_entry);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+U0 EdLineDel(CDoc *doc)
+{
+  CDocEntry *doc_ce=doc->cur_entry,*doc_ce2;
+  I64 y;
+  y=doc->y;
+  while (doc_ce!=doc && doc_ce->y==y)
+    doc_ce=doc_ce->next;
+  doc->cur_entry=doc_ce;
+  doc->cur_col=doc_ce->min_col;
+  doc_ce=doc_ce->last;
+  while (doc_ce!=doc && doc_ce->y==y) {
+    doc_ce2=doc_ce->last;
+    if (!(doc_ce->de_flags&DOCEF_FILTER_SKIP))
+      DocEntryDel(doc,doc_ce);
+    doc_ce=doc_ce2;
+  }
+}

TempleOSCD/Adam/DolDoc/DocClipBoard.HC

@@ -0,0 +1,123 @@
+#help_index "DolDoc/Clipboard"
+
+sys_clipboard_doc=DocNew;
+
+public U0 ClipboardDel()
+{//Delete everything on clipboard.
+  DocRst(sys_clipboard_doc,TRUE);
+}
+
+public U0 EdCopyToClipboard(CDoc *doc)
+{//Copy $LK,"DOCET_SEL",A="MN:DOCET_SEL"$ flagged entries to clipboard.
+  CDoc *doc2=sys_clipboard_doc;
+  Bool unlock_doc=DocLock(doc),
+	unlock_doc2=DocLock(doc2);
+  CDocEntry *doc_e=doc->head.next,*doc_ne;
+  ClipboardDel;
+  while (doc_e!=doc) {
+    if (doc_e->type & DOCET_SEL) {
+      doc_e->type&=~DOCET_SEL;
+      if (!Bt(doldoc.type_flags_data,doc_e->type_u8)) {
+	doc_ne=DocEntryCopy(doc2,doc_e);
+	QueIns(doc_ne,doc2->head.last);
+      }
+    }
+    doc_e=doc_e->next;
+  }
+  if (unlock_doc2)
+    DocUnlock(doc2);
+  if (unlock_doc)
+    DocUnlock(doc);
+}
+
+public U0 EdCutToClipboard(CDoc *doc)
+{//Remove sel entries and place on clipboard.
+  CDoc *doc2=sys_clipboard_doc;
+  Bool unlock_doc=DocLock(doc),
+	unlock_doc2=DocLock(doc2);
+  CDocEntry *doc_e=doc->head.next,*doc_e1,*doc_ne,*doc_e2=NULL;
+  ClipboardDel;
+  while (doc_e!=doc) {
+    doc_e1=doc_e->next;
+    if (doc_e->type & DOCET_SEL) {
+      doc_e->type&=~DOCET_SEL;
+      if (!Bt(doldoc.type_flags_data,doc_e->type_u8)) {
+	doc_ne=DocEntryCopy(doc2,doc_e);
+	QueIns(doc_ne,doc2->head.last);
+      }
+      if (doc_e==doc->cur_entry || doc_e==doc_e2)
+	doc_e2=doc_e->next;
+      DocEntryDel(doc,doc_e);
+    }
+    doc_e=doc_e1;
+  }
+  if (doc_e2) {
+    doc->cur_entry=doc_e2;
+    doc->cur_col=doc_e2->min_col;
+  }
+  DocRemSoftNewLines(doc,NULL);
+  if (unlock_doc2)
+    DocUnlock(doc2);
+  if (unlock_doc)
+    DocUnlock(doc);
+}
+
+public U0 EdPasteClipboard(CDoc *doc)
+{//Insert copy of clipboard at insert pt, cur_entry.
+  CDoc *doc2=sys_clipboard_doc;
+  Bool unlock_doc=DocLock(doc),
+	unlock_doc2=DocLock(doc2);
+  CDocEntry *doc_ce=doc->cur_entry,*doc_e;
+  if (doc_ce->type_u8==DOCT_DATA) {
+    doc_e=doc2->head.next;
+    while (doc_e!=doc2) {
+      if (doc_e->de_flags&DOCEF_TAG)
+	DocPrintPartial(doc,"%s",doc_e->tag);
+      doc_e=doc_e->next;
+    }
+  } else
+    DocInsDoc(doc,doc2);
+  if (unlock_doc2)
+    DocUnlock(doc2);
+  if (unlock_doc)
+    DocUnlock(doc);
+}
+
+public U0 DocCut(CDoc *doc,CDocEntry *start,CDocEntry *end)
+{//Del start to end entry, including end points.
+  Bool unlock_doc=DocLock(doc);
+  CDocEntry *doc_e1;
+  while (start!=doc) {
+    doc_e1=start->next;
+    if (start==doc->cur_entry) {
+      doc->cur_entry=start->next;
+      doc->cur_col=doc->cur_entry->min_col;
+    }
+    DocEntryDel(doc,start);
+    if (start==end)
+      break;
+    start=doc_e1;
+  }
+  DocRemSoftNewLines(doc,NULL);
+  if (unlock_doc)
+    DocUnlock(doc);
+}
+
+public CDoc *DocCopy(CDoc *doc,CDocEntry *start,CDocEntry *end)
+{//Copies start to end entry, including end points.
+  CDoc *doc2=DocNew;
+  Bool unlock_doc=DocLock(doc);
+  CDocEntry *doc_ne;
+  while (start!=doc) {
+    if (!Bt(doldoc.type_flags_data,start->type_u8)) {
+      doc_ne=DocEntryCopy(doc2,start);
+      QueIns(doc_ne,doc2->head.last);
+    }
+    if (start==end)
+      break;
+    start=start->next;
+  }
+  if (unlock_doc)
+    DocUnlock(doc);
+  return doc2;
+}

TempleOSCD/Adam/DolDoc/DocCodeTools.HC

@@ -0,0 +1,658 @@
+#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=CurDir;
+      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);
+      DocLineNumGoTo(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);
+	DocLineNumGoTo(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);
+      DocLineNumGoTo(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);
+  DocLineNumGoTo(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;
+  }
+}

TempleOSCD/Adam/DolDoc/DocDblBuf.HC

@@ -0,0 +1,110 @@
+#help_index "DolDoc/Task;StdOut/Task"
+public CDoc *DocPut(CTask *task=NULL)
+{//Current document that StdOut Put() goes to.
+//Basically, StdOut unless double buffering.
+  CDoc *res;
+  if (!task) task=Fs;
+  if (Bt(&task->task_flags,TASKf_INPUT_FILTER_TASK))
+    task=task->parent_task;
+  if ((res=task->put_doc) && res->doc_signature==DOC_SIGNATURE_VAL)
+    return res;
+  else
+    return NULL;
+}
+
+public CDoc *DocDisplay(CTask *task=NULL)
+{//StdOut displayed unless double buffering.
+  CDoc *res;
+  if (!task) task=Fs;
+  if ((res=task->display_doc) && res->doc_signature==DOC_SIGNATURE_VAL)
+    return res;
+  else
+    return NULL;
+}
+
+public CDoc *DocBorder(CTask *task=NULL)
+{//Doc holding border of window text.
+  CDoc *res;
+  if (!task) task=Fs;
+  if ((res=task->border_doc) && res->doc_signature==DOC_SIGNATURE_VAL)
+    return res;
+  else
+    return NULL;
+}
+
+public CDoc *DocDblBufStart(CTask *task=NULL)
+{//See $LK,"::/Demo/Spy.HC"$
+  Bool unlock_ddoc;
+  CDoc *pdoc=DocPut(task),*ddoc=DocDisplay(task),*res;
+  if (!pdoc || !ddoc || pdoc!=ddoc)
+    res=NULL; //Already Double buffering
+  else {
+    if (!task) task=Fs;
+    unlock_ddoc=DocLock(ddoc); //dont change during winupdate, so lock DocPut$WW,0$
+    res=DocNew(,task);
+    res->win_task		=ddoc->win_task;
+    res->max_entries		=ddoc->max_entries;
+    MemCpy(res->find_replace,ddoc->find_replace,sizeof(CEdFindText));
+    MemCpy(&res->filename,&ddoc->filename,sizeof(CEdFileName));
+    res->left_click_link	=ddoc->left_click_link;
+    res->right_click_link	=ddoc->right_click_link;
+    res->user_put_data	=ddoc->user_put_data;
+    res->user_put_key	=ddoc->user_put_key;
+    res->user_put_s		=ddoc->user_put_s;
+    res->parent_doc		=ddoc->parent_doc;
+    res->desc		=ddoc->desc;
+    res->user_data		=ddoc->user_data;
+    res->flags|=ddoc->flags&DOCG_DBL_BUF_FLAGS | DOCF_DONT_SHOW;
+    task->put_doc=res;
+    if (unlock_ddoc)
+      DocUnlock(ddoc);
+  }
+  return res;
+}
+
+public Bool DocDblBufEnd(CTask *task=NULL)
+{//See $LK,"::/Demo/Spy.HC"$
+  Bool res=FALSE;
+  CDoc *pdoc=DocPut(task),*ddoc=DocDisplay(task);
+  if (pdoc && ddoc && pdoc!=ddoc) {//Double buffering?
+    if (!task) task=Fs;
+    ddoc->flags|=DOCF_DONT_SHOW;
+    pdoc->flags&=~DOCF_DONT_SHOW;
+    DocLock(ddoc);
+    task->display_doc=pdoc;
+    DocUnlock(ddoc);
+    DocDel(ddoc);
+    res=TRUE;
+  }
+  return res;
+}
+
+public Bool DocDblBufSwap(CTask *task=NULL)
+{//See $LK,"::/Demo/Spy.HC"$
+  Bool res=FALSE;
+  CDoc *pdoc=DocPut(task),*ddoc=DocDisplay(task);
+  if (pdoc && ddoc && pdoc!=ddoc) {//Double buffering?
+    if (!task) task=Fs;
+    ddoc->flags|=DOCF_DONT_SHOW;
+    pdoc->flags&=~DOCF_DONT_SHOW;
+    DocLock(ddoc);
+    task->display_doc=pdoc;
+    DocUnlock(ddoc);
+    DocRst(ddoc,TRUE);
+    MemCpy(ddoc->find_replace,pdoc->find_replace,sizeof(CEdFindText));
+    MemCpy(&ddoc->filename,&pdoc->filename,sizeof(CEdFileName));
+    ddoc->max_entries		=pdoc->max_entries;
+    ddoc->flags			=pdoc->flags&DOCG_DBL_BUF_FLAGS |
+	  ddoc->flags&~DOCG_DBL_BUF_FLAGS;
+    ddoc->left_click_link	=pdoc->left_click_link;
+    ddoc->right_click_link	=pdoc->right_click_link;
+    ddoc->user_put_data		=pdoc->user_put_data;
+    ddoc->user_put_key		=pdoc->user_put_key;
+    ddoc->user_put_s		=pdoc->user_put_s;
+    ddoc->desc			=pdoc->desc;
+    ddoc->user_data		=pdoc->user_data;
+    task->put_doc=ddoc;
+    res=TRUE;
+  }
+  return res;
+}

TempleOSCD/Adam/DolDoc/DocEd.HC

@@ -0,0 +1,250 @@
+#help_index "DolDoc/Output;StdOut/DolDoc"
+
+public Bool View()
+{//Go live for user interaction until <ESC> or <SHIFT-ESC>.
+  I64 ch;
+  do ch=DocGetKey;
+  while (ch!=CH_ESC && ch!=CH_SHIFT_ESC);
+  return ch==CH_ESC;
+}
+
+#help_index "DolDoc"
+U8 *EdOverStrikeCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
+{
+  CDoc *doc=doc_e->user_data;
+  U8 *st=MAlloc(8,mem_task);
+  if (doc->flags & DOCF_OVERSTRIKE)
+    *st='O';
+  else
+    *st='Ä';
+  st[1]=0;
+  return st;
+}
+
+U8 *EdFilterCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
+{
+  CDoc *doc=doc_e->user_data;
+  U8 *st=MAlloc(8,mem_task);
+  if (doc->find_replace->filter_lines)
+    *st='F';
+  else
+    *st='Ä';
+  st[1]=0;
+  return st;
+}
+
+U8 *EdDollarCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
+{
+  CDoc *doc=doc_e->user_data;
+  U8 *st=MAlloc(8,mem_task);
+  if (doc->flags & DOCF_IN_DOLLAR)
+    *st='$$';
+  else
+    *st='Ä';
+  st[1]=0;
+  return st;
+}
+
+U8 *EdMoreCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
+{
+  CDoc *doc=doc_e->user_data;
+  U8 *st=MAlloc(8,mem_task);
+  if (doc->flags&DOCF_MORE)
+    StrCpy(st,"MoreÄ");
+  else
+    StrCpy(st,"ÄÄÄÄÄ");
+  return st;
+}
+
+U8 *EdDollarTypeCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
+{
+  CDoc *doc=doc_e->user_data;
+  U8 *src=DefineSub(doc->cur_entry->type_u8,"ST_DOC_CMDS"),
+	*st=CAlloc(8,mem_task);
+  if (doc->cur_entry==doc)
+    src="EOF";
+  else if (!src)
+    src="ERR";
+  StrPrint(st,"%-3ts",src);
+  return st;
+}
+
+public Bool DocEd(CDoc *doc,I64 dof_flags=0)
+{//Live for user interaction. End on <ESC> or <SHIFT-ESC>.
+  CDoc *old_put_doc	  =DocPut,
+	*old_display_doc=DocDisplay,
+	*old_border_doc =DocBorder,*bdoc;
+  CDocEntry *doc_e;
+  I64 old_attr=Fs->text_attr,
+	old_top =Fs->win_top, old_bottom=Fs->win_bottom,
+	old_left=Fs->win_left,old_right =Fs->win_right,
+	old_title_src=Fs->title_src;
+  Bool res,unlock;
+  U8 *old_task_title;
+  if (dof_flags&DOF_WIN_MAX)
+    WinMax;
+
+  unlock=DocLock(doc);
+  doc->win_task=Fs;
+  bdoc=DocNew;
+  bdoc->flags|=DOCF_BORDER_DOC;
+  DocPrint(bdoc,"$$CM+TY+LX+NC,0,-1$$");
+  DocPrint(bdoc,"$$TX+RX+BD,\"[X]\"$$");
+  DocPrint(bdoc,"$$BK,1$$$$TX+LX+BD,\"MENU\"$$$$BK,0$$");
+
+  old_task_title=StrNew(Fs->task_title);
+  if (Fs->title_src!=TTS_LOCKED_CONST) {
+    Fs->title_src=TTS_ED_FILENAME;
+    MemCpy(Fs->task_title,doc->filename.name,STR_LEN-1);
+  }
+  doc_e=DocPrint(bdoc,"$$DA-TRM-P+BD+RD+CX+IV,LEN=STR_LEN-1,"
+	"A=\"%%s...\",SCX=16$$");
+  doc_e->data=&Fs->task_title;
+  DocDataFmt(bdoc,doc_e);
+
+  if (doc->flags & DOCF_ALLOW_UNDO) {
+    DocPrint(bdoc,"$$CM+BY+LX+NC,1,1$$");
+    doc_e=DocPrint(bdoc,"$$DA+BD+RD-TRM,RT=U32,A=\"Undo:%%03d\"$$\n");
+    doc_e->data=&doc->undo_cnt;
+    DocDataFmt(bdoc,doc_e);
+  }
+
+  DocPrint(bdoc,"$$CM+BY+RX+NC,-30,1$$");
+  doc_e=DocPrint(bdoc,"$$TX+BD+TC,\"     \"$$");
+  doc_e->user_data=doc;
+  doc_e->tag_cb=&EdMoreCB;
+  doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
+  doc_e->user_data=doc;
+  doc_e->tag_cb=&EdDollarTypeCB;
+  doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
+  doc_e->user_data=doc;
+  doc_e->tag_cb=&EdFilterCB;
+  doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
+  doc_e->user_data=doc;
+  doc_e->tag_cb=&EdOverStrikeCB;
+  doc_e=DocPrint(bdoc,"$$TX+BD+TC,\" \"$$");
+  doc_e->user_data=doc;
+  doc_e->tag_cb=&EdDollarCB;
+  doc_e=DocPrint(bdoc,"$$DA+BD+RD-TRM,A=\"Line:%%04d \"$$");
+  doc_e->data=&doc->line;
+  DocDataFmt(bdoc,doc_e);
+  doc_e=DocPrint(bdoc,"$$DA+BD+RD-TRM,A=\"Col:%%04d\"$$\n");
+  doc_e->data=&doc->col;
+  DocDataFmt(bdoc,doc_e);
+
+  DocRecalc(bdoc);
+  DocRecalc(doc);
+  if (!(dof_flags&DOF_DONT_HOME))
+    DocTop(doc);
+  Fs->border_doc=bdoc;
+  if (doc!=old_display_doc)
+    doc->parent_doc=old_display_doc;
+  Fs->put_doc=Fs->display_doc=doc;
+  if (!(dof_flags&DOF_DONT_TEXT_ATTR))
+    Fs->text_attr=DOC_ATTR_DFT_TEXT;
+  if (!(dof_flags&DOF_DONT_SHOW)) {
+    LBts(&Fs->display_flags,DISPLAYf_SHOW);
+    WinZBufUpdate;
+  }
+  if (dof_flags&DOF_SIZE_MIN)
+    doc->flags|=DOCF_SIZE_MIN;
+
+  DocUnlock(doc);
+  if (!(dof_flags&DOF_DONT_WINMGR_SYNC)) {
+    Refresh(2,TRUE);
+    if (doc->flags&DOCF_SIZE_MIN)
+      Refresh(2,TRUE);
+  }
+  res=View;
+
+  DocLock(doc);
+  if (res) {
+    doc_e=doc->head.next;
+    while (doc_e!=doc) {
+      if (doc_e->type_u8==DOCT_DATA || doc_e->type_u8==DOCT_CHECK_BOX)
+	DocDataScan(doc,doc_e);
+      doc_e=doc_e->next;
+    }
+  }
+  if (unlock)
+    DocUnlock(doc);
+  Fs->border_doc =old_border_doc;
+  Fs->display_doc=old_display_doc;
+  Fs->put_doc	 =old_put_doc;
+  Fs->text_attr  =old_attr;
+  if (Fs->title_src!=TTS_LOCKED_CONST) {
+    Fs->title_src  =old_title_src;
+    StrCpy(Fs->task_title,old_task_title);
+  }
+  Free(old_task_title);
+  DocDel(bdoc);
+  if (dof_flags&DOF_SIZE_MIN) {
+    WinHorz(old_left,old_right);
+    WinVert(old_top,old_bottom);
+  }
+  return res;
+}
+
+#help_index "DolDoc/Cmd Line (Typically);Cmd Line (Typically)"
+public Bool Ed(U8 *link_st,I64 edf_dof_flags=0)
+{//Invoke document editor.
+  U8 *filename,*needle_str;
+  I64 i,num;
+  Bool cont,res=FALSE;
+  CDoc *doc;
+
+  switch (i=EdLinkCvt(link_st,&filename,&needle_str,&num,edf_dof_flags)) {
+    case -1:
+      break;
+    case LK_DEF:
+      doc=DocNew;
+      doc->desc='DictDef';
+      ACDDefsPut(doc,filename,num);
+      goto ej_doc;
+    case LK_HELP_INDEX:
+      doc=DocNew;
+      doc->desc='HelpIndx';
+      DocHelpIdx(doc,filename);
+ej_doc:
+      if (!(edf_dof_flags&EDF_BAIL)) {
+	DocEd(doc);
+	DocDel(doc);
+      }
+      if (!(edf_dof_flags&EDF_WAS_WRITE))
+	res=TRUE;
+      break;
+    default:
+      if (IsRaw)
+	res=EdLite(filename,num,edf_dof_flags);
+      else {
+	cont=TRUE;
+	if (!(edf_dof_flags&EDF_BAIL) && !(LK_DOC<=i<=LK_DOC_LINE) &&
+	      !FilesFindMatch(filename,FILEMASK_TXT) &&
+	      !PopUpCancelOk(ST_WARN_ST "Not Text File\n\n"))
+	  cont=FALSE;
+	if (cont)
+	  res=DocFileEd(i,filename,needle_str,&num,edf_dof_flags);
+      }
+  }
+  Free(filename);
+  Free(needle_str);
+  return res;
+}
+
+public Bool Plain(U8 *filename,I64 edf_dof_flags=0)
+{//Edit document in plain text mode, so dollar signs are not special.
+  Bool res;
+  U8 *st=MStrPrint("PI:%s",filename);
+  res=Ed(st,edf_dof_flags);
+  Free(st);
+  return res;
+}
+
+#help_index "DolDoc;Job/Exe;Task/Job/Exe"
+public I64 PopUpEd(U8 *filename,CTask *parent=NULL,CTask **_pu_task=NULL)
+{//Create PopUp win task and edit a doc.
+  U8 *st=MStrPrint("Ed(\"%Q\");",filename);
+  I64 res=PopUp(st,parent,_pu_task);
+  Free(st);
+  return res;
+}

TempleOSCD/Adam/DolDoc/DocExt.HC

@@ -0,0 +1,13 @@
+#help_index "DolDoc"
+extern Bool DocEd(CDoc *doc,I64 dof_flags=0);
+extern I64 DocEntryRun(CDoc *doc,CDocEntry *doc_e,
+	Bool exited,I64 *_has_action=NULL);
+extern U0 DocFormBwd(CDoc *doc,Bool giveup=FALSE);
+extern U0 DocLoad(CDoc *doc,U8 *src2,I64 size);
+extern U0 DocPrintAtomic(CDoc *doc=NULL,U8 *fmt,...);
+extern U0 DocPrintPartial(CDoc *doc=NULL,U8 *fmt,...);
+extern CDocEntry *DocPutS(CDoc *doc,U8 *st);
+extern U8 *DocSave(CDoc *doc,I64 *_size=NULL);
+extern I64 EdLeftClickLink(CDoc *doc,CDocEntry *doc_e);
+extern U8 *PopUpPickLst(U8 *lst);
+extern I64 TermRightClickLink(CDoc *doc,CDocEntry *doc_e);

TempleOSCD/Adam/DolDoc/DocFile.HC

@@ -0,0 +1,333 @@
+#help_index "DolDoc/File"
+
+public U0 DocLoad(CDoc *doc,U8 *src2,I64 size)
+{//Fetch doc from raw mem buf.
+  I64 i;
+  U8 *src;
+  Bool unlock=DocLock(doc);
+  CDocBin *tmpb;
+  doc->find_replace->filter_lines=0;
+  if (src2) {
+    DocPutS(doc,src2); //Too big $LK,"DocPrint",A="MN:DocPrint"$() is wasteful.
+    src=src2+StrLen(src2)+1;
+    i=size-(offset(CDocBin.end)-offset(CDocBin.start));
+    while (src<=src2+i) {
+      tmpb=CAlloc(sizeof(CDocBin),doc->mem_task);
+      MemCpy(&tmpb->start,src,offset(CDocBin.end)-offset(CDocBin.start));
+      src+=offset(CDocBin.end)-offset(CDocBin.start);
+      tmpb->data=MAlloc(tmpb->size,doc->mem_task);
+      if (tmpb->size) {
+	MemCpy(tmpb->data,src,tmpb->size);
+	src+=tmpb->size;
+      }
+      QueIns(tmpb,doc->bin_head.last);
+      if (tmpb->num>=doc->cur_bin_num)
+	doc->cur_bin_num=tmpb->num+1;
+    }
+  }
+  if (!(doc->flags & (DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS)))
+    DocBinsValidate(doc);
+  DocTop(doc); //Calls $LK,"DocRecalc",A="MN:DocRecalc"$().  DOCT_CURSOR will be set.
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public CDoc *DocRead(U8 *name=NULL,I64 flags=0)
+{//Fetch doc from disk. See $LK,"flags",A="MN:DOCF_PLAIN_TEXT"$.
+  CDoc *doc=DocNew;
+  U8 *src,*name2;
+  I64 size=0;
+  CDirContext *dirc;
+  if (!name) name=blkdev.tmp_filename;
+  doc->flags|=flags;
+  name2=FileNameAbs(name);
+  StrCpy(doc->filename.name,name2);
+  if (src=FileRead(name2,&size,&doc->file_attr)) {
+    if (dirc=DirContextNew(name2)) {
+      DocLoad(doc,src,size);
+      DirContextDel(dirc);
+    }
+    Free(src);
+  }
+  Free(name2);
+  return doc;
+}
+
+public U8 *DocSave(CDoc *doc,I64 *_size=NULL)
+{//Store doc to raw mem buf.
+  CDocEntry *doc_e,*doc_e1;
+  CDocBin *b;
+  Bool unlock=DocLock(doc);
+  I64 ch,cnt=1;//terminator
+  U8 *st,*res,*dst,*src;
+
+  if (!(doc->flags & (DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS)))
+    DocBinsValidate(doc);
+  if (doc->flags&DOCF_NO_CURSOR)
+    DocRecalc(doc);
+  else {
+    DocRecalc(doc,RECALCF_ADD_CURSOR);
+    if (doc->head.next->type_u8==DOCT_CURSOR)
+      DocEntryDel(doc,doc->head.next); //If no cursor, $LK,"DocLoad",A="MN:DocLoad"$() puts at top.
+  }
+  for (doc_e=doc->head.next;doc_e!=doc;doc_e=doc_e->next) {
+    if (!Bt(doldoc.type_flags_data,doc_e->type_u8)) {
+      switch (doc_e->type_u8) {
+	case DOCT_TAB:
+	case DOCT_PAGE_BREAK:
+	case DOCT_CURSOR:
+	  cnt++;
+	  break;
+	case DOCT_NEW_LINE:
+	  if (doc->flags&DOCF_CARRIAGE_RETURN)
+	    cnt+=2;
+	  else
+	    cnt++;
+	  break;
+	case DOCT_SOFT_NEW_LINE:
+	  break;
+	case DOCT_TEXT:
+	  if (!(doc_e->de_flags & ~(DOCEF_TAG|DOCG_BL_IV_UL|DOCEF_WORD_WRAP|
+		DOCEF_HIGHLIGHT|DOCEF_SKIP|DOCEF_FILTER_SKIP))&&
+		!(doc_e->type&DOCG_BL_IV_UL)) {
+	    cnt+=StrLen(doc_e->tag);
+	    if (!(doc->flags & (DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS)) ||
+		  doc->flags&DOCF_DBL_DOLLARS)
+	      cnt+=StrOcc(doc_e->tag,'$$');
+	    break;
+	  }
+	default:
+	  st=Doc2PlainText(doc,doc_e);
+	  cnt+=StrLen(st)+2;
+	  Free(st);
+      }
+    }
+  }
+  for (b=doc->bin_head.next;b!=&doc->bin_head;b=b->next)
+    if (b->use_cnt>b->tmp_use_cnt)
+      cnt+=offset(CDocBin.end)-offset(CDocBin.start)+b->size;
+  res=MAlloc(cnt);
+  dst=res;
+  doc_e=doc->head.next;
+  while (doc_e!=doc) {
+    doc_e1=doc_e->next;
+    if (!Bt(doldoc.type_flags_data,doc_e->type_u8))
+      switch (doc_e->type_u8) {
+	case DOCT_CURSOR:
+	  DocEntryDel(doc,doc_e);
+	  *dst++=CH_CURSOR;
+	  break;
+	case DOCT_TAB:
+	  *dst++='\t';
+	  break;
+	case DOCT_NEW_LINE:
+	  if (doc->flags&DOCF_CARRIAGE_RETURN)
+	    *dst++='\r';
+	  *dst++='\n';
+	  break;
+	case DOCT_SOFT_NEW_LINE:
+	  break;
+	case DOCT_TEXT:
+	  if (!(doc_e->de_flags & ~(DOCEF_TAG|DOCG_BL_IV_UL|DOCEF_WORD_WRAP|
+		DOCEF_HIGHLIGHT|DOCEF_SKIP|DOCEF_FILTER_SKIP)) &&
+		!(doc_e->type&DOCG_BL_IV_UL)) {
+	    src=doc_e->tag;
+	    while (ch=*src++) {
+	      *dst++=ch;
+	      if (ch=='$$' && (!(doc->flags & (DOCF_PLAIN_TEXT|
+		    DOCF_PLAIN_TEXT_TABS)) || doc->flags&DOCF_DBL_DOLLARS))
+		*dst++=ch;
+	    }
+	    break;
+	  }
+	default:
+	  *dst++='$$';
+	  st=Doc2PlainText(doc,doc_e);
+	  StrCpy(dst,st);
+	  dst+=StrLen(st);
+	  *dst++='$$';
+	  Free(st);
+      }
+    doc_e=doc_e1;
+  }
+  *dst++=0;
+  b=doc->bin_head.next;
+  if (b!=&doc->bin_head) {
+    do {
+      if (b->use_cnt>b->tmp_use_cnt) {
+	MemCpy(dst,&b->start,offset(CDocBin.end)-offset(CDocBin.start));
+	dst+=offset(CDocBin.end)-offset(CDocBin.start);
+	MemCpy(dst,b->data,b->size);
+	dst+=b->size;
+      }
+      b=b->next;
+    } while (b!=&doc->bin_head);
+  } else
+    cnt--; //No terminator
+  if (_size) *_size=cnt;
+  if (unlock)
+    DocUnlock(doc);
+  return res;
+}
+
+public Bool DocWrite(CDoc *doc,Bool prompt=FALSE)
+{//Store doc to disk.
+  I64 size;
+  U8 *buf;
+  if (prompt && !DocForm(&doc->filename) ||
+	doc->filename.name[0]=='A' && doc->filename.name[2]==':')
+    return FALSE;  //CANCEL || LK_DOC,LK_DOC_ANCHOR,LK_DOC_FIND,LK_DOC_LINE?
+  buf=DocSave(doc,&size);
+  FileWrite(doc->filename.name,buf,size,0,doc->file_attr);
+  Free(buf);
+  return TRUE;
+}
+
+#help_index "DolDoc"
+public U0 DocInsDoc(CDoc *doc=NULL,CDoc *doc2)
+{//Insert copy of doc2 into doc at insert pt, cur_entry.
+//TODO: $LK,"DocRst",A="MN:DocRst"$
+  U8 *dst;
+  Bool unlock_doc,unlock_doc2=DocLock(doc2);
+  CDocEntry *doc_ne,*doc_e=doc2->head.next,*doc_ce;
+  if (!doc) doc=DocPut;
+  unlock_doc=DocLock(doc),
+	DocRemSoftNewLines(doc,NULL);
+  doc_ce=doc->cur_entry;
+  if (doc_ce->type_u8==DOCT_TEXT && doc->cur_col>doc_ce->min_col) {
+    if (doc->cur_col<doc_ce->max_col) {
+      dst=doc_ce->tag+doc->cur_col;
+      doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+      *dst=0;
+      doc_ne->type=DOCT_TEXT | doc_ce->type & 0xFFFFFF00;
+      doc_ce->max_col=doc->cur_col;
+      QueIns(doc_ne,doc_ce);
+      doc->cur_entry=doc_ne;
+      doc->cur_col=doc_ne->min_col;
+    } else
+      if (doc_ce!=doc)
+	doc->cur_entry=doc_ce->next;
+  }
+  while (doc_e!=doc2) {
+    if (doc_e->type_u8!=DOCT_SOFT_NEW_LINE) {
+      doc_ne=DocEntryCopy(doc,doc_e);
+      QueIns(doc_ne,doc->cur_entry->last);
+    }
+    doc_e=doc_e->next;
+  }
+  DocRecalc(doc);
+  if (unlock_doc2)
+    DocUnlock(doc2);
+  if (unlock_doc)
+    DocUnlock(doc);
+}
+
+#help_index "DolDoc/Compiler;Compiler/Directive"
+public U0 StreamDoc(CDoc *doc)
+{//Inject doc into compile stream. Use inside #exe{}.
+//TODO: $LK,"DocRst",A="MN:DocRst"$
+  Bool unlock_doc=DocLock(doc);
+  CDocEntry *doc_e=doc->head.next;
+  while (doc_e!=doc) {
+    if (doc_e->type_u8==DOCT_TEXT)
+      StreamPrint("%s",doc_e->tag);
+    else if (doc_e->type_u8==DOCT_NEW_LINE)
+      StreamPrint("\n");
+    else if (doc_e->type_u8==DOCT_TAB)
+      StreamPrint("\t");
+    doc_e=doc_e->next;
+  }
+  if (unlock_doc)
+    DocUnlock(doc);
+}
+
+#help_index "DolDoc"
+Bool DocCaptureUndo(CDoc *doc,Bool force=FALSE)
+{
+  Bool res=FALSE,unlock;
+  I64 time_stamp,flags;
+  CDocUndo *u;
+  if (doc->flags&DOCF_ALLOW_UNDO) {
+    unlock=DocLock(doc);
+    time_stamp=GetTSC;
+    if (doc->flags&DOCF_UNDO_DIRTY &&
+	  time_stamp>doc->undo_head.last->time_stamp+cnts.time_stamp_freq<<4 ||
+	  force) {
+      u=CAlloc(sizeof(CDocUndo),doc->mem_task);
+      u->time_stamp=time_stamp;
+      flags=doc->flags;
+      doc->flags&=~DOCF_NO_CURSOR;
+      u->body=DocSave(doc,&u->size);
+      doc->flags=flags;
+      QueIns(u,doc->undo_head.last);
+      doc->flags&=~DOCF_UNDO_DIRTY;
+      doc->undo_cnt++;
+      u->doc_flags=doc->flags;
+      res=TRUE;
+    }
+    if (unlock)
+      DocUnlock(doc);
+  }
+  return res;
+}
+ 
+U0 DocUndoRestore(CDoc *doc)
+{
+  Bool unlock=DocLock(doc);
+  CDocUndo *u=doc->undo_head.last,*u_next,*u_last;
+  if (u!=&doc->undo_head) {
+    QueRem(u);
+    u_next=doc->undo_head.next;
+    u_last=doc->undo_head.last;
+    QueInit(&doc->undo_head);
+    DocRst(doc,TRUE);
+    doc->flags=u->doc_flags&~DOCF_NO_CURSOR;
+    DocLoad(doc,u->body,u->size);
+    doc->flags=u->doc_flags;
+    DocUndoDel(doc,u);
+    doc->undo_head.next=u_next;
+    doc->undo_head.last=u_last;
+  }
+  DocUndoCntSet(doc);
+  doc->flags&=~DOCF_UNDO_DIRTY;
+  if (unlock)
+    DocUnlock(doc);
+}
+
+#help_index "Graphics/Windows BMP Files;Graphics/GR Files;"\
+	"DolDoc/Output;StdOut/DolDoc"
+public Bool DocType(CDoc *doc=NULL,U8 *filename,I64 trailing_new_lines=1)
+{//Output txt or graphic file to document.
+  Bool res=FALSE;
+  CDoc *doc2;
+  if (!doc && !(doc=DocPut) || doc->doc_signature!=DOC_SIGNATURE_VAL)
+    return FALSE;
+  if (FilesFindMatch(filename,FILEMASK_TXT)) {
+    doc2=DocRead(filename);
+    DocInsDoc(doc,doc2);
+    if (IsRaw)
+      DocDump(doc2,100000);
+    DocDel(doc2);
+    res=TRUE;
+  } else if (FilesFindMatch(filename,"*.BMP.Z")) {
+    DocBMP(doc,filename,,FALSE);
+    res=TRUE;
+  } else if (FilesFindMatch(filename,"*.BMP;*.bmp")) {
+    DocBMP(doc,filename,,TRUE);
+    res=TRUE;
+  } else if (FilesFindMatch(filename,"*.GR*")) {
+    DocGR(doc,filename);
+    res=TRUE;
+  }
+  if (res)
+    DocPrint(doc,"%h*c",trailing_new_lines,'\n');
+  return res;
+}
+
+#help_index "Graphics/Windows BMP Files;Graphics/GR Files;"\
+	"File/Cmd Line (Typically);DolDoc/Cmd Line (Typically);"\
+	"StdOut;Cmd Line (Typically)"
+public Bool Type(U8 *filename,I64 trailing_new_lines=1)
+{//Output txt or graphic file to command line.
+  return DocType(,filename,trailing_new_lines);
+}

TempleOSCD/Adam/DolDoc/DocFind.HC

@@ -0,0 +1,584 @@
+#help_index "DolDoc/Editor"
+
+public Bool DocLineNumGoTo(CDoc *doc,I64 line_num) //one based
+{//Nearest to specified line num.  Move cur_entry & center.
+  Bool res=FALSE,unlock;
+  if (doc) {
+    unlock=DocLock(doc);
+    doc->x=0;
+    doc->y=line_num-1;
+    DocRecalc(doc,RECALCt_FIND_CURSOR);
+    DocCenter(doc);
+    if (doc->cur_entry->y==line_num-1)
+      res=TRUE;
+    if (unlock)
+      DocUnlock(doc);
+  }
+  return res;
+}
+
+public Bool DocFind(CDoc *haystack_doc,I64 start_line_num=I64_MIN,
+U8 *needle,I64 match=1)
+{//Find str by searching tags. Move cur_entry & center.
+  Bool res=FALSE,unlock;
+  CDocEntry *doc_e;
+  U8 *ptr;
+  I64 i;
+  if (haystack_doc) {
+    unlock=DocLock(haystack_doc);
+    if (start_line_num==I64_MIN) {
+      res=TRUE;
+      doc_e=haystack_doc->head.next;
+    } else {
+      res=DocLineNumGoTo(haystack_doc,start_line_num);
+      doc_e=haystack_doc->cur_entry;
+    }
+    if (res) {
+      if (needle) {
+	res=FALSE;
+	while (doc_e!=haystack_doc) {
+	  if (doc_e->de_flags&DOCEF_TAG && doc_e->tag &&
+//TODO: handle multi-DocEntry strs
+		(ptr=StrIMatch(needle,doc_e->tag))) {
+	    i=ptr-doc_e->tag;
+	    if (!--match) {
+	      haystack_doc->cur_entry=doc_e;
+	      if (i<doc_e->min_col) i=doc_e->min_col;
+	      if (i>doc_e->max_col) i=doc_e->max_col;
+	      haystack_doc->cur_col=i;
+	      res=TRUE;
+	      break;
+	    }
+	  }
+	  doc_e=doc_e->next;
+	}
+      } else
+	res=FALSE;
+    }
+    if (!res) DocBottom(haystack_doc);
+    DocCenter(haystack_doc);
+    if (unlock)
+      DocUnlock(haystack_doc);
+  }
+  return res;
+}
+
+public Bool DocAnchorFind(CDoc *haystack_doc,U8 *needle_str)
+{//Find named anchor. Move cur_entry & center.
+  Bool res=FALSE,unlock;
+  CDocEntry *doc_e;
+  if (haystack_doc) {
+    unlock=DocLock(haystack_doc);
+    doc_e=haystack_doc->head.next;
+    if (needle_str)
+      while (doc_e!=haystack_doc) {
+	if (doc_e->type_u8==DOCT_ANCHOR && doc_e->de_flags & DOCEF_AUX_STR) {
+	  if (!StrCmp(needle_str,doc_e->aux_str)) {
+	    haystack_doc->cur_entry=doc_e;
+	    haystack_doc->cur_col=doc_e->min_col;
+	    res=TRUE;
+	    break;
+	  }
+	}
+	doc_e=doc_e->next;
+      }
+    if (!res) DocBottom(haystack_doc);
+    DocCenter(haystack_doc);
+    if (unlock)
+      DocUnlock(haystack_doc);
+  }
+  return res;
+}
+
+public U0 EdFindNext(CDoc *doc)
+{//Editor F3 find next, possibly doing replaces.
+  Bool unlock=DocLock(doc);
+  U8 *ptr,*ptr2,*ptr3;
+  CDocEntry *doc_ce=doc->cur_entry,*doc_e=doc_ce;
+  I64 sf_flags;
+  if (doc->find_replace->match_case)
+    sf_flags=0;
+  else
+    sf_flags=SFF_IGNORE_CASE;
+  if (doc->find_replace->whole_labels)
+    sf_flags|=SFG_WHOLE_LABELS;
+  do {
+    if (doc_e!=doc) {
+      if (doc_e->de_flags&DOCEF_TAG && doc_e->tag &&
+	    !(doc_e->de_flags&(DOCEG_DONT_EDIT|DOCEF_FILTER_SKIP))) {
+	if (doc_e->type & DOCET_SEL ||
+	      !doc->find_replace->scan_sel_text) {
+	  if (doc->find_replace->scan_fwd) {
+	    if (doc_e==doc_ce) {
+	      ptr=doc_ce->tag+doc->cur_col+1;
+	      if (ptr-doc_ce->tag>=doc_ce->max_col)
+		goto fn_skip;
+	      if (ptr-doc_ce->tag<doc_ce->min_col)
+		ptr=doc_ce->tag+doc_ce->min_col;
+	    } else
+	      ptr=doc_e->tag;
+	    if (ptr=StrFind(doc->find_replace->find_text,ptr,sf_flags)) {
+	      doc->cur_entry=doc_e;
+	      doc->cur_col=ptr-doc_e->tag;
+	      if (doc->cur_col>=doc_e->max_col)
+		doc->cur_col=doc_e->max_col-1;
+	      if (doc->cur_col<doc_e->min_col)
+		doc->cur_col=doc_e->min_col;
+	      DocCenter(doc);
+	      if (unlock)
+		DocUnlock(doc);
+	      return;
+	    }
+	  } else {
+	    ptr2=NULL;
+	    ptr=doc_e->tag+doc_e->min_col;
+	    if (doc_e==doc_ce)
+	      ptr3=doc_ce->tag+doc->cur_col;
+	    else
+	      ptr3=doc_e->tag+doc_e->max_col;
+	    while (ptr=StrFind(doc->find_replace->find_text,ptr,sf_flags)) {
+	      if (ptr>=ptr3)
+		break;
+	      ptr2=ptr++;
+	    }
+	    if (ptr2 && ptr2<ptr3) {
+	      doc->cur_entry=doc_e;
+	      doc->cur_col=ptr2-doc_e->tag;
+	      if (doc->cur_col>=doc_e->max_col)
+		doc->cur_col=doc_e->max_col-1;
+	      if (doc->cur_col<doc_e->min_col)
+		doc->cur_col=doc_e->min_col;
+	      DocCenter(doc);
+	      if (unlock)
+		DocUnlock(doc);
+	      return;
+	    }
+	  }
+	}
+      }
+    }
+fn_skip:
+    if (doc->find_replace->scan_fwd)
+      doc_e=doc_e->next;
+    else
+      doc_e=doc_e->last;
+  } while (doc_e!=doc_ce);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 EdSelAll(CDoc *doc,Bool sel)
+{//Set state of $LK,"DOCET_SEL",A="MN:DOCET_SEL"$ on all entries.
+  Bool unlock=DocLock(doc);
+  CDocEntry *doc_e=doc->head.next;
+  while (doc_e!=doc) {
+    BEqu(&doc_e->type,DOCEt_SEL,sel);
+    doc_e=doc_e->next;
+  }
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public Bool EdFindPaired(CDoc *doc,U8 plus,U8 minus,
+Bool fwd,Bool abort_on_dbl_colon=FALSE)
+{//Find { } or ( ) pair. Move cur_entry & center.
+  Bool unlock=DocLock(doc),res=FALSE;
+  U8 *ptr;
+  I64 ch,levels=0,colons=0,original_col=doc->cur_col;
+  CDocEntry *doc_ce=doc->cur_entry,*doc_e=doc_ce,*original_ce=doc_ce;
+  if (abort_on_dbl_colon && EdCurU8(doc)==':')
+    colons=1;
+  else
+    colons=0;
+  do {
+    if (doc_e!=doc) {
+      if (doc_e->de_flags&DOCEF_TAG && doc_e->tag &&
+	    !(doc_e->de_flags&DOCEF_FILTER_SKIP)) {
+	if (fwd) {
+	  if (doc_e==doc_ce)
+	    ptr=doc_e->tag+doc->cur_col+1;
+	  else
+	    ptr=doc_e->tag;
+	  if (ptr-doc_e->tag<doc_e->min_col)
+	    ptr=doc_e->tag+doc_e->min_col;
+	  if (ptr-doc_e->tag>=doc_e->max_col)
+	    goto pa_skip;
+	  while (ch=*ptr++)
+	    if (abort_on_dbl_colon && ch==':') {
+	      if (++colons==2) {
+		doc->cur_entry=doc_e;
+		doc->cur_col=ptr-doc_e->tag-1;
+		EdCursorLeft(doc);
+		res=FALSE;
+		goto pa_done;
+	      }
+	    } else {
+	      colons=0;
+	      if (ch==plus)
+		levels++;
+	      else if (ch==minus) {
+		if (!levels--) {
+		  doc->cur_entry=doc_e;
+		  doc->cur_col=ptr-doc_e->tag-1;
+		  res=doc->cur_entry!=original_ce ||
+			doc->cur_col!=original_col;
+		  goto pa_done;
+		}
+	      }
+	    }
+	} else {
+	  if (doc_e==doc_ce) {
+	    ptr=doc_e->tag+doc->cur_col-1;
+	    if (ptr-doc_e->tag>=doc_e->max_col)
+	      ptr=doc_e->tag+doc_e->max_col-1;
+	  } else
+	    ptr=doc_e->tag+doc_e->max_col-1;
+	  if (ptr-doc_e->tag<doc_e->min_col)
+	    goto pa_skip;
+	  while (ptr>=doc_e->tag+doc_e->min_col) {
+	    ch=*ptr--;
+	    if (abort_on_dbl_colon && ch==':') {
+	      if (++colons==2) {
+		doc->cur_entry=doc_e;
+		doc->cur_col=ptr-doc_e->tag+1;
+		res=FALSE;
+		goto pa_done;
+	      }
+	    } else {
+	      colons=0;
+	      if (ch==plus)
+		levels++;
+	      else if (ch==minus) {
+		if (!levels--) {
+		  doc->cur_entry=doc_e;
+		  doc->cur_col=ptr-doc_e->tag+1;
+		  res=doc->cur_entry!=original_ce ||
+			doc->cur_col!=original_col;
+		  goto pa_done;
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    }
+pa_skip:
+    if (fwd)
+      doc_e=doc_e->next;
+    else
+      doc_e=doc_e->last;
+  } while (doc_e!=doc_ce);
+pa_done:
+  DocRecalc(doc);
+  DocCenter(doc);
+  if (unlock)
+    DocUnlock(doc);
+  return res;
+}
+
+public Bool EdGoToFun(CDoc *doc,Bool fwd,Bool abort_on_dbl_colon)
+{//Move cur_entry to start of cur fun and center.(Shoddy)
+  Bool unlock=DocLock(doc),res=FALSE;
+  I64 ch,levels,colons;
+  if (fwd) {
+    levels=0;
+    colons=0;
+    while (doc->cur_entry!=doc) {
+      ch=EdCurU8(doc);
+      if (abort_on_dbl_colon && ch==':') {
+	if (++colons==2) {
+	  EdCursorLeft(doc);
+	  break;
+	}
+      } else {
+	colons=0;
+	if (ch=='{')
+	  levels++;
+	else if (ch=='}' && !levels--)
+	  break;
+      }
+      EdCursorRight(doc);
+    }
+    DocRecalc(doc);
+    if (doc->cur_entry!=doc)
+      res=TRUE;
+  } else {
+    while (EdFindPaired(doc,'}','{',FALSE,abort_on_dbl_colon));
+    if (doc->cur_entry!=doc) {
+      ch=EdCurU8(doc);
+      if (abort_on_dbl_colon && ch==':')
+	res=TRUE;
+      else {
+	if (ch=='{')
+	  res=TRUE;
+      }
+    }
+  }
+  if (unlock)
+    DocUnlock(doc);
+  return res;
+}
+
+public U0 EdSelFun(CDoc *doc,Bool abort_on_dbl_colon=FALSE)
+{//Set $LK,"DOCET_SEL",A="MN:DOCET_SEL"$ on all entries in cur fun.
+  Bool unlock=DocLock(doc);
+  U8 *ptr;
+  I64 ch,levels=0,colons=0;
+  CDocEntry *doc_e;
+  EdSelAll(doc,FALSE);
+  EdGoToFun(doc,FALSE,abort_on_dbl_colon);
+  if (EdCurU8(doc)=='{')
+    levels--;
+  else if (abort_on_dbl_colon && EdCurU8(doc)==':') {
+    EdCursorRight(doc);
+    if (EdCurU8(doc)==':')
+      EdCursorRight(doc);
+  }
+  doc_e=doc->cur_entry;
+  while (doc_e!=doc) {
+    doc_e->type|=DOCET_SEL;
+    if (doc_e->de_flags&DOCEF_TAG && doc_e->tag) {
+      ptr=doc_e->tag;
+      if (doc_e==doc->cur_entry)
+	ptr+=doc->cur_col;
+      while (ch=*ptr++)
+	if (abort_on_dbl_colon && ch==':') {
+	  if (++colons==2)
+	    goto sf_done;
+	} else {
+	  colons=0;
+	  if (ch=='{')
+	    levels++;
+	  else if (ch=='}' && !levels--)
+	    goto sf_done;
+	}
+    }
+    doc_e=doc_e->next;
+  }
+sf_done:
+  DocRecalc(doc);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+#define RSAC_REPLACE	0
+#define RSAC_SKIP	1
+#define RSAC_ALL	2
+
+I64 PopUpReplaceSkipAllCancel(U8 *header=NULL,U8 *footer=NULL)
+{
+  I64 i;
+  CDoc *doc=DocNew;
+  if (header) DocPrint(doc,"%s",header);
+  DocPrint(doc,"$$CM+LX,1,4$$$$BT,\"REPLACE\",LE=RSAC_REPLACE$$"
+	"$$CM+LX,17,0$$$$BT,\"SKIP\",LE=RSAC_SKIP$$"
+	"$$CM+LX,1,3$$$$BT,\"ALL\",LE=RSAC_ALL$$"
+	"$$CM+LX,17,0$$$$BT,\"CANCEL\",LE=DOCM_CANCEL$$\n");
+  if (footer) DocPrint(doc,"%s",footer);
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i;
+}
+
+I64 EdFindReplace(CDoc *doc)
+{
+  Bool found,unlock;
+  I64 cmd,i,j,plen,rlen,dlen,res=-1,sf_flags;
+  U8 *src,*dst,*dst2;
+  CDocEntry *doc_ce,*doc_e,*doc_marker=NULL;
+  if (doc->find_replace->pmt)
+    cmd=RSAC_REPLACE;
+  else
+    cmd=RSAC_ALL;
+  if (!doc->find_replace->pmt || DocForm(doc->find_replace)) {
+    res=0;
+    unlock=DocLock(doc);
+    if (doc->find_replace->match_case || doc->find_replace->local_var)
+      sf_flags=0;
+    else
+      sf_flags=SFF_IGNORE_CASE;
+    if (doc->find_replace->whole_labels || doc->find_replace->local_var)
+      sf_flags|=SFG_WHOLE_LABELS;
+
+    if (i=doc->find_replace->filter_lines) {
+      doc_ce=doc->head.next;
+      while (doc_ce!=doc) {
+	if (doc_ce->de_flags&DOCEF_TAG && doc_ce->tag &&
+	      !(doc_ce->de_flags&DOCEF_FILTER_SKIP) &&
+	      StrFind(doc->find_replace->find_text,doc_ce->tag,sf_flags)) {
+	  doc_ce->type|=DOCET_SEL;
+	  res++;
+	} else
+	  doc_ce->type&=~DOCET_SEL;
+	doc_ce=doc_ce->next;
+      }
+
+      doc_ce=doc->head.next;
+      while (doc_ce!=doc) {
+	if (!(doc_ce->de_flags&DOCEF_FILTER_SKIP)) {
+	  found=FALSE;
+
+	  doc_e=doc_ce;
+	  while (doc_e!=doc && doc_e->y>doc_ce->y-i) {
+	    if (doc_e->type&DOCET_SEL) {
+	      found=TRUE;
+	      break;
+	    } else
+	      doc_e=doc_e->last;
+	  }
+
+	  if (!found) {
+	    doc_e=doc_ce;
+	    while (doc_e!=doc && doc_e->y<doc_ce->y+i) {
+	      if (doc_e->type&DOCET_SEL) {
+		found=TRUE;
+		break;
+	      } else
+		doc_e=doc_e->next;
+	    }
+	  }
+
+	  if (!found)
+	    doc_ce->de_flags|=DOCEF_FILTER_SKIP;
+	}
+
+	doc_ce=doc_ce->next;
+      }
+      EdSelAll(doc,FALSE);
+      goto fr_unlock_done;
+    }
+
+    if (doc->find_replace->local_var)
+      EdSelFun(doc);
+
+    if (!doc->find_replace->replace && !doc->find_replace->local_var) {
+      EdFindNext(doc);
+      goto fr_unlock_done;
+    }
+    plen=StrLen(doc->find_replace->find_text);
+    if (!plen)
+      goto fr_unlock_done;
+    rlen=StrLen(doc->find_replace->replace_text);
+    if (doc->head.next!=doc) {
+      doc_e=doc_marker=DocSplitTag(doc,doc->cur_entry,doc->cur_col,
+	    doc->cur_entry->x+doc->cur_col,doc->cur_entry->y,DOCT_MARKER);
+      do {
+	if (doc_e==doc) {
+	  if (doc->find_replace->scan_fwd)
+	    doc_e=doc_e->next;
+	  else
+	    doc_e=doc_e->last;
+	  if (doc_e==doc_marker)
+	    break;
+	}
+	if (doc_e->type_u8==DOCT_TEXT &&
+	      !(doc_e->de_flags&(DOCEG_DONT_EDIT|DOCEF_FILTER_SKIP)) &&
+	      (doc_e->type & DOCET_SEL ||
+	      !doc->find_replace->scan_sel_text&&
+	      !doc->find_replace->local_var)) {
+	  src=doc_e->tag;
+	  while (src) {
+	    src=StrFind(doc->find_replace->find_text,src,sf_flags);
+	    if (src) {
+	      doc->cur_col=src-doc_e->tag;
+	      doc->cur_entry=doc_e;
+	      if (cmd!=RSAC_ALL)
+		DocCenter(doc);
+	      if (cmd!=RSAC_ALL) {
+		DocUnlock(doc);
+		cmd=PopUpReplaceSkipAllCancel("");
+		DocLock(doc);
+		if (cmd<0)
+		  goto fr_unlock_done;
+	      }
+	      doc_e=doc->cur_entry;
+	      src=doc->cur_col+doc_e->tag;
+	      if (cmd==RSAC_REPLACE || cmd==RSAC_ALL) {
+		dlen=StrLen(doc_e->tag);
+		doc_e->max_col=dlen+rlen-plen;
+		dst=MAlloc(doc_e->max_col+1,doc->mem_task);
+		dst2=dst;
+		j=src-doc_e->tag;
+		for (i=0;i<j;i++)
+		  *dst++=doc_e->tag[i];
+		for (i=0;i<rlen;i++)
+		  *dst++=doc->find_replace->replace_text[i];
+		src=dst;
+		for (i=j+plen;i<=dlen;i++)
+		  *dst++=doc_e->tag[i];
+		Free(doc_e->tag);
+		doc_e->tag=dst2;
+		doc->cur_col=src-doc_e->tag;
+		doc->cur_entry=doc_e;
+		if (cmd!=RSAC_ALL) {
+		  DocRemSoftNewLines(doc,doc->cur_entry);
+		  DocRecalc(doc);
+		}
+		doc_e=doc->cur_entry;
+		src=doc->cur_col+doc_e->tag;
+		res++;
+	      } else
+		src++;
+	    }
+	  }
+	}
+	if (doc->find_replace->scan_fwd)
+	  doc_e=doc_e->next;
+	else
+	  doc_e=doc_e->last;
+      } while (doc_e!=doc_marker);
+    }
+fr_unlock_done:
+    if (doc_marker)
+      DocEntryDel(doc,doc_marker);
+    DocRemSoftNewLines(doc,NULL);
+    DocRecalc(doc);
+    DocCenter(doc);
+    if (unlock)
+      DocUnlock(doc);
+  }
+  return res;
+}
+
+public I64 EdReplace(CDoc *doc,U8 *find,U8 *replace,
+Bool sel=TRUE,Bool match_case=TRUE,Bool whole_labels=FALSE)
+{//Find & replace using editor's cmd.
+  CEdFindText old_find_replace;
+  Bool unlock;
+  I64 i,res=-1;
+  if (!doc) return -1;
+  unlock=DocLock(doc);
+  MemCpy(&old_find_replace,doc->find_replace,sizeof(CEdFindText));
+  MemSet(doc->find_replace,0,sizeof(CEdFindText));
+  i=StrLen(find);
+  if (i<sizeof(CEdFindText.find_text)) {
+    MemCpy(doc->find_replace->find_text,find,i+1);
+    i=StrLen(replace);
+    if (i<sizeof(CEdFindText.replace_text)) {
+      MemCpy(doc->find_replace->replace_text,replace,i+1);
+      doc->find_replace->replace=TRUE;
+      doc->find_replace->scan_sel_text=sel;
+      doc->find_replace->match_case=match_case;
+      doc->find_replace->whole_labels=whole_labels;
+      doc->find_replace->pmt=FALSE;
+      res=EdFindReplace(doc);
+    }
+  }
+  MemCpy(doc->find_replace,&old_find_replace,sizeof(CEdFindText));
+  if (unlock)
+    DocUnlock(doc);
+  return res;
+}
+
+class CEdLineGoTo
+{
+  I64 line fmtstr "$$DA,A=\"Go to Line:%d\"$$";
+};
+
+U0 EdGoToLine(CDoc *doc)
+{//Prompt with form and go to line num.
+  CEdLineGoTo gtl;
+  gtl.line=1;
+  if (DocForm(&gtl))
+    DocLineNumGoTo(doc,gtl.line);
+}

TempleOSCD/Adam/DolDoc/DocForm.HC

@@ -0,0 +1,344 @@
+#help_index "DolDoc/Form"
+
+U0 DocFormFwd(CDoc *doc,Bool giveup=FALSE)
+{
+  CDocEntry *doc_e=doc->cur_entry,*doc_e2=doc_e;
+  if (doc->flags & DOCF_FORM) {
+    if (doc_e==doc) goto ff_recover;
+    while (!Bt(doldoc.type_flags_form,doc_e->type_u8) &&
+	  !(doc_e->de_flags&DOCEF_LINK) ||
+	  doc_e->de_flags&DOCEF_SKIP_IN_FORM) {
+      doc_e=doc_e->next;
+      if (doc_e==doc) {
+ff_recover:
+	doc->cur_col=0;
+	if (!giveup) {
+	  doc->cur_entry=doc_e->last;
+	  DocFormBwd(doc,TRUE);
+	} else
+	  doc->cur_entry=doc;
+	return;
+      }
+    }
+  }
+  while (doc_e->type_u8==DOCT_INDENT)
+    doc_e=doc_e->next;
+  if (doc_e!=doc_e2) {
+    doc->cur_col=doc_e->min_col;
+    doc->cur_entry=doc_e;
+  }
+}
+
+U0 DocFormBwd(CDoc *doc,Bool giveup=FALSE)
+{
+  CDocEntry *doc_e=doc->cur_entry,*doc_e2=doc_e;
+  if (doc->flags & DOCF_FORM) {
+    while (!Bt(doldoc.type_flags_form,doc_e->type_u8) &&
+	  !(doc_e->de_flags&DOCEF_LINK) ||
+	  doc_e->de_flags&DOCEF_SKIP_IN_FORM) {
+      doc_e=doc_e->last;
+      if (doc_e==doc) {
+	doc->cur_col=0;
+	if (!giveup) {
+	  doc->cur_entry=doc_e->next;
+	  DocFormFwd(doc,TRUE);
+	} else
+	  doc->cur_entry=doc;
+	return;
+      }
+    }
+  }
+  while (doc_e->type_u8==DOCT_INDENT)
+    doc_e=doc_e->next;
+  if (doc_e!=doc_e2) {
+    doc->cur_col=doc_e->min_col;
+    doc->cur_entry=doc_e;
+  }
+}
+
+U0 DocDataFmt(CDoc *doc,CDocEntry *doc_e,I64 d=DOCM_CANCEL)
+{
+  I64 i;
+  U8 *ptr,*ptr2;
+  CHashDefineStr *tmph;
+  if (doc_e->type_u8==DOCT_DATA && doc_e->de_flags&DOCEF_AUX_STR ||
+	doc_e->type_u8==DOCT_CHECK_BOX || doc_e->de_flags & DOCEF_LST) {
+    if (d==DOCM_CANCEL) {
+      if (doc_e->de_flags&DOCEF_DEREF_DATA &&
+	    !(doc_e->de_flags&DOCEF_REMALLOC_DATA)) {
+	if (!(ptr=doc_e->data)) return;
+      } else
+	ptr=&doc_e->data;
+      switch (doc_e->raw_type) {
+	case RT_I0:
+	case RT_U0:	d=0;		break;
+	case RT_I8:	d=*ptr(I8 *);	break;
+	case RT_U8:	d=*ptr(U8 *);	break;
+	case RT_I16:	d=*ptr(I16 *);	break;
+	case RT_U16:	d=*ptr(U16 *);	break;
+	case RT_I32:	d=*ptr(I32 *);	break;
+	case RT_U32:	d=*ptr(U32 *);	break;
+	default:	d=*ptr(I64 *);
+      }
+    }
+    if (doc_e->type_u8==DOCT_DATA) {
+      if (doc_e->de_flags & DOCEF_REMALLOC_DATA) {
+	ptr=MStrPrint(doc_e->aux_str,d,doc_e->my_fmt_data);
+	i=StrLen(ptr);
+	if (!doc_e->data) {
+	  doc_e->data=CAlloc(2,doc->mem_task);
+	  doc_e->len=MSize(doc_e->data)-2;
+	}
+	if (doc_e->len+doc_e->min_col>i)
+	  MemCpy(doc_e->tag,ptr,i+1);
+	else {
+	  ptr2=MAlloc(i+8,doc->mem_task);
+	  doc_e->len=MSize(ptr2)-doc_e->min_col-2;	 //See $LK,"DataTagWidth",A="FA:::/Adam/DolDoc/DocPlain.HC,DataTagWidth"$
+	  MemCpy(ptr2,ptr,i+1);
+	  Free(doc_e->tag);
+	  doc_e->tag=ptr2;
+	}
+	Free(ptr);
+      } else {
+	StrPrint(doc_e->tag,doc_e->aux_str,d,doc_e->my_fmt_data);
+	i=StrLen(doc_e->tag);
+      }
+      if (doc_e->de_flags & DOCEF_HAS_TERMINATOR) {
+	doc_e->tag[i++]='_';
+	doc_e->tag[i]=0;
+      }
+      doc_e->max_col=i;
+    } else if (doc_e->de_flags & DOCEF_LST) {
+      if (doc_e->de_flags & DOCEF_DEFINE && (tmph=HashFind(doc_e->define_str,
+	    doc->win_task->hash_table,HTT_DEFINE_STR)) && 0<=d<tmph->cnt) {
+	ptr=MStrPrint("[%s]",tmph->sub_idx[d]);
+	Free(doc_e->tag);
+	doc_e->tag=StrNew(ptr,doc->mem_task);
+	Free(ptr);
+      } else {
+	Free(doc_e->tag);
+	doc_e->tag=StrNew("[]",doc->mem_task);
+      }
+    } else {
+      if (d)
+	doc_e->de_flags|=DOCEF_CHECKED_COLLAPSED;
+      else
+	doc_e->de_flags&=~DOCEF_CHECKED_COLLAPSED;
+    }
+  }
+}
+
+U0 DocDataScan(CDoc *doc,CDocEntry *doc_e)
+{
+  I64 i,d;
+  U8 *ptr,*ptr1,*ptr2;
+  CHashDefineStr *tmph;
+  if (doc_e->type_u8==DOCT_DATA && doc_e->de_flags&DOCEF_AUX_STR ||
+	doc_e->type_u8==DOCT_CHECK_BOX || doc_e->de_flags & DOCEF_LST) {
+    if (doc_e->de_flags&DOCEF_DEREF_DATA &&
+	  !(doc_e->de_flags&DOCEF_REMALLOC_DATA)) {
+      if (!(ptr=doc_e->data)) return;
+    } else
+      ptr=&doc_e->data;
+    if (doc_e->type_u8==DOCT_DATA) {
+      i=StrLen(doc_e->tag);
+      if (doc_e->de_flags & DOCEF_HAS_TERMINATOR)
+	doc_e->tag[--i]=0;
+      if (i>doc_e->len+doc_e->min_col)
+	doc_e->tag[doc_e->len+doc_e->min_col]=0;
+      if (RT_I8<=doc_e->raw_type<=RT_U32) {
+	StrScan(doc_e->tag,doc_e->aux_str,&d,doc_e->my_fmt_data);
+	if (doc_e->de_flags & DOCEF_HAS_TERMINATOR)
+	  doc_e->tag[i]='_';
+      } else if (RT_I64<=doc_e->raw_type<=RT_UF64) {
+	if (doc_e->de_flags & DOCEF_REMALLOC_DATA) {
+	  ptr=MAlloc(i-doc_e->min_col+8,doc->mem_task);
+	  MemCpy(ptr,doc_e->tag+doc_e->min_col,i-doc_e->min_col+1);
+	  Free(doc_e->data);
+	  doc_e->data=ptr;
+	  doc_e->len=MSize(ptr)-1;
+	} else
+	  StrScan(doc_e->tag,doc_e->aux_str,ptr,doc_e->my_fmt_data);
+	if (doc_e->de_flags & DOCEF_HAS_TERMINATOR)
+	  doc_e->tag[i]='_';
+	return;
+      }
+    } else if (doc_e->de_flags & DOCEF_LST) {
+      d=0;
+      if (doc_e->tag && doc_e->de_flags & DOCEF_DEFINE &&
+	    (tmph=HashFind(doc_e->define_str,
+	    doc->win_task->hash_table,HTT_DEFINE_STR))) {
+	ptr1=ptr2=StrNew(doc_e->tag);
+	if (*ptr2=='[') {
+	  ptr2++;
+	  i=StrLen(ptr2);
+	  if (ptr2[i-1]==']')
+	    ptr2[i-1]=0;
+	}
+	d=LstMatch(ptr2,tmph->data);
+	Free(ptr1);
+      }
+    } else {
+      if (doc_e->de_flags & DOCEF_CHECKED_COLLAPSED)
+	d=TRUE;
+      else
+	d=FALSE;
+    }
+    switch (doc_e->raw_type) {
+      case RT_I8:
+      case RT_U8:
+	*ptr(U8 *)=d;
+      case RT_I0:
+      case RT_U0:
+	break;
+      case RT_I16:
+      case RT_U16:
+	*ptr(U16 *)=d;
+	break;
+      case RT_I32:
+      case RT_U32:
+	*ptr(U32 *)=d;
+	break;
+      default:
+	*ptr(I64 *)=d;
+    }
+  }
+}
+
+#help_index "DolDoc/Input;StdIn/DolDoc"
+public Bool DocForm(U8 *_d,U8 *class_name=lastclass,
+    I64 dof_flags=0,U8 *header=NULL,U8 *footer=NULL)
+{//User input. Supply a class name that has fmtstr definitions.
+//See $LK,"::/Demo/DolDoc/Form.HC"$ and $LK,"::/Demo/LastClass.HC"$.
+  CMemberLst *ml;
+  CDocEntry *doc_e;
+  U8 *fmtstr;
+  CHashClass *tmpc,*tmpc2;
+  CDoc *doc;
+  Bool res=FALSE;
+  I64 old_border_src=Fs->border_src,has_action;
+  if (!(tmpc=HashFind(class_name,Fs->hash_table,HTT_CLASS)))
+    return FALSE;
+  doc=DocNew;
+  doc->desc='Form';
+  if (header) DocPrint(doc,"%s",header);
+  doc->flags|=DOCF_OVERSTRIKE|DOCF_FORM;
+  if (dof_flags&DOF_SIZE_MIN)
+    doc->flags|=DOCF_SIZE_MIN;
+  ml=tmpc->member_lst_and_root;
+  while (ml) {
+    if ((fmtstr=MemberMetaData("fmtstr",ml)) &&
+	  (doc_e=DocPrint(doc,"%s",fmtstr))) {
+      tmpc2=ml->member_class;
+      if ((doc_e->type_u8==DOCT_DATA || doc_e->type_u8==DOCT_LST ||
+	    doc_e->type_u8==DOCT_CHECK_BOX) && !tmpc2->ptr_stars_cnt) {
+	tmpc2=OptClassFwd(tmpc2);
+	tmpc2-=tmpc2->ptr_stars_cnt;
+	if (tmpc2->type & HTT_INTERNAL_TYPE) {
+	  if (ml->dim.next) { //Array
+	    if (tmpc2->raw_type==RT_U8 &&
+		  LBtr(&doc_e->de_flags,&DOCEf_DFT_LEN)) {
+	      doc_e->len=ml->dim.total_cnt;
+	      if (doc_e->de_flags&DOCEF_HAS_TERMINATOR)
+		doc_e->len--;
+	      Free(doc_e->tag);  //See $LK,"DataTagWidth",A="FA:::/Adam/DolDoc/DocPlain.HC,DataTagWidth"$
+	      doc_e->tag=MAlloc(doc_e->len+doc_e->min_col+2,
+		    doc->mem_task); //+2 because "_\0"
+	    }
+	  } else if (LBtr(&doc_e->de_flags,DOCEf_DFT_RAW_TYPE))
+	    doc_e->raw_type=tmpc2->raw_type;
+	}
+      }
+      if (doc_e->de_flags&DOCEF_REMALLOC_DATA) {
+	doc_e->user_data=_d+ml->offset;
+	doc_e->data=*doc_e->user_data(U8 **);
+      } else
+	doc_e->data=_d+ml->offset;
+      doc_e->my_fmt_data=MemberMetaData("fmtdata",ml);
+      DocDataFmt(doc,doc_e);
+    }
+    ml=ml->next;
+  }
+  if (footer) DocPrint(doc,"%s",footer);
+  if (doc->head.next!=doc)	{
+    Fs->border_src=BDS_CONST;
+    DocRecalc(doc);
+    if (DocEd(doc,dof_flags)) {
+      doc_e=doc->cur_entry;
+      res=TRUE;
+      if (doc_e!=doc) {
+	if (DocEntryRun(doc,doc_e,TRUE,&has_action)==DOCM_CANCEL && has_action)
+	  res=FALSE;
+	DocUnlock(doc);
+      }
+    }
+  }
+  doc_e=doc->head.next;
+  while (doc_e!=doc) {
+    if (doc_e->de_flags&DOCEF_REMALLOC_DATA) {
+      *doc_e->user_data(U8 **)=doc_e->data;
+      doc_e->data=NULL;
+    }
+    doc_e=doc_e->next;
+  }
+  DocDel(doc);
+  Fs->border_src=old_border_src;
+  return res;
+}
+
+U0 DocMenuEndTaskCB()
+{
+  WinToTop;
+  throw;
+}
+
+public I64 DocMenu(CDoc *m,I64 dof_flags=0)
+{//Run menu chooser doc. Returns menu doc unlocked.
+  U8 *old_end_cb=Fs->task_end_cb;
+  Bool old_break_shift_esc=LBts(&Fs->task_flags,TASKf_BREAK_TO_SHIFT_ESC);
+  CDocEntry *doc_e;
+  I64 old_border_src=Fs->border_src,res=DOCM_CANCEL,has_action;
+  Fs->task_end_cb=&DocMenuEndTaskCB;
+  try {
+    if (m) {
+      m->desc='Menu';
+      Fs->border_src=BDS_CONST;
+dm_restart:
+      if (DocEd(m,dof_flags)) {
+	doc_e=m->cur_entry;
+	if (doc_e!=m) {
+	  res=DocEntryRun(m,doc_e,TRUE,&has_action);
+	  DocUnlock(m);
+	  if (!has_action) {
+	    res=DOCM_CANCEL;
+	    dof_flags|=DOF_DONT_HOME;
+	    goto dm_restart;
+	  }
+	}
+      }
+    }
+  } catch {
+    if (!Fs->except_ch) {
+      if (!(dof_flags & DOF_INTERCEPT_TASK_END))
+	Exit;
+      Fs->catch_except=TRUE;
+    }
+  }
+  LBEqu(&Fs->task_flags,TASKf_BREAK_TO_SHIFT_ESC,old_break_shift_esc);
+  Fs->border_src=old_border_src;
+  Fs->task_end_cb=old_end_cb;
+  return res;
+}
+
+public I64 PopUpMenu(CDoc *doc,I64 dof_flags=0)
+{//Run menu chooser doc in PopUp win task.
+  doc->flags|=DOCF_SIZE_MIN | DOCF_FORM;
+  return PopUpPrint("DocMenu(0x%X,0x%X);",doc,dof_flags);
+}
+
+public Bool PopUpForm(U8 *_d,U8 *class_name=lastclass,
+	I64 dof_flags=DOF_SIZE_MIN,U8 *header=NULL,U8 *footer=NULL)
+{//See $LK,"::/Demo/DolDoc/Form.HC"$ and $LK,"::/Demo/LastClass.HC"$.
+  return PopUpPrint("DocForm(0x%X,0x%X,0x%X,0x%X,0x%X);",_d,class_name,
+	dof_flags,header,footer);
+}

TempleOSCD/Adam/DolDoc/DocGet.HC

@@ -0,0 +1,224 @@
+#help_index "DolDoc"
+
+U0 EdUndoFilter(CDoc *doc)
+{
+  Bool unlock=DocLock(doc);
+  CDocEntry *doc_ce=doc->head.next;
+  while (doc_ce!=doc) {
+    doc_ce->de_flags&=~DOCEF_FILTER_SKIP;
+    doc_ce=doc_ce->next;
+  }
+  doc->find_replace->filter_lines=0;
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public I64 DocGetKey(I64 *_sc=NULL)
+{//Called by $LK,"View",A="MN:View"$. You probably don't need this.
+  I64 ch,sc;
+  Bool cont,old_key_desc;
+  do {
+    old_key_desc=LBtr(&Fs->win_inhibit,WIf_SELF_KEY_DESC);
+    do ch=GetKey(&sc,TRUE);
+    while (sc&SCF_KEY_DESC);
+    LBEqu(&Fs->win_inhibit,WIf_SELF_KEY_DESC,old_key_desc);
+
+    DocRecalc(DocPut);
+    cont=FALSE;
+    if ((ch==CH_ESC || ch==CH_SHIFT_ESC) && //Check for exit filter mode
+	  DocPut && DocPut->find_replace->filter_lines) {
+      EdUndoFilter(DocPut);
+      cont=TRUE;
+    }
+  } while (cont);
+  if (_sc) *_sc=sc;
+  return ch;
+}
+
+#help_index "DolDoc/Input;StdIn/DolDoc"
+public U8 *DocScanLine(CDoc *doc,CDocEntry *doc_e,
+	I64 *cur_col=NULL,CDocEntry **_do_e_end=NULL)
+{//Start at entry in doc,make and return one line as str.
+  CDocEntry *doc_e2=doc_e;
+  Bool unlock=DocLock(doc);
+  U8 *dst,*src,*start,*res;
+  I64 i=0;
+  if (cur_col)
+    *cur_col=-1;
+  while (doc_e2!=doc && doc_e2->type_u8!=DOCT_NEW_LINE) {
+    if (doc_e2->de_flags&DOCEF_TAG && doc_e2->tag) {
+      src=doc_e2->tag;
+      i+=StrLen(src);
+    } else if (doc_e2->type_u8==DOCT_TAB)
+      i++;
+    doc_e2=doc_e2->next;
+  }
+  res=MAlloc(i+1);
+  dst=res;
+  while (doc_e!=doc && doc_e->type_u8!=DOCT_NEW_LINE) {
+    start=dst;
+    if (doc_e->de_flags&DOCEF_TAG && doc_e->tag) {
+      src=doc_e->tag;
+      while (*src)
+	*dst++=*src++;
+    } else if (doc_e->type_u8==DOCT_TAB)
+      *dst++='\t';
+    if (doc_e==doc->cur_entry && cur_col)
+      *cur_col=start-res+doc->cur_col;
+    doc_e=doc_e->next;
+  }
+  if (_do_e_end) *_do_e_end=doc_e;
+  *dst=0;
+  if (doc_e==doc->cur_entry && cur_col && !doc->cur_col)
+    *cur_col=dst-res;
+  if (unlock)
+    DocUnlock(doc);
+  return res;
+}
+
+U8 *DocGetStr2(I64 flags=0)
+{//$LK,"Flags",A="MN:GSF_SHIFT_ESC_EXIT"$
+  CDoc *doc;
+  CDocEntry *doc_e,*doc_e_end;
+  U8 *st,*st2,*res;
+  I64 ch,sc;
+  "$$PT$$";
+  do {
+    ch=DocGetKey(&sc);
+    if (ch==CH_ESC) {
+      if (doc=DocPut) {
+	DocLock(doc);
+	if (doc->doc_signature==DOC_SIGNATURE_VAL && doc->cur_entry!=doc) {
+	  doc_e=DocEntryCopy(doc,doc->cur_entry);
+	  DocBottom(doc);
+	  DocEntryRun(doc,doc_e,TRUE);
+	  DocEntryDel(doc,doc_e);
+	}
+	DocUnlock(doc);
+      }
+      if (flags&GSF_WITH_NEW_LINE)
+	break;
+    } if (ch==CH_SHIFT_ESC) {
+      if (flags&GSF_SHIFT_ESC_EXIT)
+	Exit;
+      else {
+	res=StrNew("");
+	goto gs_done;
+      }
+    }
+//<CTRL-SHIFT-ENTER> is a blank line without entry
+  } while (flags&GSF_WITH_NEW_LINE || ch!='\n' ||
+	sc&SCF_CTRL && sc&SCF_SHIFT);
+
+  doc=DocPut;
+  DocLock(doc);
+  if (flags&GSF_WITH_NEW_LINE) {
+    doc_e=doc->cur_entry;
+    do doc_e=doc_e->last;
+    while (doc_e!=doc && doc_e->type_u8!=DOCT_PMT);
+    doc_e=doc_e->next;
+    if (res=DocScanLine(doc,doc_e,NULL,&doc_e_end)) {
+      while (doc_e_end!=doc && doc_e_end->type_u8==DOCT_NEW_LINE) {
+	st2=MStrPrint("%s\n",res);
+	Free(res);
+	res=st2;
+	if (st=DocScanLine(doc,doc_e_end->next,NULL,&doc_e_end)) {
+	  st2=MStrPrint("%s%s",res,st);
+	  Free(st);
+	  Free(res);
+	  res=st2;
+	}
+      }
+    }
+  } else {
+    doc_e=doc->cur_entry;
+    do doc_e=doc_e->last;
+    while (doc_e!=doc && doc_e->type_u8!=DOCT_NEW_LINE &&
+	  doc_e->type_u8!=DOCT_PMT);
+    if (doc_e!=doc && doc_e->type_u8!=DOCT_PMT) {
+      do doc_e=doc_e->last;
+      while (doc_e!=doc && doc_e->type_u8!=DOCT_NEW_LINE &&
+	    doc_e->type_u8!=DOCT_PMT);
+    }
+    doc_e=doc_e->next;
+    res=DocScanLine(doc,doc_e,NULL);
+  }
+  DocUnlock(doc);
+gs_done:
+  "$$PT$$$$FG$$$$BG$$";
+  return res;
+}
+
+#help_index "Keyboard Devices;Char/Input;StdIn"
+public I64 GetI64(U8 *msg=NULL,I64 dft=0,I64 lo=I64_MIN,I64 hi=I64_MAX)
+{//Prompt user for I64 expression.
+  Bool okay;
+  U8 *st;
+  I64 res;
+  while (TRUE) {
+    if (msg)
+      "" msg,dft;
+    st=GetStr;
+    if (!*st) {
+      Free(st);
+      return dft;
+    }
+    try {
+      res=ExePrint2("ToI64(%s);",st);
+      okay=TRUE;
+    } catch {
+      Fs->catch_except=TRUE;
+      okay=FALSE;
+    }
+    Free(st);
+    if (okay && lo<=res<=hi)
+      return res;
+  }
+}
+
+public F64 GetF64(U8 *msg=NULL,F64 dft=0,F64 lo=F64_MIN,F64 hi=F64_MAX)
+{//Prompt user for F64 expression.
+  Bool okay;
+  U8 *st;
+  F64 res;
+  while (TRUE) {
+    if (msg)
+      "" msg,dft;
+    st=GetStr;
+    if (!*st) {
+      Free(st);
+      return dft;
+    }
+    try {
+      res=ExePrint2("ToF64(%s);",st)(F64);
+      okay=TRUE;
+    } catch {
+      Fs->catch_except=TRUE;
+      okay=FALSE;
+    }
+    Free(st);
+    if (okay && lo<=res<=hi)
+      return res;
+  }
+}
+
+public CDate GetDate(U8 *msg=NULL,CDate dft=I64_MIN,
+	CDate lo=I64_MIN,CDate hi=I64_MAX)
+{//Prompt user for date expression. (Use $LK,"Now",A="MN:Now"$() if you want current time.)
+  U8 *st;
+  CDate res;
+  if (dft==I64_MIN) dft=Now;
+  while (TRUE) {
+    if (msg)
+      "" msg,dft,dft;
+    st=GetStr;
+    if (!*st) {
+      Free(st);
+      return dft;
+    }
+    res=Str2Date(st);
+    Free(st);
+    if (res>=lo && res<=hi)
+      return res;
+  }
+}

TempleOSCD/Adam/DolDoc/DocGr.HC

@@ -0,0 +1,163 @@
+#help_index "Graphics/Input"
+
+public I64 PopUpColor(U8 *header=NULL,
+	Bool allow_transparent=TRUE,Bool allow_dft=TRUE)
+{//Chooser for 16-color, default or transparent.
+  I64 i;
+  CDoc *doc=DocNew;
+  if (header)
+    DocPrint(doc,"%s",header);
+  if (allow_transparent)
+    DocPrint(doc,"$$MU,\"TRANSPARENT\",LE=TRANSPARENT$$\n");
+  for (i=0;i<COLORS_NUM;i++)
+    DocPrint(doc,"$$BG,%d$$$$MU,\"__%-8Z__\",LE=%d$$$$BG$$\n",i,i,"ST_COLORS",i);
+  if (allow_dft)
+    DocPrint(doc,"$$BG,WHITE$$$$MU,\"DEFAULT\",LE=DOC_DFT$$$$BG$$");
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i;
+}
+
+public I64 PopUpColorLighting(U8 *header=NULL)
+{//Chooser for std TempleOS $LK,"DCLighting",A="MN:DCLighting"$() color.
+  I64 i;
+  CDoc *doc=DocNew;
+  if (header)
+    DocPrint(doc,"%s",header);
+  DocPrint(doc,"\nSingle-Sided means front and back different."
+	"\nDouble-Sided means front and back same."
+	"\n"
+	"\nHalf-Range means 0 to [0,7]"
+	"\n                 [8,15]-8 to [8,15]"
+	"\nFull-Range means 0 to [0,7] to [0,7]+8"
+	"\n");
+  DocPrint(doc,
+	"\n$$LTPURPLE$$Single-Sided Full-Range Double-Sided Full-Range\n$$BLACK$$");
+  for (i=0;i<COLORS_NUM/2;i++) {
+    DocPrint(doc,"$$BG,%d$$$$MU,\"__%-19Z__\",LE=%d$$$$BG$$ ",i,i,"ST_COLORS",i);
+    DocPrint(doc,"$$BG,%d$$$$MU,\"__%-19Z__\",LE=%d$$$$BG$$\n",i,i,"ST_COLORS",
+	  ROPF_TWO_SIDED+i);
+  }
+  DocPrint(doc,
+	"\n$$LTPURPLE$$Single-Sided Half-Range Double-Sided Half-Range\n$$BLACK$$");
+  for (i=0;i<COLORS_NUM;i++) {
+    DocPrint(doc,"$$BG,%d$$$$MU,\"__%-19Z__\",LE=%d$$$$BG$$ ",
+	  i,i,"ST_COLORS",ROPF_HALF_RANGE_COLOR+i);
+    DocPrint(doc,"$$BG,%d$$$$MU,\"__%-19Z__\",LE=%d$$$$BG$$\n",
+	  i,i,"ST_COLORS",ROPF_TWO_SIDED+ROPF_HALF_RANGE_COLOR+i);
+  }
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i;
+}
+
+class CTransformForm
+{
+  F64 x_scale	fmtstr "$$DA-TRM,A=\"X Scale :%12.6f\"$$\n";
+  F64 y_scale	fmtstr "$$DA-TRM,A=\"Y Scale :%12.6f\"$$\n";
+  F64 z_scale	fmtstr "$$DA-TRM,A=\"Z Scale :%12.6f\"$$\n";
+  F64 é_z	fmtstr "\nAngles are in degrees\n"
+		       "$$DA-TRM,A=\"Z-Axis  :%12.6f\"$$\n";
+  F64 é_y	fmtstr "$$DA-TRM,A=\"Y-Axis  :%12.6f\"$$\n";
+  F64 é_x	fmtstr "$$DA-TRM,A=\"X-Axis  :%12.6f\"$$\n";
+  F64 x_offset	fmtstr "\n$$DA-TRM,A=\"X Offset:%12.6f\"$$\n";
+  F64 y_offset	fmtstr "$$DA-TRM,A=\"Y Offset:%12.6f\"$$\n";
+  F64 z_offset	fmtstr "$$DA-TRM,A=\"Z Offset:%12.6f\"$$\n";
+};
+
+#help_index "Graphics/Input;Graphics/Math/3D Transformation"
+public Bool PopUpTransform(I64 *r)
+{//Prompt for Mat4x4 transform.
+  CTransformForm *tf=MAlloc(sizeof(CTransformForm));
+  tf->x_scale=1.0;
+  tf->y_scale=1.0;
+  tf->z_scale=1.0;
+  tf->é_x=0.0;
+  tf->é_y=0.0;
+  tf->é_z=0.0;
+  tf->x_offset=0.0;
+  tf->y_offset=0.0;
+  tf->z_offset=0.0;
+  if (PopUpForm(tf)) {
+    MemSet(r,0,16*sizeof(I64));
+    r[0] =tf->x_scale*GR_SCALE;
+    r[5] =tf->y_scale*GR_SCALE;
+    r[10]=tf->z_scale*GR_SCALE;
+    r[15]=GR_SCALE;
+
+    Mat4x4RotZ(r,tf->é_z*ã/180.0);
+    Mat4x4RotY(r,tf->é_y*ã/180.0);
+    Mat4x4RotX(r,tf->é_x*ã/180.0);
+
+    r[3] =tf->x_offset*GR_SCALE;
+    r[7] =tf->y_offset*GR_SCALE;
+    r[11]=tf->z_offset*GR_SCALE;
+    return TRUE;
+  } else
+    return FALSE;
+}
+
+#help_index "Graphics/Input"
+#define PU_SPACING	10
+U0 DrawIt(CTask *task,CDC *dc)
+{
+  I64 i,j,i1,j1;
+  CDoc *doc=DocPut(task);
+  for (j=0;j<17;j++)
+    for (i=0;i<17;i++) {
+      if (j<16)
+	j1=j;
+      else
+	j1=TRANSPARENT;
+      if (i<16)
+	i1=i;
+      else
+	i1=TRANSPARENT;
+      dc->color=j1+i1<<16+ROPF_DITHER;
+      GrRect(dc,i*PU_SPACING,j*PU_SPACING+FramePtr("DitherFrame",task),
+	    PU_SPACING,PU_SPACING);
+    }
+  i=(17*PU_SPACING+FONT_WIDTH-1)/FONT_WIDTH;
+  if (doc->max_x>i) i=doc->max_x;
+  WinHorz(task->win_left,task->win_left+i,task);
+  WinVert(task->win_top,task->win_top+doc->max_y+
+	(17*PU_SPACING+FONT_WIDTH-1)/FONT_WIDTH,task);
+}
+
+I64 DitherColor2(U8 *header=NULL)
+{
+  I64 msg_code,arg1,arg2,res=-1,i,j;
+  DocClear;
+  "%s",header;
+  DocRecalc(DocPut);
+  FramePtrAdd("DitherFrame",(DocPut->max_y+1)*FONT_HEIGHT);
+  SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
+  Fs->draw_it=&DrawIt;
+  do {
+    msg_code=GetMsg(&arg1,&arg2,1<<MSG_MS_L_DOWN|1<<MSG_KEY_DOWN);
+    if (msg_code==MSG_MS_L_DOWN) {
+      msg_code=GetMsg(&arg1,&arg2,1<<MSG_MS_L_UP);
+      i=arg1/PU_SPACING;
+      j=(arg2-FramePtr("DitherFrame"))/PU_SPACING;
+      if (arg1>=0 && arg2>=0 && 0<=j<17 && 0<=i<17) {
+	if (j==16) j=TRANSPARENT;
+	if (i==16) i=TRANSPARENT;
+	res=j+i<<16+ROPF_DITHER;
+	goto dc_done;
+      }
+    }
+  } while (!(msg_code==MSG_KEY_DOWN && (arg1==CH_ESC || arg1==CH_SHIFT_ESC)));
+  do GetMsg(&arg1,&arg2,1<<MSG_KEY_UP);
+  while (!arg1);
+dc_done:
+  SettingsPop;
+  FramePtrDel("DitherFrame");
+  return res;
+}
+
+public I64 PopUpColorDither(U8 *header=NULL)
+{//Chooser for 2 x 16 colors or transparent.
+  U8 buf[STR_LEN];
+  StrPrint(buf,"DitherColor2(0x%X);",header);
+  return PopUp(buf,Fs);
+}

TempleOSCD/Adam/DolDoc/DocHighlight.HC

@@ -0,0 +1,160 @@
+#help_index "DolDoc/Misc"
+
+CColorROPU32 highlight_hash_type_colors[HTt_TYPES_NUM]=
+	DOC_COLOR_EXPORT_SYS_SYM,0,DOC_COLOR_DEFINE_STR,DOC_COLOR_GLBL_VAR,
+	DOC_COLOR_CLASS,DOC_COLOR_KEYWORD,DOC_COLOR_FUN,0,0,DOC_COLOR_KEYWORD,
+	DOC_COLOR_KEYWORD,DOC_COLOR_KEYWORD,DOC_COLOR_REG,0,0,0,0};
+
+U32 *DocHighlight(CDocEntry *doc_e,U8 *src,I64 len,I64 _tmp_u32_attr)
+{//Be aware of $LK,"::/Demo/ToHtmlToTXTDemo/ToHtml.HC"$.
+  U32 *res=MAlloc((len+1)*sizeof(U32)),*dst=res;
+  U8 *ptr;
+  CDocSettings *s=&doc_e->settings;
+  I64 ch,ch1,last_ch,tmp_u32_attr,mask_tmp_u32_attr=_tmp_u32_attr&0xFFFFF000,
+	comment_depth,brace_depth=s->brace_depth,paren_depth=s->paren_depth;
+  CHash *tmph;
+  switch [s->state] {
+    case DOCSS_NORMAL:
+hl_normal:
+      while (len) {
+	while (len && !Bt(char_bmp_alpha_numeric,*src)) {
+	  tmp_u32_attr=_tmp_u32_attr;
+	  ch1=*src++;
+	  switch (ch1) {
+	    case '/':
+	      if (len>=2) {
+		if (*src=='/') {
+		  tmp_u32_attr=DOC_COLOR_COMMENT<<8|mask_tmp_u32_attr;
+		  *dst++=ch1+tmp_u32_attr;
+		  *dst++=*src++ +tmp_u32_attr;
+		  len-=2;
+		  goto hl_cpp_comment;
+		} else if (*src=='*') {
+		  tmp_u32_attr=DOC_COLOR_COMMENT<<8|mask_tmp_u32_attr;
+		  *dst++=ch1+tmp_u32_attr;
+		  *dst++=*src++ +tmp_u32_attr;
+		  len-=2;
+		  comment_depth=1;
+		  goto hl_comment;
+		}
+	      }
+	      break;
+	    case '\'':
+	      tmp_u32_attr=DOC_COLOR_CHAR_CONST<<8|mask_tmp_u32_attr;
+	      *dst++=ch1+tmp_u32_attr;
+	      len--;
+	      goto hl_single_quote;
+	    case '\"':
+	      tmp_u32_attr=DOC_COLOR_STR<<8|mask_tmp_u32_attr;
+	      *dst++=ch1+tmp_u32_attr;
+	      len--;
+	      goto hl_dbl_quote;
+	    case '(':
+	      if (paren_depth++&1)
+		tmp_u32_attr=DOC_COLOR_ALT_TEXT<<8|mask_tmp_u32_attr;
+	      break;
+	    case ')':
+	      if (--paren_depth&1)
+		tmp_u32_attr=DOC_COLOR_ALT_TEXT<<8|mask_tmp_u32_attr;
+	      break;
+	    case '{':
+	      if (brace_depth++&1)
+		tmp_u32_attr=DOC_COLOR_ALT_TEXT<<8|mask_tmp_u32_attr;
+	      break;
+	    case '}':
+	      if (--brace_depth&1)
+		tmp_u32_attr=DOC_COLOR_ALT_TEXT<<8|mask_tmp_u32_attr;
+	      break;
+	  }
+	  *dst++=ch1+tmp_u32_attr;
+	  if (!--len) goto hl_normal_done;
+	}
+	ptr=src;
+	while (len && Bt(char_bmp_alpha_numeric,*src)) {
+	  src++;
+	  len--;
+	}
+	ch=*src;
+	*src=0;
+	if (tmph=HashFind(ptr,adam_task->hash_table,
+	      HTT_EXPORT_SYS_SYM|HTT_DEFINE_STR|HTT_GLBL_VAR|HTT_CLASS|
+	      HTT_INTERNAL_TYPE|HTT_FUN|HTT_KEYWORD|HTT_ASM_KEYWORD|
+	      HTT_OPCODE|HTT_REG))
+	  tmp_u32_attr=highlight_hash_type_colors[HashTypeNum(tmph)]<<8|
+		mask_tmp_u32_attr;
+	else
+	  tmp_u32_attr=_tmp_u32_attr;
+	while (ch1=*ptr++)
+	  *dst++=ch1+tmp_u32_attr;
+	*src=ch;
+      }
+hl_normal_done:
+      s->state=DOCSS_NORMAL;
+      s->comment_depth=0;
+      break;
+    case DOCSS_SINGLE_QUOTE:
+      tmp_u32_attr=DOC_COLOR_CHAR_CONST<<8|mask_tmp_u32_attr;
+hl_single_quote:
+      last_ch=0;
+      while (len--) {
+	ch1=*src++;
+	*dst++=ch1+tmp_u32_attr;
+	if (last_ch!='\\' && ch1=='\'')
+	  goto hl_normal;
+	if (last_ch=='\\' && ch1=='\\')
+	  last_ch=0;
+	else
+	  last_ch=ch1;
+      }
+      s->state=DOCSS_SINGLE_QUOTE;
+      s->comment_depth=0;
+      break;
+    case DOCSS_DBL_QUOTE:
+      tmp_u32_attr=DOC_COLOR_CHAR_CONST<<8|mask_tmp_u32_attr;
+hl_dbl_quote:
+      last_ch=0;
+      while (len--) {
+	ch1=*src++;
+	*dst++=ch1+tmp_u32_attr;
+	if (last_ch!='\\' && ch1=='\"')
+	  goto hl_normal;
+	if (last_ch=='\\' && ch1=='\\')
+	  last_ch=0;
+	else
+	  last_ch=ch1;
+      }
+      s->state=DOCSS_DBL_QUOTE;
+      s->comment_depth=0;
+      break;
+    case DOCSS_COMMENT:
+      tmp_u32_attr=DOC_COLOR_COMMENT<<8|mask_tmp_u32_attr;
+      comment_depth=s->comment_depth;
+hl_comment:
+      last_ch=0;
+      while (len--) {
+	ch1=*src++;
+	*dst++=ch1+tmp_u32_attr;
+	if (last_ch=='*' && ch1=='/') {
+	  if (!--comment_depth)
+	    goto hl_normal;
+	} else if (last_ch=='/' && ch1=='*')
+	  comment_depth++;
+	last_ch=ch1;
+      }
+      s->state=DOCSS_COMMENT;
+      s->comment_depth=comment_depth;
+      break;
+    case DOCSS_CPP_Z_COMMENT:
+      tmp_u32_attr=DOC_COLOR_COMMENT<<8|mask_tmp_u32_attr;
+hl_cpp_comment:
+      while (len--)
+	*dst++=*src++ +tmp_u32_attr;
+      s->state=DOCSS_CPP_Z_COMMENT;
+      s->comment_depth=0;
+      break;
+  }
+  s->paren_depth=paren_depth;
+  s->brace_depth=brace_depth;
+  *dst=0;
+  return res;
+}

TempleOSCD/Adam/DolDoc/DocInit.HC

@@ -0,0 +1,112 @@
+#help_index "DolDoc"
+
+U0 DocInit()
+{//$LK-UL,"CMD Defines",A="MN:DOCT_TEXT"$
+  CCmpCtrl *cc;
+  I64 i;
+  CHashGeneric *tmph;
+
+  DefineLstLoad("ST_DOC_CMDS",
+	"TX\0CR\0SR\0TB\0PB\0CU\0MK\0PT\0CL\0PL\0LM\0RM\0HD\0FO\0ID\0FG\0"
+	"BG\0FD\0BD\0WW\0HL\0BK\0IV\0UL\0SX\0SY\0CM\0AN\0LK\0BT\0"
+	"DA\0CB\0LS\0MA\0MU\0HX\0TR\0SP\0IB\0IS\0SO\0HC\0ER\0");
+  DefineLstLoad("ST_DOC_FLAGS",
+	"T\0LEN\0A\0D\0HTML\0LE\0LM\0RE\0RM\0BI\0BP\0RT\0SX\0SY\0SCX\0U\0"
+	"LC\0LIS\0RC\0RIS\0LX\0CX\0RX\0TY\0CY\0BY\0"
+	"HL\0WW\0BK\0IV\0SEL\0UL\0"
+	"TC\0PRY\0MRX\0WR\0L\0X\0Q\0FST\0B\0S\0BD\0C\0CA\0RD\0UD\0P\0M\0"
+	"TRM\0Z\0H\0TR\0LS\0SK\0PU\0SIF\0FS\0NC\0DD\0DL\0DRT\0");
+  DefineLstLoad("ST_LINK_TYPES",
+	"FI\0FA\0FF\0FL\0MN\0PI\0PF\0PL\0BF\0DN\0HI\0AD\0AI\0AA\0AF\0AL\0");
+
+  doldoc.hash=HashTableNew(512);
+  HashDefineLstAdd("ST_DOC_CMDS",DHT_DOC_CMD,doldoc.hash);
+  HashDefineLstAdd("ST_DOC_FLAGS",DHT_DOC_FLAG,doldoc.hash);
+  HashDefineLstAdd("ST_COLORS",DHT_COLOR,doldoc.hash);
+
+  MemSet(doldoc.dft_de_flags,	0,sizeof(doldoc.dft_de_flags));
+  MemSet(doldoc.dft_type_flags,	0,sizeof(doldoc.dft_type_flags));
+  cc=CmpCtrlNew("TX+T;DA+P+TRM+T+DL+DRT;CM+LE+RE;AN+T;LK+L+UL+T;MA+X+UL+T;"
+	"MU+X+UL+T;BT+X+B+T;CB+CA+P+T+DRT;LS+LS+P+T+DRT;HX+P+Z;TR+TR+C+CA+UL+T;"
+	"SP+T;IB+T;IS+T;SO+T;HC+T;",CCF_DONT_FREE_BUF);
+  cc->htc.hash_table_lst=NULL;
+  Lex(cc);
+  while (cc->token==TK_IDENT) {
+    if (tmph=HashFind(cc->cur_str,doldoc.hash,DHT_DOC_CMD)) {
+      i=tmph->user_data0;
+      Lex(cc);
+      PrsDocFlags(cc,&doldoc.dft_de_flags[i],&doldoc.dft_type_flags[i]);
+    }
+    if (cc->token==';')
+      Lex(cc);
+  }
+  CmpCtrlDel(cc);
+
+  for (i=0;i<DOCT_TYPES_NUM;i++)
+    doldoc.dft_de_flags[i]&=~DOCG_BL_IV_UL;
+
+  doldoc.type_flags_form[0]=0;
+  for (i=0;i<DOCT_TYPES_NUM;i++)
+    if (Bt(&doldoc.dft_de_flags[i],DOCEf_TAG) && i!=DOCT_TEXT || i==DOCT_HEX_ED)
+      Bts(doldoc.type_flags_form,i);
+
+      //Don't forget $LK,"cmp_type_flags_src_code",A="MN:cmp_type_flags_src_code"$.
+  doldoc.type_flags_nontag_invis[0]=
+	1<<DOCT_PMT|
+	1<<DOCT_PAGE_LEN|
+	1<<DOCT_LEFT_MARGIN|
+	1<<DOCT_RIGHT_MARGIN|
+	1<<DOCT_HEADER|
+	1<<DOCT_FOOTER|
+	1<<DOCT_INDENT|
+	1<<DOCT_FOREGROUND|
+	1<<DOCT_BACKGROUND|
+	1<<DOCT_DFT_FOREGROUND|
+	1<<DOCT_DFT_BACKGROUND|
+	1<<DOCT_WORD_WRAP|
+	1<<DOCT_HIGHLIGHT|
+	1<<DOCT_BLINK|
+	1<<DOCT_INVERT|
+	1<<DOCT_UNDERLINE|
+	1<<DOCT_SHIFTED_X|
+	1<<DOCT_SHIFTED_Y|
+	1<<DOCT_SPRITE;
+
+  doldoc.type_flags_data[0]=1<<DOCT_DATA|1<<DOCT_HEX_ED|1<<DOCT_CHECK_BOX;
+
+  doldoc.type_flags_chk_dup[0]=
+	1<<DOCT_LEFT_MARGIN|
+	1<<DOCT_RIGHT_MARGIN|
+	1<<DOCT_HEADER|
+	1<<DOCT_FOOTER|
+	1<<DOCT_FOREGROUND|
+	1<<DOCT_BACKGROUND|
+	1<<DOCT_DFT_FOREGROUND|
+	1<<DOCT_DFT_BACKGROUND|
+	1<<DOCT_WORD_WRAP|
+	1<<DOCT_HIGHLIGHT|
+	1<<DOCT_BLINK|
+	1<<DOCT_INVERT|
+	1<<DOCT_UNDERLINE|
+	1<<DOCT_SHIFTED_X|
+	1<<DOCT_SHIFTED_Y;
+
+  Bts(doldoc.clean_scan_codes,SC_CURSOR_RIGHT);
+  Bts(doldoc.clean_scan_codes,SC_CURSOR_LEFT);
+  Bts(doldoc.clean_scan_codes,SC_CURSOR_UP);
+  Bts(doldoc.clean_scan_codes,SC_CURSOR_DOWN);
+  Bts(doldoc.clean_scan_codes,SC_PAGE_UP);
+  Bts(doldoc.clean_scan_codes,SC_PAGE_DOWN);
+  Bts(doldoc.clean_scan_codes,SC_ALT);
+  Bts(doldoc.clean_scan_codes,SC_CTRL);
+  Bts(doldoc.clean_scan_codes,SC_SHIFT);
+  Bts(doldoc.clean_scan_codes,SC_CAPS);
+  Bts(doldoc.clean_scan_codes,SC_NUM);
+  Bts(doldoc.clean_scan_codes,SC_SCROLL);
+  Bts(doldoc.clean_scan_codes,SC_HOME);
+  Bts(doldoc.clean_scan_codes,SC_END);
+  Bts(doldoc.clean_scan_codes,SC_GUI);
+  Bts(doldoc.clean_scan_codes,SC_BACKSPACE); //Handled specially
+}
+
+DocInit;

TempleOSCD/Adam/DolDoc/DocLink.HC

@@ -0,0 +1,358 @@
+#help_index "DolDoc/Link"
+
+/* See $LK,"TempleOS Link Types",A="MN:ST_LINK_TYPES"$.
+"filename"
+"FI:filename"
+"FA:haystack_filename,needle_anchor_str"
+"FF:haystack_filename,needle_str"
+"FF:haystack_filename,needle_str:occurnum"
+"FL:filename,linenum"
+"MN:SymName"
+"PI:filename"
+"PF:haystack_filename,needle_str"
+"PF:haystack_filename,needle_str:occurnum"
+"PL:filename,linenum"
+"BF:haystack_bible_book,needle_str"
+"DN:word"
+"DN:word,defnum"
+"HI:index"
+"AD:code_address_number"
+
+To edit a doc structure already in memory. See $LK,"SpriteEdText",A="MN:SpriteEdText"$().
+"AI:doc_address"
+"AA:haystack_doc_address,needle_anchor_str"
+"AF:haystack_doc_address,needle_str"
+"AF:haystack_doc_address,needle_str:occurnum"
+"AL:doc_address,linenum"
+*/
+
+#define LK_FILE 	0
+#define LK_FILE_ANCHOR	1
+#define LK_FILE_FIND	2
+#define LK_FILE_LINE	3
+#define LK_MAN_PAGE	4
+#define LK_PLAIN	5
+#define LK_PLAIN_FIND	6
+#define LK_PLAIN_LINE	7
+#define LK_BIBLE_FIND	8
+#define LK_DEF		9
+#define LK_HELP_INDEX	10
+#define LK_ADDR		11
+#define LK_DOC		12 //See $LK,"SpriteEdText",A="MN:SpriteEdText"$()
+#define LK_DOC_ANCHOR	13
+#define LK_DOC_FIND	14
+#define LK_DOC_LINE	15
+#define LK_PLACE_ANCHOR	16
+
+public U8 *DocEntryLink(CDoc *doc,CDocEntry *doc_e)
+{//MAlloc new str, either tag or aux_str if link.
+  if (doc_e->de_flags&DOCEF_LINK) {
+    if (doc_e->de_flags & DOCEF_AUX_STR)
+      return StrNew(doc_e->aux_str,doc->mem_task);
+    else if (doc_e->de_flags & DOCEF_TAG)
+      return StrNew(doc_e->tag,doc->mem_task);
+  }
+  return NULL;
+}
+
+Bool DocFileEd(I64 _type,U8 *filename,
+	U8 *needle_str,I64 *_num,I64 edf_dof_flags)
+{
+  I64 type=_type,flags=0,old_border_src=Fs->border_src;
+  CDocEntry *doc_e;
+  CDoc *doc;
+  Bool old_silent=Bt(&Fs->display_flags,DISPLAYf_SILENT),
+	res=FALSE,other_found=FALSE;
+  U8 *st1,*st2;
+  try {
+    switch (type) {
+      case LK_PLAIN:
+	flags=DOCF_PLAIN_TEXT|DOCF_NO_CURSOR;
+      case LK_DOC:
+	type=LK_FILE;
+	break;
+      case LK_DOC_ANCHOR:
+	type=LK_FILE_ANCHOR;
+	break;
+      case LK_PLAIN_FIND:
+	flags=DOCF_PLAIN_TEXT|DOCF_NO_CURSOR;
+      case LK_DOC_FIND:
+	type=LK_FILE_FIND;
+	break;
+      case LK_PLAIN_LINE:
+	flags=DOCF_PLAIN_TEXT|DOCF_NO_CURSOR;
+      case LK_DOC_LINE:
+	type=LK_FILE_LINE;
+	break;
+      case LK_BIBLE_FIND:
+	flags=DOCF_PLAIN_TEXT|DOCF_NO_CURSOR;
+	break;
+    }
+
+    flags|=DOCF_ALLOW_UNDO;
+
+    if (LK_DOC<=_type<=LK_DOC_LINE) {
+      doc=Str2I64(filename);//See $LK,"SpriteEdText",A="MN:SpriteEdText"$()
+      res=TRUE;
+    } else {
+      st1=StrNew(filename);
+      st2=StrNew(filename);
+      StrLastRem(st1,"/",st2); //st2 is name without dir
+      if (!FileNameChk(st2))
+	doc=NULL;
+      else {
+	Silent;
+	if (Bt(&edf_dof_flags,EDf_BAIL)) //if bail, scan parents
+	  res=FileFind(filename,,
+		FUF_JUST_FILES|FUF_Z_OR_NOT_Z|FUF_SCAN_PARENTS);
+	else if (!(res=FileFind(filename,,FUF_JUST_FILES)))
+	  other_found=FileFind(filename,,
+		FUF_JUST_FILES|FUF_Z_OR_NOT_Z|FUF_SCAN_PARENTS);
+	doc=DocRead(filename,flags);
+	doc->desc='Edit';
+	Silent(old_silent);
+	Fs->border_src=BDS_ED_FILENAME_DRV;
+      }
+      Free(st1);
+      Free(st2);
+    }
+    if (!doc||doc->doc_signature!=DOC_SIGNATURE_VAL)
+      res=FALSE;
+    else {
+      if (Bt(&edf_dof_flags,EDf_COLLAPSE))
+	DocCollapse(TRUE,doc);
+      else if (Bt(&edf_dof_flags,EDf_UNCOLLAPSE))
+	DocCollapse(FALSE,doc);
+
+      if (res || other_found)
+	switch (type) {
+	  case LK_FILE_LINE:
+	    res=DocLineNumGoTo(doc,*_num);
+	    break;
+	  case LK_FILE_ANCHOR:
+	    res=DocAnchorFind(doc,needle_str);
+	    break;
+	  case LK_FILE_FIND:
+	    res=DocFind(doc,,needle_str,*_num);
+	    break;
+	  case LK_BIBLE_FIND:
+	    res=DocFind(doc,*_num,needle_str);
+	    break;
+	  default:
+	    DocCenter(doc);
+	}
+      *_num=doc->cur_entry->y+1;
+
+      if (edf_dof_flags&EDF_WAS_WRITE)
+	res=FALSE;
+      if (!(edf_dof_flags&EDF_BAIL)) {
+	if (*doc->filename.name)
+	  doc->filename.dirc=DirContextNew(doc->filename.name);
+	else
+	  doc->filename.dirc=NULL;
+	if (DocEd(doc,edf_dof_flags|DOF_DONT_HOME)) {
+	  DocLock(doc);
+	  doc_e=doc->cur_entry;
+	  if (doc_e!=doc)
+	    DocEntryRun(doc,doc_e,TRUE);
+	  DocUnlock(doc);
+	  if (!(LK_DOC<=_type<=LK_DOC_LINE)) {
+	    DocWrite(doc);
+	    if (edf_dof_flags&EDF_WAS_WRITE)
+	      res=TRUE;
+	  }
+	}
+	DirContextDel(doc->filename.dirc);
+      }
+      if (!(LK_DOC<=_type<=LK_DOC_LINE))
+	DocDel(doc);
+    }
+  } catch {
+    Silent(old_silent);
+    res=FALSE;
+  }
+  Fs->border_src=old_border_src;
+  return res;
+}
+
+#define DFT_ADDR_LINK_BIN_SIZE	64
+
+public I64 EdLinkCvt(U8 *link_st,U8 **_filename=NULL,U8 **_needle_str=NULL,
+	I64 *_num=NULL,I64 edf_dof_flags=0)
+{//$LK,"Editor Link",A="MN:LK_FILE"$--> filename, needle_str and line number.
+  U8 *st,*ptr,*src,*filename=NULL,*needle_str=NULL,*filename2;
+  I64 res,i,num=1;
+  CHashSrcSym *tmph;
+  if (!link_st||!*link_st) {
+    if (edf_dof_flags&EDF_BAIL)
+      return -1;
+    link_st=blkdev.tmp_filename;
+  }
+  st=StrNew(link_st);
+  res=LK_FILE;
+  if (StrLen(st)>3 && st[2]==':') {
+    st[2]=0;
+    filename2=st+3;
+    switch (res=DefineMatch(st,"ST_LINK_TYPES",LMF_IGNORE_CASE)) {
+      case LK_MAN_PAGE:
+	if (tmph=HashFind(filename2,Fs->hash_table,HTG_SRC_SYM))
+	  res=EdLinkCvt(tmph->src_link,&filename,
+		&needle_str,&num,edf_dof_flags);
+	else
+	  res=-1;
+	goto lc_done;
+      case LK_ADDR:
+	if (ptr=StrLastOcc(filename2,",")) {
+	  *ptr=0;
+	  i=Str2I64(ptr+1);
+	} else
+	  i=DFT_ADDR_LINK_BIN_SIZE;
+	if (ptr=SrcEdLink(ExePrint("%s;",filename2),i)) {
+	  res=EdLinkCvt(ptr,&filename,&needle_str,&num,edf_dof_flags);
+	  Free(ptr);
+	} else
+	  res=-1;
+	goto lc_done;
+      case LK_DEF:
+	if (ptr=StrLastOcc(filename2,",")) {
+	  *ptr=0;
+	  i=Str2I64(ptr+1);
+	} else
+	  i=-1;
+	filename=StrNew(filename2);
+	num=i;
+	goto lc_done;
+      case LK_HELP_INDEX:
+	filename=StrNew(filename2);
+	goto lc_done;
+      case LK_BIBLE_FIND:
+	if (ptr=StrLastOcc(filename2,",")) {
+	  *ptr=0;
+	  src=ptr+1;
+	  while (*src) { //We do not allow ending verse
+	    if (*src=='-')
+	      *src=0;
+	    src++;
+	  }
+	  needle_str=StrNew(ptr+1);
+	}
+	i=DefineMatch(filename2,"ST_BIBLE_BOOKS",LMF_IGNORE_CASE);
+	if (i<0)
+	  res=-1;
+	else {
+	  num=Str2I64(DefineSub(i,"ST_BIBLE_BOOK_LINES"));
+	  filename2=BIBLE_FILENAME;
+	}
+	break;
+      case LK_FILE_LINE:
+      case LK_PLAIN_LINE:
+      case LK_DOC_LINE:
+	if (ptr=StrLastOcc(filename2,",")) {
+	  *ptr=0;
+	  num=Str2I64(ptr+1);
+	}
+	break;
+      case LK_FILE_ANCHOR:
+      case LK_DOC_ANCHOR:
+	if (ptr=StrLastOcc(filename2,",")) {
+	  *ptr=0;
+	  needle_str=StrNew(ptr+1);
+	}
+	break;
+      case LK_FILE_FIND:
+      case LK_PLAIN_FIND:
+      case LK_DOC_FIND:
+	if (ptr=StrLastOcc(filename2,",")) {
+	  *ptr=0;
+	  needle_str=StrNew(ptr+1);
+	  if (ptr=StrLastOcc(needle_str,":")) {
+	    *ptr=0;
+	    num=Str2I64(ptr+1);
+	  }
+	}
+	break;
+    }
+  } else
+    filename2=st;
+  if (res>=0) {
+    if (LK_DOC<=res<=LK_DOC_LINE)
+      filename=StrNew(filename2); //Holds document address as number.
+    else
+      filename=FileNameAbs(filename2,FUF_Z_OR_NOT_Z);
+  }
+lc_done:
+  Free(st);
+  if (_filename)
+    *_filename=filename;
+  else
+    Free(filename);
+  if (_needle_str)
+    *_needle_str=needle_str;
+  else
+    Free(needle_str);
+  if (_num)
+    *_num=num;
+  return res;
+}
+
+public Bool DocLinkChk(CDoc *doc,U8 *link_st)
+{//Check for bad $LK,"Editor Link",A="MN:LK_FILE"$.
+  U8 *filename,*st;
+  Bool res=FALSE;
+  CDirContext *dirc;
+  if (link_st) {
+    st=FileNameAbs(doc->filename.name);
+    dirc=DirContextNew(st);
+    Free(st);
+    switch (EdLinkCvt(link_st,&filename)) {
+      case -1:
+	break;
+      case LK_FILE_LINE:
+      case LK_PLAIN_LINE:
+      case LK_FILE:
+//We don't check line number
+	res=FileFind(filename,,
+	      FUF_JUST_FILES|FUF_Z_OR_NOT_Z|FUF_SCAN_PARENTS);
+	break;
+      case LK_BIBLE_FIND:
+	st=StrNew(link_st+3);
+	if (StrOcc(st,','))
+	  StrLastRem(st,",");
+	if (DefineMatch(st,"ST_BIBLE_BOOKS",LMF_IGNORE_CASE)>=0)
+	  res=TRUE;
+	Free(st);
+	break;
+      default://TODO: Need to validate HI: and DN:
+	if (Ed(link_st,EDF_BAIL))
+	  res=TRUE;
+    }
+    Free(filename);
+    DirContextDel(dirc);
+  }
+  return res;
+}
+
+public U8 *DocLinkFile(U8 *link_st,CTask *mem_task=NULL)
+{//Return the file for an $LK,"Editor Link Types",A="MN:LK_FILE"$.
+  U8 *filename=NULL,*st,*res=NULL;
+  if (link_st) {
+    switch (EdLinkCvt(link_st,&filename)) {
+      case LK_FILE:
+      case LK_FILE_ANCHOR:
+      case LK_FILE_FIND:
+      case LK_FILE_LINE:
+      case LK_PLAIN:
+      case LK_PLAIN_FIND:
+      case LK_PLAIN_LINE:
+	st=FileNameAbs(filename,FUF_Z_OR_NOT_Z|FUF_SCAN_PARENTS);
+	res=StrNew(st);
+	Free(st);
+	break;
+      case LK_BIBLE_FIND:
+	res=StrNew(BIBLE_FILENAME,mem_task);
+	break;
+    }
+    Free(filename);
+  }
+  return res;
+}

TempleOSCD/Adam/DolDoc/DocMacro.HC

@@ -0,0 +1,211 @@
+#help_index "DolDoc/Misc"
+
+U8 captured_macro_name[STR_LEN];
+StrCpy(captured_macro_name,"Test");
+
+I64 sys_macro_repeat_n=1;
+
+U0 SysMacroStripKey(CJob *macro_head,I64 arg1,I64 arg2)
+{
+  CJob *tmpc,*tmpc1;
+  tmpc=macro_head->next;
+  while (tmpc!=macro_head) {
+    tmpc1=tmpc->next;
+    if (tmpc->job_code==JOBT_MSG &&
+	  (tmpc->msg_code==MSG_KEY_DOWN || tmpc->msg_code==MSG_KEY_UP ||
+	  tmpc->msg_code==MSG_KEY_DOWN_UP) &&
+	  arg1 && tmpc->aux1==arg1 || !arg1 && tmpc->aux2==arg2) {
+      QueRem(tmpc);
+      JobDel(tmpc);
+    }
+    tmpc=tmpc1;
+  }
+}
+
+#define MT_NULL	0
+#define MT_MSG	1
+#define MT_CHAR	2
+
+class CMacroTmp
+{
+  CMacroTmp *next,*last;
+  I64 type;
+  U8 buf[STR_LEN];
+};
+
+CMacroTmp *Cmd2MT(CJob *tmpc)
+{
+  U8 buf[8];
+  CMacroTmp *tmpmt=CAlloc(sizeof(CMacroTmp));
+  if (Bt(char_bmp_macro,tmpc->aux1) && tmpc->msg_code==MSG_KEY_DOWN) {
+    tmpmt->type=MT_CHAR;
+    buf[0]=tmpc->aux1;
+    buf[1]=0;
+    StrPrint(tmpmt->buf,"%Q",buf);
+  } else {
+    tmpmt->type=MT_MSG;
+    StrPrint(tmpmt->buf,"Msg(0x%X,0x%X,0x%X);",
+	  tmpc->msg_code,tmpc->aux1,tmpc->aux2);
+  }
+  return tmpmt;
+}
+
+U8 *SysMacro2Str(CJob *macro_head)
+{
+  CJob *tmpc;
+  I64 cnt=1; //terminating zero
+  U8 *ptr,*m;
+  CMacroTmp *tmpmt,*tmpmt1,head;
+  LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
+
+  QueInit(&head);
+  head.type=MT_NULL;
+  tmpc=macro_head->next;
+  while (tmpc!=macro_head) {
+    tmpmt=Cmd2MT(tmpc);
+    QueIns(tmpmt,head.last);
+    cnt+=StrLen(tmpmt->buf);
+    if (tmpmt->type==MT_CHAR) {
+      if (tmpmt->last->type!=MT_CHAR)
+	cnt+=StrLen("\"");
+      if (tmpmt->next->type!=MT_CHAR)
+	cnt+=StrLen("\";");
+    }
+    tmpc=tmpc->next;
+  }
+
+  m=MAlloc(cnt);
+  ptr=m;
+
+  tmpmt=head.next;
+  while (tmpmt!=&head) {
+    tmpmt1=tmpmt->next;
+    if (tmpmt->type==MT_MSG) {
+      StrCpy(ptr, tmpmt->buf);
+      ptr+=StrLen(tmpmt->buf);
+    } else {
+      if (tmpmt->last->type!=MT_CHAR) {
+	StrCpy(ptr, "\"");
+	ptr+=StrLen("\"");
+      }
+      StrCpy(ptr,tmpmt->buf);
+      ptr+=StrLen(tmpmt->buf);
+      if (tmpmt->next->type!=MT_CHAR) {
+	StrCpy(ptr, "\";");
+	ptr+=StrLen("\";");
+      }
+    }
+    Free(tmpmt);
+    tmpmt=tmpmt1;
+  }
+  *ptr=0;
+  return m;
+}
+
+U0 PlaySysMacro(I64 n=1)
+{
+  CTask *task=sys_focus_task;
+  U8 *m;
+  if (TaskValidate(task)) {
+    LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
+    m=SysMacro2Str(&sys_macro_head);
+    while (n-- && TaskValidate(task)) {
+      if (task==Fs)
+	InStr("%s",m);
+      else
+	XTalkStrWait(task,"%s",m);
+    }
+    Free(m);
+  }
+}
+
+U0 EdInsCapturedMacro()
+{
+  U8 *st=SysMacro2Str(&sys_macro_head);
+  if (sys_focus_task) {
+    XTalk(sys_focus_task,"$$MA+LIS,T=\"%s\",LM=\"%$$Q\"$$",
+	  captured_macro_name,st);
+    Free(st);
+  }
+}
+
+#define SM_RECORD	0
+#define SM_INS		1
+#define SM_PLAY		2
+#define SM_REPEAT_N	3
+#define SM_STOP		4
+
+I64 PopUpMacroMenu()
+{
+  I64 res=0;
+  U8 buf[STR_LEN];
+  CJob *tmpc;
+  CDoc *doc=DocNew;
+  CDocEntry *doc_e=DocPrint(doc,"$$DA-P,LEN=STR_LEN-1,A=\"Name:%%s\"$$");
+  doc_e->data=captured_macro_name;
+  DocDataFmt(doc,doc_e);
+
+  doc_e=DocPrint(doc,"\n$$DA,A=\"Repeat N:%%d\"$$");
+  doc_e->data=&sys_macro_repeat_n;
+  DocDataFmt(doc,doc_e);
+
+  DocPrint(doc,"\n"
+	"$$CM+LX,1,3$$$$BT,\"RECORD\",LE=SM_RECORD$$"
+	"$$CM+LX,17,0$$$$BT,\"INSERT\",LE=SM_INS$$"
+	"$$CM+LX,1,3$$$$BT,\"PLAY\",LE=SM_PLAY$$"
+	"$$CM+LX,17,0$$$$BT,\"REPEAT N\",LE=SM_REPEAT_N$$"
+	"$$CM+LX,1,3$$$$BT,\"STOP\",LE=SM_STOP$$"
+	"$$CM+LX,17,0$$$$BT,\"CANCEL\",LE=DOCM_CANCEL$$"
+	"\n\n\n$$GREEN$$SHIFT-F2$$FG$$ will play macro.\n");
+  doc->flags|=DOCF_SIZE_MIN | DOCF_FORM;
+  StrPrint(buf,"DocMenu(%d);",doc);
+  sys_macro_task=Spawn(&SrvCmdLine,NULL,"Macro Popup",,Fs);
+  Fs->popup_task=sys_macro_task;
+  LBts(&sys_macro_task->display_flags,DISPLAYf_WIN_ON_TOP);
+  tmpc=TaskExe(sys_macro_task,Fs,buf,
+	1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER);
+  JobResScan(tmpc,&res);
+  Fs->popup_task=NULL;
+  Kill(sys_macro_task);
+  sys_macro_task=NULL;
+  DocDataScan(doc,doc_e);
+  DocDel(doc);
+  return res;
+}
+
+U0 MacroTask(I64)
+{
+  I64 i;
+  StrCpy(captured_macro_name,"Click Here");
+  sys_macro_repeat_n=1;
+  do {
+    i=PopUpMacroMenu;
+    WinRefocus(sys_focus_task);
+    switch (i) {
+      case SM_RECORD:
+	LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
+	QueDel(&sys_macro_head,TRUE);
+	LBts(&sys_semas[SEMA_RECORD_MACRO],0);
+	break;
+      case SM_PLAY:
+	PlaySysMacro;
+	break;
+      case SM_REPEAT_N:
+	PlaySysMacro(sys_macro_repeat_n);
+	break;
+      case SM_STOP:
+	LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
+	break;
+      case SM_INS:
+	LBtr(&sys_semas[SEMA_RECORD_MACRO],0);
+	EdInsCapturedMacro;
+	break;
+    }
+  } while (i>=0);
+}
+
+U0 EdMacroUtil()
+{
+  if (!sys_macro_task)
+    Spawn(&MacroTask,NULL,"Macro");
+}

TempleOSCD/Adam/DolDoc/DocNew.HC

@@ -0,0 +1,385 @@
+#help_index "DolDoc"
+
+public Bool DocLock(CDoc *doc)
+{//Make this task have exclusive access to this doc.
+  if (!Bt(&doc->locked_flags,DOClf_LOCKED) || doc->owning_task!=Fs) {
+    while (LBts(&doc->locked_flags,DOClf_LOCKED))
+      Yield;
+    if (doc->owning_task!=Fs)
+      LBEqu(&doc->flags,DOCf_BREAK_UNLOCKED,BreakLock(Fs));
+    doc->owning_task=Fs;
+    return TRUE;
+  } else
+    return FALSE;
+}
+
+public Bool DocUnlock(CDoc *doc)
+{//Release exclusive lock on access to doc.
+  Bool unlock_break;
+  if (Bt(&doc->locked_flags,DOClf_LOCKED) && doc->owning_task==Fs) {
+    doc->owning_task=0;
+    unlock_break=Bt(&doc->flags,DOCf_BREAK_UNLOCKED);
+    LBtr(&doc->locked_flags,DOClf_LOCKED);
+    if (unlock_break)
+      BreakUnlock(Fs);
+    return TRUE;
+  } else
+    return FALSE;
+}
+
+Bool IsEditableText(CDocEntry *doc_e)
+{
+  if (doc_e->type_u8==DOCT_TEXT&&!(doc_e->de_flags&DOCEG_DONT_EDIT))
+    return TRUE;
+  else
+    return FALSE;
+}
+
+CDocEntry *DocEntryNewBase(CDoc *doc,I64 type,I64 de_flags=0,
+	I64 x=0,I64 y=0,I64 page_line_num=0)
+{//See also $LK,"MAllocIdent",A="FF:::/Adam/DolDoc/DocRecalc.HC,MAllocIdent"$ and $MA-X+PU,"CDocEntry",LM="F(\"sizeof(CDocEntry)\");View;"$.
+  CDocEntry *res=CAlloc(sizeof(CDocEntryBase),doc->mem_task);
+  res->type=type;
+  res->de_flags=de_flags|doldoc.dft_de_flags[type.u8[0]];
+  res->x=x;
+  res->y=y;
+  res->page_line_num=page_line_num;
+  return res;
+}
+
+CDocEntry *DocEntryNewTag(CDoc *doc,CDocEntry *doc_ce,U8 *tag)
+{
+  I64 l=StrLen(tag);
+  CDocEntry *res=DocEntryNewBase(doc,doc_ce->type,doc_ce->de_flags,
+	doc_ce->x,doc_ce->y,doc_ce->page_line_num);
+  res->de_flags=doc_ce->de_flags; //Override
+  res->max_col=l;
+  res->tag=MAlloc(l+1,doc->mem_task);
+  MemCpy(res->tag,tag,l+1);
+  MemCpy(&res->settings,&doc_ce->settings,sizeof(CDocSettings));
+  return res;
+}
+
+public U0 DocEntryDel(CDoc *doc,CDocEntry *doc_e)
+{//Free entry and all parts of entry.
+  if (!doc || doc==doc_e)
+    RawPrint(3000,"DocEntryDel");
+  else {
+    if (doc->cur_entry==doc_e)
+      doc->cur_entry=doc_e->next;
+    QueRem(doc_e);
+    if (doc_e->de_flags & DOCEF_TAG)
+      Free(doc_e->tag);
+    if (doc_e->de_flags & DOCEF_AUX_STR)
+      Free(doc_e->aux_str);
+    if (doc_e->de_flags & DOCEF_DEFINE)
+      Free(doc_e->define_str);
+    if (doc_e->de_flags & DOCEF_HTML_LINK)
+      Free(doc_e->html_link);
+    if (doc_e->de_flags & DOCEF_LEFT_MACRO)
+      Free(doc_e->left_macro);
+    if (doc_e->de_flags & DOCEF_RIGHT_MACRO)
+      Free(doc_e->right_macro);
+    if (doc_e->de_flags & DOCEF_BIN_PTR_LINK)
+      Free(doc_e->bin_ptr_link);
+    if (doc_e->de_flags & DOCEF_HAS_BIN)
+      DocBinDel(doc,doc_e->bin_data);
+    if (doc_e->de_flags & DOCEF_REMALLOC_DATA)
+      Free(doc_e->data);
+    Free(doc_e);
+  }
+}
+
+public I64 DocEntrySize(CDoc *,CDocEntry *doc_e)
+{//Mem size of entry and all parts.
+  I64 res;
+  if (!doc_e) return 0;
+  res=MSize2(doc_e);
+  if (doc_e->de_flags & DOCEF_TAG)
+    res+=MSize2(doc_e->tag);
+  if (doc_e->de_flags & DOCEF_AUX_STR)
+    res+=MSize2(doc_e->aux_str);
+  if (doc_e->de_flags & DOCEF_DEFINE)
+    res+=MSize2(doc_e->define_str);
+  if (doc_e->de_flags & DOCEF_HTML_LINK)
+    res+=MSize2(doc_e->html_link);
+  if (doc_e->de_flags & DOCEF_LEFT_MACRO)
+    res+=MSize2(doc_e->left_macro);
+  if (doc_e->de_flags & DOCEF_RIGHT_MACRO)
+    res+=MSize2(doc_e->right_macro);
+  if (doc_e->de_flags & DOCEF_BIN_PTR_LINK)
+    res+=MSize2(doc_e->bin_ptr_link);
+  if (doc_e->de_flags & DOCEF_REMALLOC_DATA)
+    res+=MSize2(doc_e->data);
+  return res;
+}
+
+U0 DocUndoDel(CDoc *,CDocUndo *u)
+{
+  Free(u->body);
+  Free(u);
+}
+
+U0 DocUndoCntSet(CDoc *doc)
+{
+  Bool unlock=DocLock(doc);
+  CDocUndo *u=doc->undo_head.next;
+  doc->undo_cnt=0;
+  while (u!=&doc->undo_head) {
+    doc->undo_cnt++;
+    u=u->next;
+  }
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public CDocEntry *DocEntryCopy(CDoc *doc,CDocEntry *doc_e)
+{//Make copy of entry and all parts of entry.
+  CDocEntry *doc_ne;
+  CDocBin *tmpb;
+  CTask *task=doc->mem_task;
+  doc_ne=MAllocIdent(doc_e,task);
+  doc_ne->next=doc_ne;
+  doc_ne->last=doc_ne;
+  if (doc_e->de_flags & DOCEF_TAG)
+    doc_ne->tag=MAllocIdent(doc_e->tag,task);
+  if (doc_e->de_flags & DOCEF_AUX_STR)
+    doc_ne->aux_str=MAllocIdent(doc_e->aux_str,task);
+  if (doc_e->de_flags & DOCEF_DEFINE)
+    doc_ne->define_str=MAllocIdent(doc_e->define_str,task);
+  if (doc_e->de_flags & DOCEF_HTML_LINK)
+    doc_ne->html_link=MAllocIdent(doc_e->html_link,task);
+  if (doc_e->de_flags & DOCEF_LEFT_MACRO)
+    doc_ne->left_macro=MAllocIdent(doc_e->left_macro,task);
+  if (doc_e->de_flags & DOCEF_RIGHT_MACRO)
+    doc_ne->right_macro=MAllocIdent(doc_e->right_macro,task);
+  if (doc_e->de_flags & DOCEF_BIN_PTR_LINK)
+    doc_ne->bin_ptr_link=MAllocIdent(doc_e->bin_ptr_link,task);
+  if (doc_e->de_flags & DOCEF_HAS_BIN) {
+    tmpb=MAllocIdent(doc_e->bin_data,task);
+    tmpb->data=MAllocIdent(doc_e->bin_data->data,task);
+    doc_ne->bin_num=doc->cur_bin_num;
+    tmpb->num=doc->cur_bin_num++;
+    doc_ne->bin_data=tmpb;
+    if (doc_e->de_flags&DOCEF_TAG && doc_e->tag && *doc_e->tag)
+      tmpb->tag=StrNew(doc_e->tag,task);
+    else
+      tmpb->tag=NULL;
+    QueIns(tmpb,doc->bin_head.last);
+  }
+  if (doc_e->de_flags & DOCEF_REMALLOC_DATA)
+    doc_ne->data=MAllocIdent(doc_e->data,task);
+  return doc_ne;
+}
+
+U0 DocRemSoftNewLines(CDoc *doc=NULL,CDocEntry *doc_e=NULL)
+{
+  CDocEntry *doc_e2,*saved_ll=doc_e;
+  Bool unlock;
+  if (!doc && !(doc=DocPut))
+    return;
+  unlock=DocLock(doc);
+  if (!doc_e) doc_e=doc->head.next;
+  while (doc_e!=doc) {
+    doc_e2=doc_e->next;
+    if (doc_e->type_u8==DOCT_SOFT_NEW_LINE) {
+      if (doc->cur_entry==doc_e) {
+	doc->cur_entry=doc_e2;
+	doc->cur_col=doc->cur_entry->min_col;
+      }
+      DocEntryDel(doc,doc_e);
+    } else if (saved_ll && doc_e->type_u8==DOCT_NEW_LINE)
+      break;
+    doc_e=doc_e2;
+  }
+  if (unlock)
+    DocUnlock(doc);
+}
+
+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_col>0 &&
+	doc_ce->type_u8==DOCT_TEXT &&
+	!(doc_ce->de_flags&(DOCEF_TAG_CB|DOCEF_DEFINE|DOCEF_AUX_STR|
+	DOCEF_HTML_LINK|DOCEF_BIN_PTR_LINK)) &&
+	doc->cur_col<doc_ce->max_col) {
+    dst=doc_ce->tag+doc->cur_col;
+    doc_ne=DocEntryNewTag(doc,doc_ce,dst);
+    *dst=0;
+    doc_ne->type=DOCT_TEXT|doc_ce->type&0xFFFFFF00;
+    doc_ce->max_col=doc->cur_col;
+    QueIns(doc_ne,doc_ce);
+    doc->cur_col=0;
+    doc_ce=doc_ne;
+  }
+  if (doc_ce->type_u8==DOCT_TEXT && doc->cur_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_col=doc->cur_entry->min_col;
+  DocRemSoftNewLines(doc,doc->cur_entry);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 DocRst(CDoc *doc,Bool is_old)
+{//Del all entries and set doc to dfts.
+  Bool unlock;
+  CDocEntry *doc_e,*doc_e2;
+  CDocUndo *u,*u8;
+  CDocSettings *s;
+  CDocBin *b,*b1;
+  if (!doc && !(doc=DocPut))
+    return;
+  unlock=DocLock(doc);
+  if (is_old) {
+    doc_e=doc->head.next;
+    while (doc_e!=doc) {
+      doc_e2=doc_e->next;
+      DocEntryDel(doc,doc_e);
+      doc_e=doc_e2;
+    }
+    u=doc->undo_head.next;
+    while (u!=&doc->undo_head) {
+      u8=u->next;
+      DocUndoDel(doc,u);
+      u=u8;
+    }
+    b=doc->bin_head.next;
+    while (b!=&doc->bin_head) {
+      b1=b->next;
+      QueRem(b);
+      Free(b->data);
+      Free(b);
+      b=b1;
+    }
+  }
+//Check $LK,"DocInsDoc",A="MN:DocInsDoc"$
+  doc->flags&=DOCF_BREAK_UNLOCKED;
+  doc->head.next=doc->head.last=doc;
+  QueInit(&doc->bin_head);
+  QueInit(&doc->undo_head);
+  doc->undo_head.time_stamp=0;
+  doc->undo_cnt=0;
+  doc->cur_bin_num=1;
+  doc->dollar_buf_ptr=0;
+  doc->cmd_U8=CH_SPACE;
+  doc->page_line_num=0;
+  doc->best_d=I64_MAX;
+
+  s=&doc->settings_head;
+  s->left_margin=DOC_DFT;
+  s->right_margin=DOC_DFT;
+  s->indent=0;
+  s->page_len=66;
+  s->header=DOC_DFT;
+  s->footer=DOC_DFT;
+  s->state=DOCSS_NORMAL;
+  s->comment_depth=0;
+  s->paren_depth=0;
+  s->brace_depth=0;
+  s->shifted_x=0;
+  s->shifted_y=0;
+  s->cur_text_attr=s->dft_text_attr=DOC_ATTR_DFT_TEXT;
+
+  doc_e=&doc->head;
+  doc_e->type=DOCT_ERROR;
+  doc_e->de_flags=0;
+  doc_e->x=0;
+  doc_e->y=0;
+  doc_e->min_col=0;
+  doc_e->max_col=0;
+  doc_e->page_line_num=doc->page_line_num;
+  MemCpy(&doc_e->settings,s,sizeof(CDocSettings));
+
+  DocTop(doc);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 DocDel(CDoc *doc)
+{//Free entire doc and entries.
+  if (!doc || doc->doc_signature!=DOC_SIGNATURE_VAL) return;
+  DocLock(doc);
+  doc->doc_signature=0;
+  DocRst(doc,TRUE);
+  Free(doc->find_replace);
+  Free(doc->dollar_buf);
+  DocUnlock(doc);
+  Free(doc);
+}
+
+public I64 DocSize(CDoc *doc)
+{//Mem size of doc and all its entries.
+  Bool unlock;
+  CDocEntry *doc_e;
+  CDocUndo *u;
+  CDocBin *b;
+  I64 res=0;
+
+  if (!doc || doc->doc_signature!=DOC_SIGNATURE_VAL) return 0;
+  unlock=DocLock(doc);
+
+  doc_e=doc->head.next;
+  while (doc_e!=doc) {
+    res+=DocEntrySize(doc,doc_e);
+    doc_e=doc_e->next;
+  }
+
+  u=doc->undo_head.next;
+  while (u!=&doc->undo_head) {
+    res+=MSize2(u->body);
+    res+=MSize2(u);
+    u=u->next;
+  }
+
+  b=doc->bin_head.next;
+  while (b!=&doc->bin_head) {
+    res+=MSize2(b->data);
+    res+=MSize2(b);
+    b=b->next;
+  }
+
+  res+=MSize2(doc->find_replace);
+  res+=MSize2(doc->dollar_buf);
+  res+=MSize2(doc);
+  if (unlock)
+    DocUnlock(doc);
+  return res;
+}
+
+#help_index "DolDoc"
+public CDoc *DocNew(U8 *filename=NULL,CTask *task=NULL)
+{//MAlloc new $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.DD"$. (Begin a new doc.)
+  CDoc *doc;
+  if (!task) task=Fs;
+  doc=CAlloc(sizeof(CDoc),task);
+  if (filename)
+    StrCpy(doc->filename.name,filename);
+  else
+    StrCpy(doc->filename.name,blkdev.tmp_filename);
+  doc->find_replace=CAlloc(sizeof(CEdFindText),task);
+  doc->find_replace->scan_fwd=TRUE;
+  doc->find_replace->match_case=TRUE;
+  doc->find_replace->pmt=TRUE;
+  doc->left_click_link=&EdLeftClickLink;
+  doc->dollar_buf_size=84;
+  doc->dollar_buf=MAlloc(doc->dollar_buf_size,task);
+  doc->max_entries=I64_MAX;
+  doc->win_task=task;
+  doc->mem_task=task;
+  DocRst(doc,FALSE);
+  doc->doc_signature=DOC_SIGNATURE_VAL;
+  return doc;
+}

TempleOSCD/Adam/DolDoc/DocPlain.HC

@@ -0,0 +1,611 @@
+#help_index "DolDoc"
+
+I64 PrsDocFlagSingle(CCmpCtrl *cc,I64 *_de_flags,U32 *_type,Bool turn_on)
+{
+  I64 res=-1;
+  CHashGeneric *tmph;
+  if (cc->token==TK_IDENT &&
+	(tmph=HashFind(cc->cur_str,doldoc.hash,DHT_DOC_FLAG))) {
+    res=tmph->user_data0;
+    if (res<64) {
+      BEqu(_de_flags,res,turn_on);
+      switch (res) {
+	case DOCEf_BLINK:
+	case DOCEf_INVERT:
+	case DOCEf_UNDERLINE:
+	case DOCEf_SEL:
+	  BEqu(_type,res,turn_on);
+	  break;
+      }
+    }
+    Lex(cc);	//skip flag
+  }
+  return res;
+}
+
+I64 PrsDocFlags(CCmpCtrl *cc,I64 *_de_flags,U32 *_type)
+{
+  I64 res=-1;
+  Bool turn_on;
+  while (TRUE) {
+    if (cc->token=='+')
+      turn_on=TRUE;
+    else if (cc->token=='-')
+      turn_on=FALSE;
+    else
+      break;
+    Lex(cc);
+    res=PrsDocFlagSingle(cc,_de_flags,_type,turn_on);
+  }
+  return res;
+}
+
+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<COLORS_NUM) {
+    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_SEL|
+	  DOCEF_HIGHLIGHT|DOCEF_WORD_WRAP|DOCEF_SKIP|DOCEF_FILTER_SKIP);
+    for (i=0;i<DOCEf_FLAGS_NUM;i++)
+      if (Bt(&f1,i)!=Bt(&de_flags,i)) {
+	if (Bt(&de_flags,i)) {
+	  if (!(1<<i&DOCEG_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_SEL;
+    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;
+    switch [doc_e->type_u8] {
+      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);
+	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<COLORS_NUM) {
+	  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_BLINK:
+      case DOCT_INVERT:
+      case DOCT_UNDERLINE:
+      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_TYPES_NUM-1: //nobound switch
+	break;
+    }
+    de_flags=doc_e->de_flags & DOCEG_HAS_ARG;
+    while (de_flags) {
+      j=Bsf(de_flags);
+      Btr(&de_flags,j);
+      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_LEN:
+	  buf2=MStrPrint("%sLEN=%d,",buf,doc_e->len);
+	  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_FLAGS_NUM-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 *tmph;
+  CCmpCtrl *cc=CmpCtrlNew(st,CCF_DONT_FREE_BUF);
+  CHashTable *old_hash_table_lst=cc->htc.hash_table_lst;
+  try {
+    cc->htc.hash_table_lst=NULL;
+    if (Lex(cc)==TK_IDENT) {
+      if (tmph=HashFind(cc->cur_str,doldoc.hash,DHT_DOC_CMD|DHT_COLOR)) {
+	if (tmph->type&DHT_DOC_CMD)
+	  i=tmph->user_data0;
+	else {//DHT_COLOR
+	  i=DOCT_FOREGROUND;
+	  attr=tmph->user_data0;
+	}
+      } else
+	goto pd_err;
+      Lex(cc); //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;
+      doc_e->len=DOCE_LEN_DFT;
+      j=PrsDocFlags(cc,&doc_e->de_flags,&doc_e->type);
+      cc->htc.hash_table_lst=old_hash_table_lst;
+      switch [i] {
+	case DOCT_CHECK_BOX:
+	  doc_e->raw_type=RT_I8;
+	  break;
+	case DOCT_HEX_ED:
+	  while (cc->token==',')
+	    Lex(cc);
+	  if (cc->token)
+	    doc_e->len=LexExpressionI64(cc);
+	  else
+	    goto pd_err;
+	  while (cc->token==',')
+	    Lex(cc);
+	  if (cc->token)
+	    doc_e->hex_ed_width=LexExpressionI64(cc);
+	  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_BLINK:
+	case DOCT_INVERT:
+	case DOCT_UNDERLINE:
+	case DOCT_SHIFTED_X:
+	case DOCT_SHIFTED_Y:
+	  while (cc->token==',')
+	    Lex(cc);
+	  if (cc->token)
+	    doc_e->attr=LexExpressionI64(cc);
+	  else
+	    doc_e->attr=attr;
+	  break;
+#assert DOCT_ERROR==DOCT_TYPES_NUM-1
+	case DOCT_ERROR:
+	  goto pd_err;
+      }
+
+      processed_flags=0;
+      while (TRUE) {
+	cc->htc.hash_table_lst=NULL;
+	while (cc->token==',')
+	  Lex(cc);
+	cc->htc.hash_table_lst=old_hash_table_lst;
+	j=PrsDocFlagSingle(cc,&doc_e->de_flags,&doc_e->type,TRUE);
+	if (!(de_flags=~processed_flags & doc_e->de_flags & DOCEG_HAS_ARG))
+	  break;
+	if (cc->token=='=')
+	  Lex(cc);
+	else
+	  j=Bsf(de_flags);
+	if (j<0 || Bts(&processed_flags,j))
+	  goto pd_err;
+	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 (cc->token==TK_STR) {
+		st2=LexExtStr(cc);
+		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_LEN:
+	    if (cc->token) {
+	      doc_e->len=LexExpression(cc);
+	      doc_e->de_flags&=~DOCEF_DFT_LEN;
+	    } else
+	      goto pd_err;
+	    break;
+	  case DOCEf_AUX_STR:
+	    if (cc->token==TK_STR) {
+	      st2=LexExtStr(cc);
+	      doc_e->aux_str=StrNew(st2,doc->mem_task);
+	      Free(st2);
+//$AN,"Anchor",A="DataTagWidth"$
+	      if (i==DOCT_DATA) { //See $LK,"DocForm",A="MN:DocForm"$()
+		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 (cc->token==TK_STR) {
+	      st2=LexExtStr(cc);
+	      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 (cc->token==TK_STR) {
+	      st2=LexExtStr(cc);
+	      doc_e->html_link=StrNew(st2,doc->mem_task);
+	      Free(st2);
+	    } else
+	      goto pd_err;
+	    break;
+	  case DOCEf_LEFT_EXP:
+	    if (cc->token)
+	      doc_e->left_exp=LexExpression(cc);
+	    else
+	      goto pd_err;
+	    break;
+	  case DOCEf_LEFT_MACRO:
+	    if (cc->token==TK_STR) {
+	      st2=LexExtStr(cc);
+	      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 (cc->token)
+	      doc_e->right_exp=LexExpression(cc);
+	    else
+	      goto pd_err;
+	    break;
+	  case DOCEf_RIGHT_MACRO:
+	    if (cc->token==TK_STR) {
+	      st2=LexExtStr(cc);
+	      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 (cc->token)
+	      doc_e->bin_num=LexExpressionI64(cc);
+	    else
+	      goto pd_err;
+	    break;
+	  case DOCEf_BIN_PTR_LINK:
+	    if (cc->token==TK_STR) {
+	      st2=LexExtStr(cc);
+	      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 (cc->token==TK_IDENT) {
+	      j=DefineMatch(cc->cur_str,"ST_RAW_TYPES");
+	      if (j<0)
+		goto pd_err;
+	      doc_e->raw_type=j;
+	      doc_e->de_flags&=~DOCEF_DFT_RAW_TYPE;
+	      Lex(cc);
+	    } else
+	      goto pd_err;
+	    break;
+	  case DOCEf_SHIFTED_X:
+	    if (cc->token)
+	      doc_e->type|=(LexExpressionI64(cc) & 0x1F)<<16;
+	    else
+	      goto pd_err;
+	    break;
+	  case DOCEf_SHIFTED_Y:
+	    if (cc->token)
+	      doc_e->type|=(LexExpressionI64(cc) & 0x1F)<<21;
+	    else
+	      goto pd_err;
+	    break;
+	  case DOCEf_SCROLLING_X:
+	    if (cc->token)
+	      doc_e->scroll_len=LexExpressionI64(cc);
+	    else
+	      goto pd_err;
+	    break;
+	  case DOCEf_USER_DATA:
+	    if (cc->token)
+	      doc_e->user_data=LexExpression(cc);
+	    else
+	      goto pd_err;
+	    break;
+	  case DOCEf_FLAGS_NUM-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_REMALLOC_DATA ||
+	  !(doc_e->de_flags&DOCEF_DEREF_DATA))) {
+      DocDataScan(doc,doc_e);
+      DocDataFmt(doc,doc_e);
+    }
+    CmpCtrlDel(cc);
+  } 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;
+}
+
+U0 DocEntryToggle(CDoc *doc)
+{
+  Bool unlock=DocLock(doc),old_color_names;
+  CDocEntry *doc_ce=doc->cur_entry,*cl1,*doc_ce2;
+  U8 ch,*st,*st2;
+  I64 i,j,k;
+  if (doc_ce!=doc &&
+	!(doc->flags&(DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS))) {
+    if (doc_ce->type_u8==DOCT_TEXT && !(doc_ce->de_flags &
+	  ~(DOCEF_TAG|DOCG_BL_IV_UL|DOCEF_WORD_WRAP|DOCEF_HIGHLIGHT|
+	  DOCEF_SKIP|DOCEF_FILTER_SKIP)) &&
+	  !(doc_ce->type&DOCG_BL_IV_UL)) {
+      doc_ce2=doc_ce->last;
+      for (k=0;k<20;k++) {
+	if (doc_ce2!=doc) {
+	  cl1=doc_ce2->last;
+	  if (doc_ce2->type_u8==DOCT_TEXT &&
+		doc_ce->de_flags==doc_ce2->de_flags &&
+		doc_ce->type==doc_ce2->type) {
+	    i=StrLen(doc_ce2->tag);
+	    j=StrLen(doc_ce->tag);
+	    st=MAlloc(i+j+1,doc->mem_task);
+	    MemCpy(st,doc_ce2->tag,i);
+	    MemCpy(st+i,doc_ce->tag,j+1);
+	    Free(doc_ce->tag);
+	    doc_ce->tag=st;
+	    doc_ce->max_col=i+j;
+	    doc->cur_col+=i;
+	    DocEntryDel(doc,doc_ce2);
+	  } else if (doc_ce2->type_u8==DOCT_SOFT_NEW_LINE)
+	    DocEntryDel(doc,doc_ce2);
+	  else
+	    break;
+	  doc_ce2=cl1;
+	} else
+	  break;
+      }
+      doc_ce2=doc_ce->next;
+      for (k=0;k<20;k++) {
+	if (doc_ce2!=doc) {
+	  cl1=doc_ce2->next;
+	  if (doc_ce2->type_u8==DOCT_TEXT &&
+		doc_ce->de_flags==doc_ce2->de_flags &&
+		doc_ce->type==doc_ce2->type) {
+	    i=StrLen(doc_ce->tag);
+	    j=StrLen(doc_ce2->tag);
+	    st=MAlloc(i+j+1,doc->mem_task);
+	    MemCpy(st,doc_ce->tag,i);
+	    MemCpy(st+i,doc_ce2->tag,j+1);
+	    Free(doc_ce->tag);
+	    doc_ce->tag=st;
+	    doc_ce->max_col=i+j;
+	    DocEntryDel(doc,doc_ce2);
+	  } else if (doc_ce2->type_u8==DOCT_SOFT_NEW_LINE)
+	    DocEntryDel(doc,doc_ce2);
+	  else
+	    break;
+	  doc_ce2=cl1;
+	} else
+	  break;
+      }
+      i=doc->cur_col;
+      while (i>doc_ce->min_col && doc_ce->tag[i]!='$$')
+	i--;
+      j=doc->cur_col+1;
+      while (j<doc_ce->max_col && doc_ce->tag[j]!='$$')
+	j++;
+      if (i<j-1 && doc_ce->min_col<=i<j<doc_ce->max_col &&
+	    doc_ce->tag[i]=='$$' && doc_ce->tag[j]=='$$') {
+	ch=doc_ce->tag[j+1];
+	doc_ce->tag[j+1]=0;
+	st=StrNew(doc_ce->tag+i);
+	doc_ce->tag[j+1]=ch;
+	StrCpy(doc_ce->tag+i,doc_ce->tag+j+1);
+	doc->cur_col=i;
+	st2=MStrPrint("%q",st);
+	if (doc_ce=DocPrint(doc,st2)) {
+	  doc->cur_entry=doc_ce;
+	  doc->cur_col=doc_ce->min_col;
+	}
+	Free(st);
+	Free(st2);
+      }
+    } else {
+      old_color_names=LBts(&doc->flags,DOCf_COLOR_NAMES);
+      st=Doc2PlainText(doc,doc_ce);
+      LBEqu(&doc->flags,DOCf_COLOR_NAMES,old_color_names);
+      DocEntryDel(doc,doc_ce);
+      DocPrint(doc,"$$$$%$$Q$$$$",st);
+    }
+    DocRecalc(doc);
+  }
+  if (unlock)
+    DocUnlock(doc);
+}
+
+U0 DocFlagsToggle(CDoc *doc,I64 tog_flags)
+{
+  Bool	unlock=DocLock(doc);
+  I64 size,flags=doc->flags^tog_flags;
+  U8 *st;
+  CDocUndo *u_next,*u_last;
+
+  doc->flags=doc->flags&~DOCF_NO_CURSOR|DOCF_COLOR_NAMES;
+  st=DocSave(doc,&size);
+
+  u_next=doc->undo_head.next;
+  u_last=doc->undo_head.last;
+  doc->undo_head.next=doc->undo_head.last=&doc->undo_head;
+
+  DocRst(doc,TRUE);
+  doc->undo_head.next=u_next;
+  doc->undo_head.last=u_last;
+  DocUndoCntSet(doc);
+  doc->flags=flags&~(DOCF_NO_CURSOR|DOCG_BL_IV_UL|DOCF_WORD_WRAP);
+  DocLoad(doc,st,size);
+  doc->flags|=flags&DOCF_NO_CURSOR;
+  DocCenter(doc);
+  if (unlock)
+    DocUnlock(doc);
+  Free(st);
+}

TempleOSCD/Adam/DolDoc/DocPopUp.HC

@@ -0,0 +1,323 @@
+#help_index "DolDoc/Output;StdOut/DolDoc"
+public CTask *PopUpViewDoc(CDoc *doc,I64 dof_flags=0)
+{//Pass doc to PopUp win task for viewing.
+  U8 *buf=MStrPrint("DocEd(0x%X,0x%X);",doc,dof_flags);
+  CTask *task=Spawn(&SrvCmdLine,NULL,"View",,Fs);
+  TaskExe(task,NULL,buf,1<<JOBf_EXIT_ON_COMPLETE|1<<JOBf_FREE_ON_COMPLETE);
+  Free(buf);
+  return task;
+}
+
+U0 PopUpViewPrintEndCB()
+{
+  DocDel(FramePtr("ViewStrFrame"));
+  Exit;
+}
+
+public CTask *PopUpViewPrint(U8 *fmt,...)
+{//View Print stmt in PopUp win task.
+  CTask *task;
+  U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
+  CDoc *doc=DocNew;
+  DocPrint(doc,buf);
+  Free(buf);
+  task=PopUpViewDoc(doc);
+  FramePtrAdd("ViewStrFrame",doc,task);
+  task->task_end_cb=&PopUpViewPrintEndCB;
+  return task;
+}
+
+#help_index "DolDoc/Input;File/FileNames;StdIn/DolDoc"
+public U8 *PopUpPickFile(U8 *dir=NULL)
+{//Filename chooser.  Uses $LK,"FileMgr",A="MN:FileMgr"$().
+  U8 *res,*st,*st2;
+  if (dir)
+    st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_FILE,Fs->parent_task);",dir);
+  else {
+    st2=CurDir;
+    st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_FILE,Fs->parent_task);",st2);
+    Free(st2);
+  }
+  res=PopUp(st,Fs);
+  Free(st);
+  return res;
+}
+
+public U8 *PopUpPickDir(U8 *dir=NULL)
+{//File dir name chooser.  Uses $LK,"FileMgr",A="MN:FileMgr"$().
+  U8 *res,*st,*st2;
+  if (dir)
+    st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_DIR,Fs->parent_task);",dir);
+  else {
+    st2=CurDir;
+    st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_DIR,Fs->parent_task);",st2);
+    Free(st2);
+  }
+  res=PopUp(st,Fs);
+  Free(st);
+  return res;
+}
+
+public U8 *FileNameForm(U8 *dft=NULL,I64 dof_flags=0,CTask *mem_task=NULL)
+{//Text filename form in cur win, not PopUp.
+  CEdFileName fn;
+  if (dft)
+    StrCpy(fn.name,dft);
+  else
+    *fn.name=0;
+  if (DocForm(&fn,,dof_flags))
+    return StrNew(fn.name,mem_task);
+  else
+    return NULL;
+}
+
+public U8 *PopUpFileName(U8 *dft=NULL,I64 dof_flags=0)
+{//Filename chooser. Uses form, not $LK,"FileMgr",A="MN:FileMgr"$().
+  U8 *st=MStrPrint("FileNameForm(\"%Q\",0x%X,Fs->parent_task);",
+	dft,dof_flags|DOF_SIZE_MIN),*res=PopUp(st,Fs);
+  Free(st);
+  return res;
+}
+
+#help_index "DolDoc"
+Bool PopUpCd()
+{
+  Bool res;
+  U8 *st=PopUpPickDir;
+  if (st) {
+    res=Cd(st);
+    Free(st);
+  } else
+    res=FALSE;
+  return res;
+}
+
+#help_index "DolDoc/Input;Char/Lists;StdIn/DolDoc"
+public U8 *PopUpPickLst(U8 *lst)
+{//Prompt for lst entry in PopUp win task.
+  I64 i=0;
+  CDoc *doc=DocNew;
+  DocPrint(doc,"$$LTBLUE$$");
+  while (*lst) {
+    if (*lst=='@') {//Check for '@' alias lst entry
+      i--;
+      lst++;
+    }
+    DocPrint(doc,"$$MU,\"%s\",LE=%d$$\n",lst,i++);
+    lst+=StrLen(lst)+1;
+  }
+  DocPrint(doc,"\n$$MU,\"CANCEL\",LE=DOCM_CANCEL$$\n");
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i;
+}
+
+#help_index "DolDoc/Input;Char/Lists;Char/Define;StdIn/DolDoc"
+public U8 *PopUpPickDefineSub(U8 *dname)
+{//Prompt for $LK,"Define",A="HI:Define"$ lst entry in PopUp win task.
+  return PopUpPickLst(Define(dname));
+}
+
+#help_index "DolDoc/Input;StdIn/DolDoc"
+public I64 PopUp1(U8 *b1,I64 n1,U8 *header=NULL,U8 *footer=NULL)
+{//Make PopUp win task with one bttn.
+  I64 i,l1=StrLen(b1);
+  CDoc *doc=DocNew;
+  if (header) DocPrint(doc,"%s",header);
+  DocPrint(doc,"$$CM+CX,%d,4$$$$BT,\"%s\",LE=%d$$\n",-l1/2,b1,n1);
+  if (footer) DocPrint(doc,"%s",footer);
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i;
+}
+
+public I64 PopUp2(U8 *b1,I64 n1,U8 *b2,I64 n2,U8 *header=NULL,U8 *footer=NULL)
+{//Make PopUp win task with two bttns.
+  I64 i,l1=StrLen(b1),l2=StrLen(b2),y;
+  CDoc *doc=DocNew;
+  if (header) {
+    DocPrint(doc,"%s",header);
+    y=4;
+  } else {
+    DocPrint(doc,"%*s\n",l1+l2+10,"");
+    y=3;
+  }
+  DocPrint(doc,"$$CM+CX,%d,%d$$$$BT,\"%s\",LE=%d$$",-(l1+l2+3)>>1,y,b1,n1);
+  DocPrint(doc,"$$CM+CX,%d,0$$$$BT,\"%s\",LE=%d$$\n" ,-(l1+l2+3)>>1+l1+6,b2,n2);
+  if (footer) DocPrint(doc,"%s",footer);
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i;
+}
+
+public Bool PopUpOk(U8 *header=NULL,U8 *footer=NULL)
+{//Make PopUp win task with OKAY bttn.
+  return PopUp1("OKAY",1,header,footer)>0;
+}
+
+public Bool PopUpNoYes(U8 *header=NULL,U8 *footer=NULL)
+{//Make PopUp win task with NO/YES bttns.
+  return $WW,0$PopUp2("YES",1,"NO",0,header,footer)>0;
+}
+
+public Bool PopUpCancelOk(U8 *header=NULL,U8 *footer=NULL)
+{//Make PopUp win task CANCEL/OKAY bttns.
+  return PopUp2("OKAY",1,"CANCEL",0,header,footer)>0;
+}
+
+U8 *PopUpGetStr2(U8 *header,CTask *mem_task)
+{
+  U8 *res,*st;
+  if (header)
+    "%s",header;
+  st=GetStr(,,GSF_WITH_NEW_LINE);
+  res=StrNew(st,mem_task);
+  Free(st);
+  return res;
+}
+
+public U8 *PopUpGetStr(U8 *header=NULL)
+{//Prompt for text str in PopUp win task.
+  U8 *st=MStrPrint("PopUpGetStr2(0x%X,0x%X);",header,Fs),
+	*res=PopUp(st,Fs);
+  Free(st);
+  return res;
+}
+
+public I64 PopUpGetI64(U8 *msg,I64 dft,I64 lo=I64_MIN,I64 hi=I64_MAX)
+{//Prompt for I64 text expression in PopUp win task.
+  U8 *st=MStrPrint("GetI64(0x%X,0x%X,0x%X,0x%X);",msg,dft,lo,hi);
+  I64 res=PopUp(st,Fs);
+  Free(st);
+  return res;
+}
+
+public F64 PopUpGetF64(U8 *msg,F64 dft,F64 lo=F64_MIN,F64 hi=F64_MAX)
+{//Prompt for F64 text expression in PopUp win task.
+  U8 *st=MStrPrint("GetF64(0x%X,0x%X(F64),0x%X(F64),0x%X(F64));",msg,dft,lo,hi);
+  F64 res=PopUp(st,Fs)(F64);
+  Free(st);
+  return res;
+}
+
+public I64 PopUpRangeI64(I64 lo,I64 hi,I64 step=1,
+	U8 *header=NULL,U8 *footer=NULL)
+{//Evenly-spaced I64 range chooser in PopUp win task.
+  I64 i;
+  CDoc *doc=DocNew;
+  if (header)
+    DocPrint(doc,"%s",header);
+  DocPrint(doc,"$$LTBLUE$$");
+  for (i=lo;i<=hi;i+=step)
+    DocPrint(doc,"$$MU,\"%d\",LE=%d$$\n",i,i);
+  if (footer)
+    DocPrint(doc,"%s",footer);
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i;
+}
+
+public F64 PopUpRangeF64(F64 lo,F64 hi,F64 step,
+    U8 *fmt="%9.4f",U8 *header=NULL,U8 *footer=NULL)
+{//Evenly-spaced F64 range chooser in PopUp win task.
+  F64 d;
+  I64 i;
+  U8 buf[STR_LEN];
+  CDoc *doc=DocNew;
+  if (header)
+    DocPrint(doc,"%s",header);
+  DocPrint(doc,"$$LTBLUE$$");
+  for (d=lo;d<=hi;d+=step) {
+    StrPrint(buf,fmt,d);
+    DocPrint(doc,"$$MU,\"%s\",LE=0x%X$$\n",buf,d);
+  }
+  if (footer)
+    DocPrint(doc,"%s",footer);
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i(F64);
+}
+
+public F64 PopUpRangeF64Exp(F64 lo,F64 hi,F64 factor,
+    U8 *fmt="%9.4f",U8 *header=NULL,U8 *footer=NULL)
+{//Exp-spaced F64 range chooser in PopUp win task.
+  F64 d;
+  I64 i;
+  U8 buf[STR_LEN];
+  CDoc *doc=DocNew;
+  if (header)
+    DocPrint(doc,"%s",header);
+  DocPrint(doc,"$$LTBLUE$$");
+  for (d=lo;d<=hi;d*=factor) {
+    StrPrint(buf,fmt,d);
+    DocPrint(doc,"$$MU,\"%s\",LE=0x%X$$\n",buf,d);
+  }
+  if (footer)
+    DocPrint(doc,"%s",footer);
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i(F64);
+}
+
+public F64 PopUpRangeF64Log(F64 lo,F64 hi,I64 steps,
+    U8 *fmt="%9.4f",U8 *header=NULL,U8 *footer=NULL)
+{//Log-spaced F64 range chooser in PopUp win task.
+  return PopUpRangeF64Exp(lo,hi,Exp(Ln(hi/lo)/(steps-1)),fmt,header,footer);
+}
+
+#help_index "Job/Exe;Task/Job/Exe;Compiler"
+public I64 AdamFile(U8 *filename,Bool warn_ext=TRUE)
+{//Make adam_task execute file.
+  Bool okay=TRUE;
+  U8 *name=FileNameAbs(filename),
+	*name2=DftExt(name,"HC.Z");
+  I64 res=0;
+  if (warn_ext &&
+	!FilesFindMatch(name2,FILEMASK_JIT) &&
+	!PopUpCancelOk(ST_WARN_ST "Not .HC File\n\n"))
+    okay=FALSE;
+  if (okay)
+    res=Adam("#include \"%s\";",name2);
+  Free(name2);
+  Free(name);
+  return res;
+}
+
+public I64 PopUpFile(U8 *filename,Bool warn_ext=TRUE,
+	CTask *parent=NULL,CTask **_pu_task=NULL)
+{//$LK,"ExeFile2",A="MN:ExeFile2"$() in $LK,"PopUp",A="MN:PopUp"$ task. Cont as User.
+  Bool okay=TRUE;
+  U8 *st,*name=FileNameAbs(filename),
+	*name2=DftExt(name,"HC.Z");
+  I64 res=0;
+  if (warn_ext &&
+	!FilesFindMatch(name2,FILEMASK_JIT) &&
+	!PopUpCancelOk(ST_WARN_ST "Not .HC File\n\n"))
+    okay=FALSE;
+  if (okay) {
+    st=MStrPrint(
+	  "\"$$$$WW+H,1$$$$\";In(\"ExeFile2(\\\"%s\\\",CCF_CMD_LINE);\\n\");"
+	  "UserTaskCont;",
+	  name2);
+    res=PopUp(st,parent,_pu_task);
+    Free(st);
+  }
+  Free(name2);
+  Free(name);
+  return res;
+}
+
+public I64 PopUpRunFile(U8 *filename,I64 ccf_flags=0,...)
+{//$LK,"ExeFile",A="MN:ExeFile"$() with args using $LK,"LastFun",A="MN:LastFun"$() in $LK,"PopUp",A="MN:PopUp"$ task.
+  U8 *st,*name=FileNameAbs(filename),
+	*name2=DftExt(name,"HC.Z");
+  I64 res=0;
+  st=MStrPrint(
+	"\"$$$$WW+H,1$$$$\";ExeFile2(\"%s\",0x%X);LastFun(0x%X,0x%X);",
+	name2,ccf_flags,argc,argv);
+  res=PopUp(st,Fs);
+  Free(st);
+  Free(name2);
+  Free(name);
+  return res;
+}

TempleOSCD/Adam/DolDoc/DocPutKey.HC

@@ -0,0 +1,729 @@
+#help_index "DolDoc/Output;StdOut/DolDoc"
+
+public U0 DocPutKey(CDoc *doc,I64 ch=0,I64 sc=0)
+{//$LK,"PutKey",A="MN:PutKey"$(ch,sc) at doc insert pt, cur_entry.
+  I64 i,x,y;
+  CDoc *m;
+  CDocEntry *doc_ce;
+  U8 *st,*st2;
+  Bool unlock;
+
+  if (!doc && !(doc=DocPut) || doc->doc_signature!=DOC_SIGNATURE_VAL)
+    return;
+  if (doc->user_put_key && (*doc->user_put_key)(doc,doc->user_put_data,ch,sc))
+    return;
+  unlock=DocLock(doc);
+  if (!Bt(doldoc.clean_scan_codes,sc.u8[0]))
+    doc->flags|=DOCF_UNDO_DIRTY;
+  DocCaptureUndo(doc);
+  if (Bt(char_bmp_printable,ch) && !(sc&(SCF_CTRL|SCF_ALT))) {
+    if (sc&SCF_KEY_DESC) {
+      st=Char2KeyName(ch,FALSE);
+      KeyDescSet("Char  /'%s'",st);
+      Free(st);
+    } else
+      EdCharIns(ch,sc,doc);
+  } else {
+    doc_ce=doc->cur_entry;
+    x=doc->x; y=doc->y;
+    if (sc&SCF_ALT)
+      switch (ch) {
+	case CH_BACKSPACE: //<CTRL-H>
+	  if (!(sc&(SCF_SHIFT|SCF_CTRL))) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Undo");
+	    else
+	      DocUndoRestore(doc);
+	  }
+	  break;
+      }
+    else
+      switch (ch) {
+	case 0:
+	  switch (sc.u8[0]) {
+	    case SC_CURSOR_DOWN:
+	      if (!(sc&SCF_CTRL)) {
+		if (sc&SCF_KEY_DESC) {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/Cursor Down, Sel");
+		  else
+		    KeyDescSet("Edit/Cursor Down");
+		} else
+		  EdLineDown(doc,sc);
+		break;
+	      } else
+		sc&=~SCF_CTRL;
+//Fall Through to SC_END
+	    case SC_END:
+	      if (!(sc&SCF_CTRL)) {
+		if (sc&SCF_KEY_DESC) {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/GoTo Doc End, Sel");
+		  else
+		    KeyDescSet("Edit/GoTo Doc End");
+		} else {
+		  while (doc_ce!=doc) {
+		    BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+		    doc_ce=doc->cur_entry=doc_ce->next;
+		  }
+		  doc->cur_col=doc_ce->min_col;
+		  DocFormBwd(doc);
+		}
+	      }
+	      break;
+	    case SC_CURSOR_UP:
+	      if (!(sc&SCF_CTRL)) {
+		if (sc&SCF_KEY_DESC) {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/Cursor Up, Sel");
+		  else
+		    KeyDescSet("Edit/Cursor Up");
+		} else
+		  EdLineUp(doc,sc);
+		break;
+	      } else
+		sc&=~SCF_CTRL;
+//Fall Through to SC_HOME
+	    case SC_HOME:
+	      if (!(sc&SCF_CTRL)) {
+		if (sc&SCF_KEY_DESC) {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/GoTo Top of Doc, Sel");
+		  else
+		    KeyDescSet("Edit/GoTo Top of Doc");
+		} else {
+		  if (doc_ce==doc) doc_ce=doc_ce->last;
+		  while (doc_ce!=doc) {
+		    BEqu(&doc_ce->type,DOCEt_SEL,sc&SCF_SHIFT);
+		    doc_ce=doc->cur_entry=doc_ce->last;
+		  }
+		  doc_ce=doc->cur_entry=doc->head.next;
+		  doc->cur_col=doc_ce->min_col;
+		  DocFormFwd(doc);
+		}
+	      }
+	      break;
+	    case SC_PAGE_DOWN:
+	      if (!(sc&SCF_CTRL)) {
+		if (sc&SCF_KEY_DESC) {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/Page Down, Sel");
+		  else
+		    KeyDescSet("Edit/Page Down");
+		} else {
+		  i=doc_ce->y+doc->win_task->win_height-1;
+		  if (doc_ce->type_u8==DOCT_HEX_ED)
+		    i+=doc->cur_col/3/doc_ce->hex_ed_width;
+		  while (doc_ce!=doc &&
+			(doc_ce->type_u8!=DOCT_HEX_ED && doc_ce->y<i ||
+			doc_ce->type_u8==DOCT_HEX_ED &&
+			doc_ce->y+doc->cur_col/3/doc_ce->hex_ed_width<i)) {
+		    EdLineDown(doc,sc);
+//paranoid check for stuck on same node
+		    if (doc->cur_entry==doc_ce && doc_ce->type_u8!=DOCT_HEX_ED)
+		      break;
+		    doc_ce=doc->cur_entry;
+		  }
+		}
+	      }
+	      break;
+	    case SC_PAGE_UP:
+	      if (!(sc&SCF_CTRL)) {
+		if (sc&SCF_KEY_DESC) {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/Page Up, Sel");
+		  else
+		    KeyDescSet("Edit/Page Up");
+		}else {
+		  i=doc_ce->y-(doc->win_task->win_height-1);
+		  if (doc_ce->type_u8==DOCT_HEX_ED)
+		    i+=doc->cur_col/3/doc_ce->hex_ed_width;
+		  while (doc_ce->last!=doc &&
+			(doc_ce->type_u8!=DOCT_HEX_ED && doc_ce->y>i ||
+			doc_ce->type_u8==DOCT_HEX_ED &&
+			doc_ce->y+doc->cur_col/3/doc_ce->hex_ed_width>i) &&
+			doc_ce->y!=doc->head.next->y) {
+		    EdLineUp(doc,sc);
+//paranoid check for stuck on same node
+		    if (doc->cur_entry==doc_ce && doc_ce->type_u8!=DOCT_HEX_ED)
+		      break;
+		    doc_ce=doc->cur_entry;
+		  }
+		}
+	      }
+	      break;
+	    case SC_CURSOR_LEFT:
+	      if (sc&SCF_KEY_DESC) {
+		if (sc&SCF_CTRL)
+		  KeyDescSet("Edit/GoTo Start of Line");
+		else {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/Cursor Left, Sel");
+		  else
+		    KeyDescSet("Edit/Cursor Left");
+		}
+	      } else
+		EdCursorLeft(doc,sc);
+	      break;
+	    case SC_CURSOR_RIGHT:
+	      if (sc&SCF_KEY_DESC) {
+		if (sc&SCF_CTRL)
+		  KeyDescSet("Edit/GoTo End of Line");
+		else {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/Cursor Right, Sel");
+		  else
+		    KeyDescSet("Edit/Cursor Right");
+		}
+	      } else
+		EdCursorRight(doc,sc);
+	      break;
+	    case SC_DELETE:
+	      if (!(sc&SCF_CTRL)) {
+		if (sc&SCF_KEY_DESC) {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/Cut To Clipboard");
+		  else
+		    KeyDescSet("Char  /Delete");
+		} else {
+		  if (sc&SCF_SHIFT)
+		    EdCutToClipboard(doc);
+		  else
+		    EdCharDel(doc);
+		}
+	      }
+	      break;
+	    case SC_INS:
+	      if (sc&(SCF_SHIFT|SCF_CTRL)!=(SCF_SHIFT|SCF_CTRL)) {
+		if (sc&SCF_KEY_DESC) {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Edit/Paste Clipboard");
+		  else if (sc&SCF_CTRL)
+		    KeyDescSet("Edit/Copy to Clipboard");
+		  else
+		    KeyDescSet("Edit/Toggle Overstrike");
+		} else {
+		  if (sc&SCF_SHIFT)
+		    EdPasteClipboard(doc);
+		  else if (sc&SCF_CTRL)
+		    EdCopyToClipboard(doc);
+		  else
+		    doc->flags^=DOCF_OVERSTRIKE;
+		}
+	      }
+	      break;
+	    case SC_F1...SC_F10:
+	      if (sc&SCF_CTRL) {
+		if (sc&SCF_KEY_DESC) {
+		  if (sc&SCF_SHIFT)
+		    KeyDescSet("Cmd /Src Code of Sym");
+		  else
+		    KeyDescSet("Edit/Autocomplete Sym");
+		} else {
+		  DocUnlock(doc);
+		  if (AutoComplete(ON)) {
+		    if (sc&SCF_SHIFT)
+		      ACMan(sc.u8[0]-SC_F1+1,Fs);
+		    else
+		      ACFillIn(sc.u8[0]-SC_F1+1);
+		  }
+		  DocLock(doc);
+		}
+	      } else {
+		switch (sc.u8[0]) {
+		  case SC_F1:
+		    if (sc&SCF_KEY_DESC) {
+		      if (sc&SCF_SHIFT)
+			KeyDescSet("Cmd /About");
+		      else
+			KeyDescSet("Cmd /Help");
+		    } else {
+		      if (sc&SCF_SHIFT)
+			Ed("::/Doc/AboutTempleOS.DD.Z");
+		      else
+			Ed("::/Doc/HelpIndex.DD.Z");
+		    }
+		    break;
+		  case SC_F2:
+		    if (sc&SCF_KEY_DESC) {
+		      if (sc&SCF_SHIFT)
+			KeyDescSet("Edit/Play Macro");
+		      else
+			KeyDescSet("Edit/Macro");
+		    } else {
+		      DocUnlock(doc);
+		      if (sc&SCF_SHIFT) {
+			if (TaskValidate(sys_macro_task))
+			  PostMsgWait(sys_macro_task,
+				MSG_KEY_DOWN_UP,CH_SHIFT_ESC,0);
+			SysMacroStripKey(&sys_macro_head,ch,sc);
+			PlaySysMacro;
+		      } else
+			EdMacroUtil;
+		      DocLock(doc);
+		    }
+		    break;
+		  case SC_F3:
+		    if (sc&SCF_KEY_DESC) {
+		      if (sc&SCF_SHIFT)
+			KeyDescSet("Edit/Find Last");
+		      else
+			KeyDescSet("Edit/Find Next");
+		    }else {
+		      doc->find_replace->scan_fwd=!(sc&SCF_SHIFT);
+		      EdFindNext(doc);
+		    }
+		    break;
+		  case SC_F4:
+		    if (sc&SCF_KEY_DESC) {
+		      if (sc&SCF_SHIFT)
+			KeyDescSet("Cmd /Insert Directory Name");
+		      else
+			KeyDescSet("Cmd /Insert FileName");
+		    } else {
+		      DocUnlock(doc);
+		      if (sc&SCF_SHIFT)
+			st=PopUpPickDir;
+		      else
+			st=PopUpPickFile;
+		      DocLock(doc);
+		      if (st) {
+			DocPrintPartial(doc,"%s",st);
+			Free(st);
+		      }
+		    }
+		    break;
+		  case SC_F5:
+		    if (sc&SCF_KEY_DESC) {
+		      if (sc&SCF_SHIFT)
+			KeyDescSet("Cmd /Adam Include");
+		      else
+			KeyDescSet("Cmd /Run (Execute)");
+		    } else {
+		      if (st2=DocEntryLink(doc,doc_ce)) {
+			st=DocLinkFile(st2);
+			Free(st2);
+		      } else {
+			DocWrite(doc);
+			st=StrNew(doc->filename.name);
+		      }
+		      if (st2=DirFile(st,"Run","HC.Z")) {
+			if (FileFind(st2)) {
+			  Free(st);
+			  st=st2;
+			} else
+			  Free(st2);
+		      }
+		      if (st) {
+			if (sc&SCF_SHIFT)
+			  AdamFile(st);
+			else
+			  PopUpFile(st);
+			Free(st);
+		      }
+		    }
+		    break;
+		  case SC_F6:
+		    if (sc&SCF_KEY_DESC) {
+		      if (sc&SCF_SHIFT)
+			KeyDescSet("Cmd /God Doodle");
+		      else
+			KeyDescSet("Cmd /God Song");
+		    } else {
+//$LK,"::/Adam/God/HSNotes.DD"$
+		      if (sc&SCF_SHIFT) {
+			DocUnlock(doc);
+			GodDoodle;
+			DocLock(doc);
+		      } else
+			GodSong;
+		    }
+		    break;
+		  case SC_F7:
+		    if (sc&SCF_KEY_DESC) {
+		      if (sc&SCF_SHIFT)
+			KeyDescSet("Cmd /God Passage");
+		      else
+			KeyDescSet("Cmd /God Word");
+		    } else {
+//$LK,"::/Adam/God/HSNotes.DD"$
+		      FifoU8Flush(god.fifo);
+		      GodBitsIns(GOD_GOOD_BITS,KbdMsEvtTime>>GOD_BAD_BITS);
+		      if (sc&SCF_SHIFT)
+			GodBiblePassage;
+		      else
+			GodWord;
+		    }
+		    break;
+		}
+	      }
+	      break;
+	  }
+	  break;
+	case CH_CTRLA:
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Save As");
+	    else if (DocWrite(doc,TRUE)&&(st=FileNameAbs(doc->filename.name))) {
+	      DirContextDel(doc->filename.dirc);
+	      doc->filename.dirc=DirContextNew(st);
+	      Free(st);
+	    }
+	  }
+	  break;
+	case CH_CTRLB:
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Cmd /Toggle Border");
+	    else
+	      WinBorder(Bt(&doc->win_task->display_flags,
+		    DISPLAYf_NO_BORDER),doc->win_task);
+	  }
+	  break;
+	case CH_CTRLC:
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Copy to Clipboard");
+	    else
+	      EdCopyToClipboard(doc);
+	  }
+	  break;
+	case CH_CTRLD:
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Cmd /File Manager");
+	    else {
+	      DocUnlock(doc);
+	      FileMgr;
+	      DocLock(doc);
+	    }
+	  }
+	  break;
+	case CH_CTRLF:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Cmd /Search Files");
+	    else
+	      FindWiz;
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Find & Replace");
+	    else
+	      EdFindReplace(doc);
+	  }
+	  break;
+	case CH_CTRLG:
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/GoTo Line Num");
+	    else
+	      EdGoToLine(doc);
+	  }
+	  break;
+	case CH_BACKSPACE: //<CTRL-H>
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Char  /Back Space");
+	    else {
+	      DocCaptureUndo(doc);
+	      doc_ce=doc->cur_entry;
+	      if (doc->cur_col<=doc_ce->min_col) {
+		doc_ce=doc->cur_entry=doc_ce->last;
+		if (doc_ce!=doc && doc_ce->type_u8==DOCT_SOFT_NEW_LINE)
+		  doc_ce=doc->cur_entry=doc_ce->last;
+		if (doc_ce==doc || doc_ce->type_u8==DOCT_PMT) {
+		  doc_ce=doc->cur_entry=doc_ce->next;
+		  doc->cur_col=doc_ce->min_col;
+		} else {
+		  doc->cur_col=doc_ce->max_col;
+		  if (doc->cur_col>doc_ce->min_col)
+		    doc->cur_col--;
+		  EdCharDel(doc);
+		}
+	      } else {
+		doc->cur_col--;
+		EdCharDel(doc);
+	      }
+	    }
+	  }
+	  break;
+	case CH_CTRLI:
+	  if (sc.u8[0]!=SC_TAB) {
+	    if (sc&SCF_SHIFT) {
+	      if (sc&SCF_KEY_DESC)
+		KeyDescSet("Dol /Unindent 2");
+	      else
+		DocPrint(doc,"$$ID,-2$$");
+	    } else {
+	      if (sc&SCF_KEY_DESC)
+		KeyDescSet("Dol /Indent 2");
+	      else
+		DocPrint(doc,"$$ID,2$$");
+	    }
+	  }
+	  break;
+	case '\n':
+	  if (sc&SCF_KEY_DESC) {
+	    if (sc&SCF_SHIFT)
+	      KeyDescSet("Char  /Return");
+	    else
+	      KeyDescSet("Char  /Page Break");
+	  } else
+	    EdCharIns(ch,sc,doc);
+	  break;
+	case CH_CTRLK:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Blinking Text Off");
+	    else
+	      DocPrint(doc,"$$BK,0$$");
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Blinking Text On");
+	    else
+	      DocPrint(doc,"$$BK,1$$");
+	  }
+	  break;
+	case CH_CTRLL:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Cmd /Code Tools");
+	    else {
+	      DocUnlock(doc);
+	      EdCodeTools(doc);
+	      DocLock(doc);
+	    }
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Cmd /Insert Text Widgets Wizard");
+	    else {
+	      DocUnlock(doc);
+	      EdInsWidgetWiz;
+	      DocLock(doc);
+	    }
+	  }
+	  break;
+	case CH_CTRLM:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Cmd /Personal Notes");
+	    else
+	      Ed("~/PersonalNotes.DD.Z");
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Cmd /Personal Menu");
+	    else {
+	      m=DocRead("~/PersonalMenu.DD.Z");
+	      DocMenu(m);
+	      DocDel(m);
+	    }
+	  }
+	  break;
+	case CH_CTRLO:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Collapse");
+	    else
+	      DocCollapse(TRUE,doc);
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Uncolapse");
+	    else
+	      DocCollapse(FALSE,doc);
+	  }
+	  break;
+	case CH_CTRLP:
+	  if (doc->flags & (DOCF_SUPERSCRIPT_MODE | DOCF_SUBSCRIPT_MODE)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Toggle Super or Sub script");
+	    else {
+	      DocPrint(doc,"$$SY,0$$");
+	      doc->flags&=~(DOCF_SUPERSCRIPT_MODE | DOCF_SUBSCRIPT_MODE);
+	    }
+	  } else if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Toggle Subscript");
+	    else {
+	      DocPrint(doc,"$$SY,3$$");
+	      doc->flags|=DOCF_SUBSCRIPT_MODE;
+	    }
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Toggle Superscript");
+	    else {
+	      DocPrint(doc,"$$SY,-3$$");
+	      doc->flags|=DOCF_SUPERSCRIPT_MODE;
+	    }
+	  }
+	  break;
+	case CH_CTRLQ:
+	  break;
+	case CH_CTRLR:
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Cmd /Sprite Graphic Resource");
+	    else
+	      if (!(doc->flags&DOCF_FORM) &&
+		    !(doc->flags&(DOCF_PLAIN_TEXT|DOCF_PLAIN_TEXT_TABS))) {
+		DocUnlock(doc);
+		if (doc_ce->type_u8==DOCT_SPRITE)
+		  EdSpriteEd(doc);
+		else
+		  EdSpriteIns(doc);
+		DocLock(doc);
+	      }
+	  }
+	  break;
+	case CH_CTRLS:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Find Misspelled");
+	    else
+	      ACMisspelledFind(doc);
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Save");
+	    else
+	      DocWrite(doc);
+	  }
+	  break;
+	case CH_CTRLT:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Single Entry Toggle Plain Text");
+	    else if (!(doc->flags&DOCF_FORM))
+	      DocEntryToggle(doc);
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Toggle Plain Text Display");
+	    else if (!(doc->flags&DOCF_FORM))
+	      DocFlagsToggle(doc,DOCF_PLAIN_TEXT);
+	  }
+	  break;
+	case CH_CTRLU:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Underline Off");
+	    else
+	      DocPrint(doc,"$$UL,0$$");
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Underline On");
+	    else
+	      DocPrint(doc,"$$UL,1$$");
+	  }
+	  break;
+	case CH_CTRLV:
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Paste Clipboard");
+	    else
+	      EdPasteClipboard(doc);
+	  }
+	  break;
+	case CH_CTRLW:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Word Wrap Off");
+	    else
+	      DocPrint(doc,"$$WW,0$$");
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Word Wrap On");
+	    else
+	      DocPrint(doc,"$$WW,1$$");
+	  }
+	  break;
+	case CH_CTRLX:
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Cut To Clipboard");
+	    else
+	      EdCutToClipboard(doc);
+	  }
+	  break;
+	case CH_CTRLY:
+	  if (!(sc&SCF_SHIFT)) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Edit/Delete Line");
+	    else
+	      EdLineDel(doc);
+	  }
+	  break;
+	case CH_CTRLZ:
+	  if (sc&SCF_SHIFT) {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Inverted Text Off");
+	    else
+	      DocPrint(doc,"$$IV,0$$");
+	  } else {
+	    if (sc&SCF_KEY_DESC)
+	      KeyDescSet("Dol /Inverted Text On");
+	    else
+	      DocPrint(doc,"$$IV,1$$");
+	  }
+	  break;
+	case '0'...'9':
+	  if (sc&SCF_CTRL) {
+	    if (sc&SCF_KEY_DESC) {
+	      if (sc&SCF_SHIFT)
+		KeyDescSet("Cmd /Word Definition");
+	      else
+		KeyDescSet("Edit/Autocomplete Word");
+	    } else {
+	      if (AutoComplete(ON)) {
+		DocUnlock(doc);
+		if (sc&SCF_SHIFT)
+		  ACDDef(ch-'0',Fs);
+		else
+		  ACDFillin(ch-'0');
+		DocLock(doc);
+	      }
+	    }
+	  }
+	  break;
+	case '[':
+	  if (sc&SCF_CTRL) {
+	    if (sc&SCF_SHIFT) {
+	      if (sc&SCF_KEY_DESC)
+		KeyDescSet("Edit/GoTo matching brace");
+	      else
+		EdFindPaired(doc,'}','{',FALSE);
+	    } else {
+	      if (sc&SCF_KEY_DESC)
+		KeyDescSet("Edit/GoTo matching bracket");
+	      else
+		EdFindPaired(doc,']','[',FALSE);
+	    }
+	  }
+	  break;
+	case ']':
+	  if (sc&SCF_CTRL) {
+	    if (sc&SCF_SHIFT) {
+	      if (sc&SCF_KEY_DESC)
+		KeyDescSet("Edit/GoTo matching brace");
+	      else
+		EdFindPaired(doc,'{','}',TRUE);
+	    } else {
+	      if (sc&SCF_KEY_DESC)
+		KeyDescSet("Edit/GoTo matching bracket");
+	      else
+		EdFindPaired(doc,'[',']',TRUE);
+	    }
+	  }
+	  break;
+      }
+  }
+  if (unlock)
+    DocUnlock(doc);
+  if (!(doc->flags&DOCF_DONT_SWAP_OUT))
+    Yield;
+}
+
+Bool KDDocPutKey(I64 ch,I64 scan_code)
+{
+  CDoc *doc;
+  if (doc=DocPut)
+    DocPutKey(doc,ch,scan_code);
+  return FALSE;
+}

TempleOSCD/Adam/DolDoc/DocPutS.HC

@@ -0,0 +1,336 @@
+#help_index "DolDoc/Output;StdOut/DolDoc"
+
+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 or NULL.
+  U8 *ptr=st,*ptr2,*st2,*ptr3,*ptr4,*src,
+	*char_bmp;
+  Bool unlock;
+  I64 ch,j;
+  CDocEntry *doc_e=NULL,*res=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_TABS)
+    char_bmp=char_bmp_zero_cr_nl_cursor;
+  else if (doc->flags & DOCF_PLAIN_TEXT)
+    char_bmp=char_bmp_zero_tab_cr_nl_cursor;
+  else
+    char_bmp=char_bmp_zero_tab_cr_nl_cursor_dollar;
+  doc_ce=doc->cur_entry;
+  while (*ptr) {
+    ptr2=ptr;
+    do ch=*ptr++;
+    while (!Bt(char_bmp,ch) || ch==CH_CURSOR && doc->flags&DOCF_NO_CURSOR);
+    ptr--;
+    if (!ch) {
+      if (j=ptr-ptr2) {
+	doc_e=DocEntryNewBase(doc,
+	      DOCT_TEXT|doc->settings_head.dft_text_attr<<8);
+	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=DocEntryNewBase(doc,
+	      DOCT_TEXT|doc->settings_head.dft_text_attr<<8);
+	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=DocEntryNewBase(doc,
+		DOCT_CURSOR|doc->settings_head.dft_text_attr<<8);
+	  DocInsEntry(doc,doc_e);
+	  ptr++;
+	  break;
+	case '\t':
+	  doc_e=DocEntryNewBase(doc,
+		DOCT_TAB|doc->settings_head.dft_text_attr<<8);
+	  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=DocEntryNewBase(doc,
+		    DOCT_CURSOR|doc->settings_head.dft_text_attr<<8);
+	      DocInsEntry(doc,doc_e);
+	      ptr2++;
+	    }
+	    if (ptr==ptr2) {
+	      doc_e=DocEntryNewBase(doc,
+		    DOCT_TEXT|doc->settings_head.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);
+	      DocInsEntry(doc,doc_e);
+	    } else {
+	      st2=MAlloc(ptr-ptr2+1);
+	      ptr3=ptr2;
+	      ptr4=st2;
+	      while (ch=*ptr3++) {
+		if (ch==CH_CURSOR) {
+		  doc_e=DocEntryNewBase(doc,
+			DOCT_CURSOR|doc->settings_head.dft_text_attr<<8);
+		  DocInsEntry(doc,doc_e);
+		} else
+		  *ptr4++=ch;
+	      }
+	      *ptr4=0;
+	      if (doc_e=PrsDollarCmd(doc,st2)) {
+		res=doc_e;
+		DocInsEntry(doc,doc_e);
+	      }
+	      Free(st2);
+	    }
+	    *ptr++='$$';
+	  }
+	  break;
+	default:
+	  doc_e=DocEntryNewBase(doc,
+		DOCT_NEW_LINE|doc->settings_head.dft_text_attr<<8);
+	  DocInsEntry(doc,doc_e);
+	  if (ch=='\r')
+	    while (*ptr=='\r')
+	      ptr++;
+	  if (*ptr=='\n')
+	    ptr++;
+	  while (*ptr=='\r')
+	    ptr++;
+      }
+    }
+  }
+  if (unlock)
+    DocUnlock(doc);
+  return res;
+}
+
+public CDocEntry *DocPrint(CDoc *doc=NULL,U8 *fmt,...)
+{//You must not print partial doc cmds.
+//Returns last newly created dollar-sign CDocEntry or NULL.
+  U8 *buf=StrPrintJoin(NULL,fmt,argc,argv);
+  CDocEntry *res=DocPutS(doc,buf);
+  Free(buf);
+  return res;
+}
+
+public U0 DocPrintPartial(CDoc *doc=NULL,U8 *fmt,...)
+{//Lets you print half a doc cmd, if you like.
+  U8 *buf,*st,*src,*dst,*ptr,*ptr2;
+  Bool unlock;
+  CDocEntry *doc_ce,*doc_ne;
+  I64 ch,i,j;
+  if (!doc && !(doc=DocPut))
+    return;
+  buf=StrPrintJoin(NULL,fmt,argc,argv);
+  ptr=buf;
+  if (doc->user_put_s && (*doc->user_put_s)(doc,doc->user_put_data,buf)) {
+    Free(buf);
+    return;
+  }
+  unlock=DocLock(doc);
+  if (doc->cur_entry->type_u8==DOCT_DATA)
+    while (ch=*ptr++)
+      DocPutKey(doc,ch,0);
+  else
+    while (ch=*ptr) {
+      if (!Bt(char_bmp_safe_dollar,ch) ||
+	    doc->flags & (DOCF_OVERSTRIKE|DOCF_IN_DOLLAR)) {
+	DocPutKey(doc,ch,0);
+	ptr++;
+      } else {
+	ptr2=ptr++;
+	while (TRUE) {
+	  ch=*ptr++;
+	  if (!Bt(char_bmp_safe_dollar,ch))
+	    break;
+	}
+	ptr--;
+	*ptr=0;
+	doc_ce=doc->cur_entry;
+	j=ptr-ptr2;
+	if (IsEditableText(doc_ce)) {
+	  dst=st=MAlloc(doc_ce->max_col+j+1,doc->mem_task);
+	  src=doc_ce->tag;
+	  i=doc->cur_col;
+	  doc->cur_col+=j;
+	  doc_ce->max_col+=j;
+	  while (i-->0)
+	    *dst++=*src++;
+	  while (j-->0)
+	    *dst++=*ptr2++;
+	  while (*dst++=*src++);
+	  Free(doc_ce->tag);
+	  doc_ce->tag=st;
+	} else {
+	  doc_ne=DocEntryNewTag(doc,doc_ce,ptr2);
+	  doc_ne->type=DOCT_TEXT|doc->settings_head.dft_text_attr<<8;
+	  doc_ne->de_flags=doldoc.dft_de_flags[DOCT_TEXT];
+	  QueIns(doc_ne,doc_ce->last);
+	  doc->cur_entry=doc_ne;
+	  doc->cur_col=StrLen(ptr2);
+	}
+	*ptr=ch;
+	DocRemSoftNewLines(doc,doc->cur_entry);
+      }
+    }
+  if (unlock)
+    DocUnlock(doc);
+  if (!(doc->flags&DOCF_DONT_SWAP_OUT))
+    Yield;
+  Free(buf);
+}
+
+Bool KDDocPutS(U8 *st)
+{
+  CDoc *doc;
+  if (doc=DocPut)
+    DocPrintPartial(doc,"%s",st);
+  return FALSE;
+}
+
+public U0 DocPrintAtomic(CDoc *doc=NULL,U8 *fmt,...)
+{//Prints multiple whole cmds all-at-once. Might need this when printing trees.
+  U8 *buf;
+  Bool unlock;
+  I64 old_flags;
+  if (!doc && !(doc=DocPut))
+    return;
+  buf=StrPrintJoin(NULL,fmt,argc,argv);
+  unlock=DocLock(doc);
+  old_flags=doc->flags;
+  doc->flags|=DOCF_NO_CURSOR;
+  DocPrint(doc,"%s",buf);
+  DocRecalc(doc);
+  doc->flags=old_flags;
+  if (unlock)
+    DocUnlock(doc);
+  Free(buf);
+}
+
+U0 DocDump(CDoc *doc,I64 uS_delay=0)
+{
+  U8 *st;
+  CDocEntry *doc_e,*doc_e2;
+  Bool unlock=DocLock(doc);
+  doc_e=doc->head.next;
+  while (doc_e!=doc) {
+    st=DocScanLine(doc,doc_e,NULL,&doc_e2);
+    "%s",st;
+    Free(st);
+    doc_e=doc_e2;
+    if (doc_e->type_u8==DOCT_NEW_LINE) {
+      '\n';
+      Busy(uS_delay);
+      doc_e=doc_e->next;
+    }
+  }
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public CDocEntry *DocPutLine(CDoc *doc=NULL,CDocEntry *doc_e)
+{//Send line from other doc to StdOut $LK,"DocPut",A="MN:DocPut"$.
+  I64 ch;
+  U8 *ptr,*ptr2;
+  Bool unlock;
+  if (!doc && !(doc=DocPut) || doc->doc_signature!=DOC_SIGNATURE_VAL)
+    return NULL;
+  unlock=DocLock(doc);
+  while (doc_e!=doc && doc_e->type_u8!=DOCT_NEW_LINE) {
+    if (doc_e->de_flags&DOCEF_TAG) {
+      ptr=doc_e->tag;
+      do {
+	ptr2=ptr;
+	while (ch=*ptr)
+	  if (ch=='$$')
+	    break;
+	  else
+	    ptr++;
+	*ptr=0;
+	"%s",ptr2;
+	*ptr=ch;
+	if (ch=='$$') {
+	  "$$$$";
+	  ptr++;
+	}
+      } while (ch);
+    } else if (doc_e->type_u8==DOCT_TAB)
+      '\t';
+    doc_e=doc_e->next;
+  }
+  '\n';
+  if (doc_e!=doc)
+    doc_e=doc_e->next;
+  if (unlock)
+    DocUnlock(doc);
+  return doc_e;
+}
+
+#help_index "Debugging/Dump;DolDoc/Cmd Line (Typically);"\
+	"Cmd Line (Typically);DolDoc/Output;StdOut/DolDoc"
+public U0 DocDm(U8 *buf,I64 cnt=0x80)
+{//Dump live chunk of mem showing addresses. Can be edited.
+  CDocEntry *doc_e;
+  CDoc *doc=DocPut;
+  Bool unlock=DocLock(doc);
+  doc_e=DocPrint(doc,"$$HX-Z,%d,16$$",cnt);
+  doc_e->data=buf;
+  doc->cur_entry=doc_e->next;
+  DocRecalc(doc);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 DocD(U8 *buf,I64 cnt=0x80)
+{//Dump live chunk of mem showing offsets. Can be edited.
+  CDocEntry *doc_e;
+  CDoc *doc=DocPut;
+  Bool unlock=DocLock(doc);
+  doc_e=DocPrint(doc,"$$HX,%d,16$$",cnt);
+  doc_e->data=buf;
+  doc->cur_entry=doc_e->next;
+  DocRecalc(doc);
+  if (unlock)
+    DocUnlock(doc);
+}

TempleOSCD/Adam/DolDoc/DocRecalcLib.HC

@@ -0,0 +1,213 @@
+#help_index "DolDoc"
+
+I64 DocCharDist(CDoc *doc,I64 x,I64 y)
+{
+#assert FONT_WIDTH==FONT_HEIGHT
+  return (SqrI64(doc->x-x)+SqrI64(doc->y-y))*FONT_WIDTH*FONT_WIDTH;
+}
+
+U0 DocDelToNum(CDoc *doc,I64 num)
+{
+  CDocEntry *doc_e=doc->head.next,*doc_e2;
+  while (num-->0 && doc_e!=doc) {
+    doc_e2=doc_e->next;
+    if (!(doc_e->de_flags & (DOCEF_HOLD|DOCEF_FILTER_SKIP))) {
+      if (doc_e==doc->cur_entry) {
+	doc->cur_entry=doc_e2;
+	doc->cur_col=doc_e2->min_col;
+      }
+      DocEntryDel(doc,doc_e);
+    }
+    doc_e=doc_e2;
+  }
+}
+
+U0 DocDelToEntry(CDoc *doc,CDocEntry *clear_entry,Bool clear_holds)
+{
+  CDocEntry *doc_e=doc->head.next,*doc_e2;
+  while (doc_e!=doc) {
+    doc_e2=doc_e->next;
+    if (!(doc_e->de_flags & (DOCEF_HOLD|DOCEF_FILTER_SKIP))||clear_holds) {
+      if (doc_e==doc->cur_entry) {
+	doc->cur_entry=doc_e2;
+	doc->cur_col=doc_e2->min_col;
+      }
+      DocEntryDel(doc,doc_e);
+    }
+    if (doc_e==clear_entry)
+      break;
+    doc_e=doc_e2;
+  }
+}
+
+U0 DocBorderLstDraw(CDoc *doc)
+{
+  CTask *win_task=doc->win_task;
+  I64 i,y=-1,attr=win_task->border_attr<<8;
+  U64 ch;
+  CDoc *tmpl=doc;
+  CD3I64 saved_scroll;
+  while (tmpl && tmpl->doc_signature==DOC_SIGNATURE_VAL) {
+    y+=(Bsr(tmpl->desc)+7)>>3+1; //StrLen+1
+    tmpl=tmpl->parent_doc;
+  }
+  tmpl=doc;
+  if (y>win_task->win_height)
+    y=win_task->win_height;
+  WinScrollNull(win_task,&saved_scroll);
+  while (tmpl && tmpl->doc_signature==DOC_SIGNATURE_VAL) {
+    ch=tmpl->desc;
+    i=(Bsr(ch)+7)>>3;	//StrLen
+    ch=EndianI64(ch<<((8-i)<<3));
+    attr=win_task->border_attr<<8;
+    while (i-- && y>0) {
+      TextChar(win_task,TRUE,-1,--y,attr+ch&0xFF);
+      ch>>=8;
+    }
+    y--;
+    tmpl=tmpl->parent_doc;
+  }
+  WinScrollRestore(win_task,&saved_scroll);
+}
+
+public U0 DocTop(CDoc *doc=NULL)
+{//Move cursor, cur_entry, to top.
+  Bool unlock;
+  if (!doc && !(doc=DocPut))
+    return;
+  unlock=DocLock(doc);
+  doc->cur_entry=doc->head.next;
+  doc->cur_col=doc->cur_entry->min_col;
+  doc->x=0;
+  doc->y=0;
+  doc->line_start_col=0;
+  doc->top_line_num=0;
+
+  DocFormFwd(doc);
+  DocRecalc(doc);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 DocCenter(CDoc *doc=NULL,I64 recalc_flags=RECALCt_NORMAL)
+{//Center win on doc cursor, cur_entry.
+  Bool unlock;
+  CTask *task;
+  if (!doc && !(doc=DocPut))
+    return;
+  unlock=DocLock(doc);
+  task=doc->win_task;
+  DocRecalc(doc,recalc_flags);
+  if (!(doc->flags&DOCF_BORDER_DOC))
+    doc->top_line_num=doc->y-(task->win_height+1)>>1;
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 DocBottom(CDoc *doc=NULL)
+{//Move cursor, cur_entry, to bottom.
+  Bool unlock;
+  if (!doc && !(doc=DocPut))
+    return;
+  unlock=DocLock(doc);
+  doc->cur_entry=doc;
+  doc->cur_col=0;
+  DocRecalc(doc);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public U0 DocClear(CDoc *doc=NULL,Bool clear_holds=FALSE)
+{//Clear all doc entries, except +H, hold entries.
+  Bool unlock;
+  if (!doc && !(doc=DocPut))
+    return;
+  unlock=DocLock(doc);
+  DocBottom(doc);
+  if (clear_holds)
+    DocPrint(doc,"$$CL+H$$");
+  else
+    DocPrint(doc,"$$CL$$");
+  DocRecalc(doc);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+public Bool DocCursor(Bool show=OFF,CDoc *doc=NULL)
+{//Show or hide cursor.
+  if (!doc && !(doc=DocPut))
+    return FALSE;
+  return !LBEqu(&doc->flags,DOCf_HIDE_CURSOR,!show);
+}
+
+public Bool DocHighlightCursor(Bool show=OFF,CDoc *doc=NULL)
+{//Highlight or Don't highlight cursor.
+  if (!doc && !(doc=DocPut))
+    return FALSE;
+  return !LBEqu(&doc->flags,DOCf_DONT_HIGHLIGHT_CURSOR,!show);
+}
+
+public Bool DocScroll(Bool val=OFF,CDoc *doc=NULL)
+{//Turn scroll bars OFF/ON.
+  if (!doc && !(doc=DocPut))
+    return FALSE;
+  return !LBEqu(&doc->flags,DOCf_NO_SCROLL_BARS,!val);
+}
+
+public U0 DocCollapse(Bool collapse=TRUE,CDoc *doc=NULL)
+{//Collapse or uncollapse all tree widgets.
+  CDocEntry *doc_e;
+  Bool unlock;
+  if (!doc && !(doc=DocPut))
+    return;
+  unlock=DocLock(doc);
+  doc_e=doc->head.next;
+  while (doc_e!=doc) {
+    if (doc_e->de_flags&DOCEF_TREE)
+      BEqu(&doc_e->de_flags,DOCEf_CHECKED_COLLAPSED,collapse);
+    doc_e=doc_e->next;
+  }
+  DocRecalc(doc);
+  if (unlock)
+    DocUnlock(doc);
+}
+
+#help_index "DolDoc/Cmd Line (Typically);Cmd Line (Typically)"
+public I64 DocMax(I64 i=I64_MAX)
+{//Set max document entries. (Cmd line buffer size.)
+//Adjusts the size of the cmd line buf.
+  //Normally, the cmd line deletes entries
+  //when more are added and the old scroll up.
+  //See $LK,"max_entries",A="FF:::/Adam/DolDoc/DocTerm.HC,max_entries"$.
+  I64 res;
+  CDoc *doc;
+  if (doc=DocPut) {
+    res=doc->max_entries;
+    doc->max_entries=i;
+    return res;
+  } else
+    return 0;
+}
+
+#help_index "DolDoc/Task;StdOut/Task"
+U0 DocUpdateTaskDocs(CTask *task)
+{//This is called from $LK,"GrUpdateTaskWin",A="MN:GrUpdateTaskWin"$() by the winmgr at 30fps.
+  CDoc *doc;
+  CD3I64 saved_scroll;
+  if (task->border_src==BDS_CUR_DRV && task->cur_dv)
+    task->border_attr=DrvTextAttrGet(Drv2Let(task->cur_dv));
+  if (task->title_src==TTS_TASK_NAME)
+    StrCpy(task->task_title,task->task_name);
+  if ((doc=DocDisplay(task)) && !(doc->flags&DOCF_DONT_SHOW)) {
+    if (task->border_src==BDS_ED_FILENAME_DRV)
+      task->border_attr=DrvTextAttrGet(*doc->filename.name);
+    if (task->title_src==TTS_ED_FILENAME)
+      MemCpy(task->task_title,doc->filename.name,STR_LEN-1);
+    DocRecalc(doc,RECALCt_TO_SCRN|RECALCF_HAS_CURSOR);
+  }
+  if ((doc=DocBorder(task)) && !(doc->flags&DOCF_DONT_SHOW)) {
+    WinScrollNull(task,&saved_scroll);
+    DocRecalc(doc,RECALCt_TO_SCRN);
+    WinScrollRestore(task,&saved_scroll);
+  }
+}

TempleOSCD/Adam/DolDoc/DocRun.HC

@@ -0,0 +1,103 @@
+#help_index "DolDoc"
+
+public I64 DocEntryRun(CDoc *doc,CDocEntry *doc_e,
+	Bool exited,I64 *_has_action=NULL)
+{//Do action on final entry sel by user.
+//Sometimes returns locked, sometimes unlocked
+  U8 ch=doc->cmd_U8,*st;
+  I64 res=DOCM_CANCEL,has_action=FALSE;
+  CHashDefineStr *tmph;
+  DocLock(doc);
+  if (!exited) {
+    if (doc_e->de_flags & DOCEF_ESC) {
+      Msg(MSG_KEY_DOWN,CH_ESC,0,1<<JOBf_DONT_FILTER);
+      has_action=TRUE;
+      goto er_done;
+    } if (doc_e->de_flags & DOCEF_QUIT) {
+      Msg(MSG_KEY_DOWN,CH_SHIFT_ESC,0,1<<JOBf_DONT_FILTER);
+      has_action=TRUE;
+      goto er_done;
+    } else if (doc_e->de_flags & DOCEF_CHECK_COLLAPSABLE) {
+      doc_e->de_flags^=DOCEF_CHECKED_COLLAPSED;
+      has_action=TRUE;
+    }
+  }
+  try {
+    if (ch==CH_SPACE) {
+      if (doc_e->de_flags & DOCEF_LINK && doc->left_click_link) {
+	res=(*doc->left_click_link)(doc,doc_e);
+	has_action=TRUE;
+      }
+      if (doc_e->de_flags & DOCEF_LEFT_EXP) {
+	res=doc_e->left_exp;
+	has_action=TRUE;
+	Msg(MSG_CMD,res,0,1<<JOBf_DONT_FILTER);
+      }
+      if (doc_e->de_flags & DOCEF_LEFT_CB && doc_e->left_cb) {
+	DocUnlock(doc);
+	res=(*doc_e->left_cb)(doc,doc_e);
+	has_action=TRUE;
+	Msg(MSG_CMD,res,0,1<<JOBf_DONT_FILTER);
+      }
+      if (doc_e->de_flags & DOCEF_LEFT_MACRO) {
+	if (doc_e->de_flags & DOCEF_POPUP) {
+	  st=StrNew(doc_e->left_macro);
+	  DocUnlock(doc);
+	  PopUp(st,Fs);
+	  Free(st);
+	} else {
+	  if (doc_e->de_flags & DOCEF_LEFT_IN_STR)
+	    InStr("%s",doc_e->left_macro);
+	  else
+	    In("%s",doc_e->left_macro);
+	}
+	has_action=TRUE;
+      }
+      if (!exited && doc_e->de_flags & DOCEF_LST &&
+	    doc_e->de_flags & DOCEF_DEFINE &&
+	    (tmph=HashFind(doc_e->define_str,
+	    doc->win_task->hash_table,HTT_DEFINE_STR)) &&
+	    (res=PopUpPickLst(tmph->data))!=DOCM_CANCEL) {
+	DocDataFmt(doc,doc_e,res);
+	DocDataScan(doc,doc_e);
+	has_action=TRUE;
+      }
+    } else if (ch=='\n') {
+      if (doc_e->de_flags & DOCEF_LINK && doc->right_click_link) {
+	res=(*doc->right_click_link)(doc,doc_e);
+	has_action=TRUE;
+      }
+      if (doc_e->de_flags & DOCEF_RIGHT_EXP) {
+	res=doc_e->right_exp;
+	has_action=TRUE;
+	Msg(MSG_CMD,res,0,1<<JOBf_DONT_FILTER);
+      }
+      if (doc_e->de_flags & DOCEF_RIGHT_CB && doc_e->right_cb) {
+	DocUnlock(doc);
+	res=(*doc_e->right_cb)(doc,doc_e);
+	has_action=TRUE;
+	Msg(MSG_CMD,res,0,1<<JOBf_DONT_FILTER);
+      }
+      if (doc_e->de_flags & DOCEF_RIGHT_MACRO) {
+	if (doc_e->de_flags & DOCEF_POPUP) {
+	  st=StrNew(doc_e->right_macro);
+	  DocUnlock(doc);
+	  PopUp(st,Fs);
+	  Free(st);
+	} else {
+	  if (doc_e->de_flags & DOCEF_RIGHT_IN_STR)
+	    InStr("%s",doc_e->right_macro);
+	  else
+	    In("%s",doc_e->right_macro);
+	}
+	has_action=TRUE;
+      }
+    }
+  }
+  catch
+    DocBottom(doc);
+  doc->cmd_U8=CH_SPACE;
+er_done:
+  if (_has_action) *_has_action=has_action;
+  return res;
+}

TempleOSCD/Adam/DolDoc/DocTerm.HC

@@ -0,0 +1,213 @@
+#help_index "DolDoc/Task;StdOut/Task"
+public CDoc *DocBorderNew(CDoc *pdoc)
+{//Make new std border doc.
+  CDocEntry *doc_e;
+  CDoc *bdoc;
+
+  bdoc=DocNew;
+  bdoc->flags|=DOCF_BORDER_DOC;
+  if (pdoc) {
+    DocPrint(bdoc,"$$CM+H+BY+RX+NC,-7,1$$");
+    doc_e=DocPrint(bdoc,"$$TX+H+BD+TC,\" \"$$");
+    doc_e->user_data=pdoc;
+    doc_e->tag_cb=&EdFilterCB;
+    doc_e=DocPrint(bdoc,"$$TX+H+BD+TC,\" \"$$");
+    doc_e->user_data=pdoc;
+    doc_e->tag_cb=&EdOverStrikeCB;
+    doc_e=DocPrint(bdoc,"$$TX+H+BD+TC,\" \"$$");
+    doc_e->user_data=pdoc;
+    doc_e->tag_cb=&EdDollarCB;
+    DocPrint(bdoc,"$$CM+H+BY+RX+NC,-18,1$$");
+    doc_e=DocPrint(bdoc,"$$TX+BD+TC,\"     \"$$");
+    doc_e->user_data=pdoc;
+    doc_e->tag_cb=&EdMoreCB;
+    doc_e=DocPrint(bdoc,"$$TX+H+BD+TC,\" \"$$");
+    doc_e->user_data=pdoc;
+    doc_e->tag_cb=&EdDollarTypeCB;
+  }
+  DocPrint(bdoc,"$$CM+H+TY+NC,0,-1$$");
+  doc_e=DocPrint(bdoc,"$$DA+H-TRM-P+BD+RD+CX+IV,LEN=STR_LEN-1,"
+	"A=\"%%s...\",SCX=15$$");
+  doc_e->data=&Fs->task_title;
+  DocDataFmt(bdoc,doc_e);
+  DocPrint(bdoc,"$$CM+H+NC,1,0$$$$TX+H+BD+IV,\"%X\"$$",Fs);
+  DocPrint(bdoc,"$$TX+H+RX+BD,\"[X]\"$$");
+  DocPrint(bdoc,"$$BK,1$$$$TX+H+LX+BD,\"MENU\"$$$$BK,0$$");
+  return bdoc;
+}
+
+public U0 DocTermNew()
+{//Make into term win task with Put/Display/Border docs.
+  CDoc *pdoc=DocNew;
+  pdoc->right_click_link=&TermRightClickLink;
+  pdoc->max_entries=4096;
+  Fs->border_src=BDS_CUR_DRV;
+  pdoc->desc='Term';
+  Fs->put_doc=Fs->display_doc=pdoc;
+  Fs->border_doc=DocBorderNew(pdoc);
+  Fs->cur_menu=MenuFile("::/Doc/EdPullDown.DD");
+  WinScrollsInit(Fs);
+  Raw(OFF);
+}
+
+#help_index "DolDoc"
+
+#define RIGHT_INCLUDE	0
+#define RIGHT_AINCLUDE	1
+#define RIGHT_COPY	2
+#define RIGHT_MOVE	3
+#define RIGHT_DELETE	4
+#define RIGHT_TYPE	5
+#define RIGHT_ED	6
+#define RIGHT_MOUNT	7
+#define RIGHT_PLAIN	8
+#define RIGHT_INFILE	9
+
+I64 PopUpTermRight(U8 *header)
+{
+  I64 i;
+  CDoc *doc=DocNew;
+  if (header) DocPrint(doc,"%s",header);
+  DocPrint(doc,"\n\n"
+	"TXT=%s\nDD =%s\nJIT=%s\nGR =%s"
+	"$$CM+LX,1,3 $$$$BT,\"INCLUDE           JIT\",LE=RIGHT_INCLUDE$$"
+	"$$CM+LX,25,0$$$$BT,\"ADAM_INCLUDE      JIT\",LE=RIGHT_AINCLUDE$$"
+	"$$CM+LX,1,3 $$$$BT,\"COPY                 \",LE=RIGHT_COPY$$"
+	"$$CM+LX,25,0$$$$BT,\"MOVE OR RENAME       \",LE=RIGHT_MOVE$$"
+	"$$CM+LX,1,3 $$$$BT,\"DELETE               \",LE=RIGHT_DELETE$$"
+	"$$CM+LX,25,0$$$$BT,\"TYPE           TXT;GR\",LE=RIGHT_TYPE$$"
+	"$$CM+LX,1,3 $$$$BT,\"DOLDOC EDIT        DD\",LE=RIGHT_ED$$"
+	"$$CM+LX,25,0$$$$BT,\"MOUNT           ISO.C\",LE=RIGHT_MOUNT$$"
+	"$$CM+LX,1,3 $$$$BT,\"PLAIN TEXT EDIT   TXT\",LE=RIGHT_PLAIN$$"
+	"$$CM+LX,25,0$$$$BT,\"INFILE             IN\",LE=RIGHT_INFILE$$"
+	"$$CM+LX,1,3 $$$$BT,\"CANCEL               \",LE=DOCM_CANCEL$$\n",
+	FILEMASK_TXT,FILEMASK_DD,FILEMASK_JIT,FILEMASK_GR);
+  i=PopUpMenu(doc);
+  DocDel(doc);
+  return i;
+}
+
+I64 EdLeftClickLink(CDoc *doc,CDocEntry *doc_e)
+{//Called with doc locked, exit unlocked
+  Bool res;
+  U8 *st;
+  if (st=DocEntryLink(doc,doc_e)) {
+    DocUnlock(doc);
+    if (doc_e->de_flags & DOCEF_POPUP)
+      res=PopUpEd(st);
+    else
+      res=Ed(st);
+    Free(st);
+    return res;
+  }
+}
+
+I64 TermRightClickLink(CDoc *doc,CDocEntry *doc_e)
+{//Called with doc locked, exit unlocked
+  Bool send_new_line=FALSE,res=FALSE;
+  U8 *st,*st2;
+  I64 i;
+  CEdFileName fn;
+  if (st2=DocEntryLink(doc,doc_e)) {
+    if (st=DocLinkFile(st2)) {
+      DocUnlock(doc);
+      if ((i=PopUpTermRight(st))>=0) {
+	DocBottom(doc);
+	switch (i) {
+	  case RIGHT_INCLUDE:
+	    if (FileExtDot(st) && !FilesFindMatch(st,FILEMASK_JIT)) {
+	      if (!PopUpCancelOk(ST_WARN_ST "Not .HC File\n\n")) {
+		send_new_line=TRUE;
+		break;
+	      }
+	    }
+	    "#include \"%s\";\n$$PT$$$$FG$$$$BG$$",st;
+	    WinZBufUpdate;
+	    ExeFile(st,CCF_CMD_LINE);
+	    res=TRUE;
+	    break;
+	  case RIGHT_AINCLUDE:
+	    if (FileExtDot(st) && !FilesFindMatch(st,FILEMASK_JIT)) {
+	      if (!PopUpCancelOk(ST_WARN_ST "Not .HC File\n\n")) {
+		send_new_line=TRUE;
+		break;
+	      }
+	    }
+	    "Adam(\"#include \\\"%s\\\"\" );\n$$PT$$$$FG$$$$BG$$",st;
+	    WinZBufUpdate;
+	    AdamFile(st,FALSE);
+	    res=TRUE;
+	    break;
+	  case RIGHT_COPY:
+	    StrCpy(fn.name,st);
+	    if (DocForm(&fn)) {
+	      res=ToBool(Copy(st,fn.name));
+	    } else
+	      send_new_line=TRUE;
+	    break;
+	  case RIGHT_MOVE:
+	    StrCpy(fn.name,st);
+	    if (DocForm(&fn))
+	      res=Move(st,fn.name);
+	    else
+	      send_new_line=TRUE;
+	    break;
+	  case RIGHT_DELETE:
+	    res=ToBool(Del(st));
+	    break;
+	  case RIGHT_TYPE:
+	    res=Type(st);
+	    break;
+	  case RIGHT_ED:
+	    if (FileExtDot(st) && !FilesFindMatch(st,FILEMASK_DD)) {
+	      if (!PopUpCancelOk(ST_WARN_ST "Not DolDoc File\n\n")) {
+		send_new_line=TRUE;
+		break;
+	      }
+	    }
+	    "Ed(\"%s\");\n$$PT$$$$FG$$$$BG$$",st;
+	    res=Ed(st);
+	    break;
+	  case RIGHT_MOUNT:
+	    if (FileExtDot(st) && !FilesFindMatch(st,"*.ISO.C")) {
+	      if (!PopUpCancelOk(ST_WARN_ST "Not .ISO.C File\n\n")) {
+		send_new_line=TRUE;
+		break;
+	      }
+	    }
+	    "MountFile(\"%s\");\n$$PT$$$$FG$$$$BG$$",st;
+	    WinZBufUpdate;
+	    MountFile(st);
+	    res=TRUE;
+	    break;
+	  case RIGHT_PLAIN:
+	    "Plain(\"%s\");\n$$PT$$$$FG$$$$BG$$",st;
+	    res=Plain(st);
+	    break;
+	  case RIGHT_INFILE:
+	    if (FileExtDot(st) && !FilesFindMatch(st,"*.IN*")) {
+	      if (!PopUpCancelOk(ST_WARN_ST "Not .IN File\n\n")) {
+		send_new_line=TRUE;
+		break;
+	      }
+	    }
+	    "InFile(\"%s\");\n$$PT$$$$FG$$$$BG$$",st;
+	    WinZBufUpdate;
+	    InFile(st);
+	    res=TRUE;
+	    break;
+	}
+      } else
+	send_new_line=TRUE;
+      Free(st);
+    } else
+      send_new_line=TRUE;
+    Free(st2);
+  } else
+    send_new_line=TRUE;
+  DocBottom(doc);
+  "$$PT$$$$FG$$$$BG$$";
+  if (send_new_line)
+    '\n';
+  return res;
+}

TempleOSCD/Adam/DolDoc/DocTree.HC

@@ -0,0 +1,167 @@
+#help_index "DolDoc"
+
+public Bool DocTreeFind(CDoc *haystack_doc,U8 *needle_path,
+  CDocEntry **_tree_entry=NULL,
+  CDocEntry **_start_indent=NULL, CDocEntry **_end_indent=NULL)
+{//Find registry-like tree widget start and end.
+  I64 i=0,k=0;
+  U8 *st1=StrNew(needle_path),*st2=MAlloc(StrLen(needle_path)+1);
+  Bool res=FALSE,unlock_doc=DocLock(haystack_doc);
+  CDocEntry *doc_e=haystack_doc->head.next;
+  if (_tree_entry) *_tree_entry=haystack_doc;
+  if (_start_indent) *_start_indent=haystack_doc;
+  if (_end_indent) *_end_indent=haystack_doc;
+  while (*st1 && doc_e!=haystack_doc) {
+    StrFirstRem(st1,"/",st2);
+    if (*st2) {
+      while (doc_e!=haystack_doc) {
+	if (doc_e->type_u8==DOCT_INDENT)
+	  i+=doc_e->attr;
+	else if (i==k && doc_e->de_flags&DOCEF_TREE &&
+	      !StrCmp(doc_e->tag+3,st2)) {
+	  if (*st1)
+	    break;
+	  else {
+	    if (_tree_entry) *_tree_entry=doc_e;
+	    i=0;
+	    while (doc_e!=haystack_doc && doc_e->type_u8!=DOCT_INDENT)
+	      doc_e=doc_e->next;
+	    if (doc_e!=haystack_doc) {
+	      i=doc_e->attr;
+	      if (_start_indent) *_start_indent=doc_e;
+	      doc_e=doc_e->next;
+	      while (doc_e!=haystack_doc && i>0) {
+		if (doc_e->type_u8==DOCT_INDENT) {
+		  i+=doc_e->attr;
+		  if (i<=0) {
+		    if (_end_indent) *_end_indent=doc_e;
+		    res=TRUE;
+		    break;
+		  }
+		}
+		doc_e=doc_e->next;
+	      }
+	    }
+	    goto ft_done;
+	  }
+	}
+	doc_e=doc_e->next;
+      }
+      k+=2;
+    }
+  }
+ft_done:
+  if (unlock_doc)
+    DocUnlock(haystack_doc);
+  Free(st1);
+  Free(st2);
+  return res;
+}
+
+public Bool DocTreeMake(CDoc *doc,U8 *path)
+{//Make registry-like tree widget.
+  I64 i=0,j=I64_MIN,k=0;
+  U8 *st1=StrNew(path),
+	*st2=MAlloc(StrLen(path)+1),
+	*st3=StrNew(path);
+  Bool res=TRUE,unlock_doc=DocLock(doc);
+  CDocEntry *doc_e=doc->head.next;
+  doc->cur_entry=doc;
+  doc->cur_col=0;
+  while (*st1 && doc_e!=doc) {
+    StrFirstRem(st1,"/",st2);
+    if (*st2) {
+      while (doc_e!=doc) {
+	if (doc_e->type_u8==DOCT_INDENT) {
+	  i+=doc_e->attr;
+	  if (i==j) {
+	    doc->cur_entry=doc_e;
+	    doc->cur_col=0;
+	    goto mt_done;
+	  }
+	} else if (i==k && doc_e->de_flags&DOCEF_TREE &&
+	      !StrCmp(doc_e->tag+3,st2)) {
+	  Free(st3);
+	  st3=StrNew(st1);
+	  j=i;
+	  if (!*st1)
+	    res=FALSE;
+	  else
+	    break;
+	}
+	doc_e=doc_e->next;
+      }
+      k+=2;
+    }
+  }
+mt_done:
+  if (res) {
+    while (*st3) {
+      StrFirstRem(st3,"/",st2);
+      if (*st2) {
+	DocPrint(doc,"$$TR+C,\"%s\"$$\n$$ID,2$$",st2);
+	doc->cur_entry=DocPrint(doc,"$$ID,-2$$");
+	doc->cur_col=0;
+      }
+    }
+  }
+  if (unlock_doc)
+    DocUnlock(doc);
+  Free(st1);
+  Free(st2);
+  Free(st3);
+  return res;
+}
+
+#help_index "DolDoc/Compiler;Compiler"
+public I64 ExeDoc(CDoc *doc,I64 ccf_flags=0)
+{//JIT Compile and execute a document.
+  I64 res;
+  Bool okay=TRUE,unlock_doc=DocLock(doc);
+  CCmpCtrl *cc=CmpCtrlNew(,ccf_flags|CCF_DONT_FREE_BUF);
+  if (Fs->last_cc!=&Fs->next_cc)
+    cc->opts=Fs->last_cc->opts;
+  QueIns(cc,Fs->last_cc);
+  LexAttachDoc(cc,,doc);
+  try {
+    Lex(cc);
+    res=ExeCmdLine(cc);
+  } catch {
+    if (Fs->except_ch=='Compiler' || Fs->except_ch=='Break') {
+      Fs->catch_except=TRUE;
+      okay=FALSE;
+      res=0;
+    }
+  }
+  QueRem(cc);
+  if (okay)
+    CmpCtrlDel(cc); //TODO: can crash
+  if (unlock_doc)
+    DocUnlock(doc);
+  return res;
+}
+
+public I64 DocTreeBranchExe(CDoc *doc,U8 *path)
+{//JIT Compile and execute code in doc tree branch.
+  CDoc *doc2;
+  Bool unlock_doc=DocLock(doc);
+  CDocEntry *tree_branch,*start_indent,*end_indent;
+  I64 res=0;
+  if (DocTreeFind(doc,path,&tree_branch,&start_indent,&end_indent)) {
+    doc2=DocCopy(doc,tree_branch,end_indent);
+    res=ExeDoc(doc2);
+    DocDel(doc2);
+  }
+  if (unlock_doc)
+    DocUnlock(doc);
+  return res;
+}
+
+public I64 ExeTreeBranch(U8 *registry_file,U8 *path)
+{//JIT Compile and execute a specified branch in a specified file.
+  I64 res;
+  CDoc *doc=DocRead(registry_file);
+  res=DocTreeBranchExe(doc,path);
+  DocDel(doc);
+  return res;
+}

TempleOSCD/Adam/DolDoc/MakeDoc.HC

@@ -0,0 +1,69 @@
+Cd(__DIR__);;
+
+#help_index "DolDoc"
+#help_file "::/Doc/DolDoc"
+
+/*
+TempleOS DolDoc's can have "cursor movement" cmds which can move the cursor up
+the scrn and layer on existing text.  It can also have callback funs which
+supply live, changing text.  For these reasons, you can't assume you know
+where the vis portion of the document is and must process much
+of the document each time it is placed on the scrn, becoming CPU
+intensive on big documents.
+See $LK,"::/Doc/DolDocOverview.DD"$
+*/
+
+//Hash Types
+#define DHT_DOC_CMD	1
+#define DHT_DOC_FLAG	2
+#define DHT_COLOR	4
+
+public class CDolDocGlbls
+{
+  CHashTable *hash;
+  I64	dft_de_flags		[DOCT_TYPES_NUM],
+	type_flags_nontag_invis [(DOCT_TYPES_NUM+63)/64],
+	type_flags_form		[(DOCT_TYPES_NUM+63)/64],
+	type_flags_data		[(DOCT_TYPES_NUM+63)/64],
+	type_flags_chk_dup	[(DOCT_TYPES_NUM+63)/64],
+	clean_scan_codes	[4];
+  I32	dft_type_flags		[DOCT_TYPES_NUM];
+} doldoc;
+MemSet(&doldoc,0,sizeof(CDolDocGlbls));
+
+#help_index "God"
+#define BIBLE_FILENAME	"::/Misc/Bible.TXT.Z"
+
+#include "DocExt"
+#include "DocBin"
+#include "DocNew"
+#include "DocForm"
+#include "DocDblBuf"
+#include "DocPlain"
+#include "DocInit"
+#include "DocHighlight"
+#include "DocRecalcLib"
+#include "DocRecalc"
+#include "DocFile"
+#include "DocClipBoard"
+#include "DocRun"
+#include "DocGet"
+#include "DocChar"
+#include "DocFind"
+#include "DocLink"
+#include "DocEd"
+#include "DocPopUp"
+#include "DocGr"
+#include "DocMacro"
+#include "DocWidgetWiz"
+#include "DocPutKey"
+#include "DocPutS"
+#include "DocCodeTools"
+#include "DocTree"
+#include "DocTerm"
+
+KeyDevAdd(&KDDocPutKey,&KDDocPutS,0x80000000,TRUE);
+fp_getstr2=&DocGetStr2;
+fp_doc_put=&DocPut;
+
+Cd("..");;