#help_index "Ltf/Cmd Line (Typically);Cmd Line (Typically)"

U1 *EdLinkFile(U1 *filename)
{
  U1 buf[4],*temp_filename,*tfn_ptr,*result=NULL;
  SrcSymHashEntry *temph;

  temp_filename=StrNew(filename),
elf_restart:
  tfn_ptr=temp_filename;
  if (StrLen(temp_filename)>3 && temp_filename[2]==':') {
    MemCpy(buf,temp_filename,2);
    buf[2]=0;
    tfn_ptr=temp_filename+3;
    switch (DefineMatch(buf,"ST_LINK_TYPES",LEM_IGNORE_CASE)) {
      case LK_MAN_PAGE:
        if (temph=HashFind(tfn_ptr,Fs->hash_table,HTT_SRC_SYM)) {
          if (temph->h.type&HTT_DEFINE_STR && temph><(DefineStrHashEntry *)->caller) {
            Free(temp_filename);
            temp_filename=SrcEditLink(temph><(DefineStrHashEntry *)->caller,64);
            goto elf_restart;
          } else {
            Free(temp_filename);
            temp_filename=StrNew(temph->src_link);
            goto elf_restart;
          }
        }
      case LK_DEF:
      case LK_HELP_INDEX:
        Free(temp_filename);
        return NULL;

      case LK_BIBLE_FIND:
        Free(temp_filename);
        return StrNew(Define("ST_BIBLE_FILE"));

      case LK_FILE_LINE:
      case LK_PLAIN_LINE:
      case LK_FILE_ANCHOR:
      case LK_FILE_FIND:
      case LK_PLAIN_FIND:
        if (Occurrences(tfn_ptr,','))
          StrLastRem(tfn_ptr,",");
        break;
    }
  }
  result=StrNew(tfn_ptr);
  Free(temp_filename);
  return result;
}


BoolI8 EdJoin(U1 *filename,BoolI1 bail)
{ //bail is for LinkChk()
  U1 *buf=StrNew(filename),
     *buf2=StrNew(filename);
  U8 num=1;
  U1 *temp_filename=StrNew(filename),
     *tfn_ptr=temp_filename;
  SrcSymHashEntry *temph;
  I8 i;
  BoolI1 cont,result=FALSE;
  Ltf *l;

  i=LK_FILE;
  if (StrLen(filename)>3 && filename[2]==':') {
    buf[2]=0;
    i=DefineMatch(buf,"ST_LINK_TYPES",LEM_IGNORE_CASE);
    tfn_ptr=temp_filename+3;
    switch (i) {
      case LK_MAN_PAGE:
        if (temph=HashFind(tfn_ptr,Fs->hash_table,HTT_SRC_SYM)) {
          if (temph->h.type&HTT_DEFINE_STR && temph><(DefineStrHashEntry *)->caller)
            result=EdAddSrc(temph><(DefineStrHashEntry *)->caller,64,bail);
          else
            result=EdJoin(temph->src_link,bail);
        }
        Free(temp_filename);
        Free(buf);
        Free(buf2);
        return result;
      case LK_DEF:
        if (Occurrences(tfn_ptr,',')) {
          StrLastRem(tfn_ptr,",",buf);
          i=A2I(buf);
        } else
          i=-1;
        if (!bail)
          WsdPopUpDef(tfn_ptr,i);
        Free(temp_filename);
        Free(buf);
        Free(buf2);
        return TRUE;  //TODO: linkchk
      case LK_HELP_INDEX:
        l=LtfNew;
        StrCpy(l->desc,"HelpIdx");
        LtfHelpIndex(l,tfn_ptr);
        Free(temp_filename);
        Free(buf);
        Free(buf2);
        if (!bail)
          LtfDo(l);
        LtfDel(l);
        return TRUE; //TODO: linkchk
      case LK_BIBLE_FIND:
        if (Occurrences(tfn_ptr,',')) {
          StrLastRem(tfn_ptr,",",buf);
        } else
          *buf=0;
        num=A2I(DefineSub(
           DefineMatch(tfn_ptr,"ST_BIBLE_BOOKS",LEM_IGNORE_CASE),
           "ST_BIBLE_BOOK_LINES"));
        tfn_ptr=Define("ST_BIBLE_FILE");
        break;
      case LK_FILE_LINE:
      case LK_PLAIN_LINE:
        if (Occurrences(tfn_ptr,',')) {
          StrLastRem(tfn_ptr,",",buf);
          num=A2I(buf);
        }
        break;
      case LK_FILE_ANCHOR:
        *buf=0;
        if (Occurrences(tfn_ptr,','))
          StrLastRem(tfn_ptr,",",buf);
        break;
      case LK_FILE_FIND:
      case LK_PLAIN_FIND:
        *buf=0;
        *buf2=0;
        if (Occurrences(tfn_ptr,','))
          StrLastRem(tfn_ptr,",",buf);
        if (Occurrences(buf,':')) {
          StrLastRem(buf,":",buf2);
          num=A2I(buf2);
        }
        break;
    }
  }
  tfn_ptr=StrNew(tfn_ptr);

  cont=TRUE;
  if (!IsTextFile(tfn_ptr) &&
      !PopUpCancelOk(ST_WARN_ST "Not Text File\r\n\r\n"))
      cont=FALSE;
  if (cont)
    result=LtfEditFile(i,tfn_ptr,buf,num,bail);

  WinTextClear(Fs);
  Free(tfn_ptr);
  Free(temp_filename);
  Free(buf);
  Free(buf2);
  return result;
}

public BoolI8 Ed(U1 *filename)
{
  if (IsRaw)
    return EdLite(filename);
  else
    return EdJoin(filename,FALSE);
}

BoolI8 LtfLinkChk(U1 *filename)
{
  return EdJoin(filename,TRUE);
}

public U0 Plain(U1 *filename)
//Open a document in plain text mode,
//so that dollar signs are not special.
{
  U1 *buf=MSPrintF("PI:%s",filename);
  Ed(buf);
  Free(buf);
}

#help_index "Ltf/Task"
public Ltf *SysAuxLtfInit(BoolI1 has_menu)
{
  LtfEntry *ll;
  Ltf *aux,*l=LtfCur;

  aux=LtfNew;
  aux->flags|=LTFF_AUX_LTF;

  LtfPutS(aux,"$$CM+H+BY+RX+NC,-8,1$$");
  ll=LtfPutS(aux,"$$TX+H+BD+TC,\" \"$$");
  ll->tag_cb=&EdPreemptCB;

  if (l) {
    LtfPutS(aux,"$$CM+H+BY+RX+NC,-7,1$$");
    ll=LtfPutS(aux,"$$TX+H+BD+TC,\" \"$$");
    ll->user_data=l;
    ll->tag_cb=&EdFilterCB;
    LtfPutS(aux,"$$CM+H+BY+RX+NC,-6,1$$");
    ll=LtfPutS(aux,"$$TX+H+BD+TC,\" \"$$");
    ll->user_data=l;
    ll->tag_cb=&EdOverStrikeCB;
    LtfPutS(aux,"$$CM+H+BY+RX+NC,-5,1$$");      //gets merged without this
    ll=LtfPutS(aux,"$$TX+H+BD+TC,\" \"$$");
    ll->user_data=l;
    ll->tag_cb=&EdDollarCB;
  }

  LtfPutS(aux,"$$CM+H+BY+RX+NC,-4,1$$");        //gets merged without this
  ll=LtfPutS(aux,"$$TX+H+BD+TC,\" \"$$");
  ll->tag_cb=&EdQuotesCB;
  LtfPutS(aux,"$$CM+H+BY+RX+NC,-3,1$$");        //gets merged without this
  ll=LtfPutS(aux,"$$TX+H+BD+TC,\" \"$$");
  ll->tag_cb=&EdBracesCB;
  LtfPutS(aux,"$$CM+H+BY+RX+NC,-2,1$$");        //gets merged without this
  ll=LtfPutS(aux,"$$TX+H+BD+TC,\" \"$$");
  ll->tag_cb=&EdSemicolonCB;

  if (l) {
    LtfPutS(aux,"$$CM+H+BY+RX+NC,-12,1$$");
    ll=LtfPutS(aux,"$$TX+H+BD+TC,\" \"$$");
    ll->user_data=l;
    ll->tag_cb=&EdDollarTypeCB;
  }

  if (Fs->user_num)
    LtfPrintF(aux,"$$CM+H+TY+LX+NC,5,-1$$$$TX+H+BD,\"#%d\"$$",Fs->user_num);
  LtfPutS(aux,"$$CM+H+TY+NC,0,-1$$");
  ll=LtfPutS(aux,"$$DA+H-T-P+BD+RD+CX+SCX+IV,140,\"%s...\",16$$");
  ll->data=&Fs->task_title;
  LtfFormatData(ll);
  LtfPrintF(aux,"$$CM+H+NC,1,0$$$$TX+H+BD+IV,\"%X\"$$",Fs);
  aux->settings_root.dft_text_attr=Fs->border_attr;
  if (Bt(&Fs->display_flags,DISPLAYf_HAS_CLOSE_WIN))
    LtfPutS(aux,"$$TX+H+RX+BD,\"[X]\"$$");
  if (has_menu) {
    LtfPutS(aux,"$$BK,1$$$$TX+H+LX+BD,\"MENU\"$$$$BK,0$$");
    LBts(&Fs->display_flags,DISPLAYf_HAS_MENU);
  }
  return aux;
}

public U0 UseTermLtf(U1 *ltf_menu_file=NULL,U1 *pulldown_menu_file=NULL)
{
  BoolI1 old_preempt=Preempt(OFF);
  Ltf *l=LtfNew,*m;
  LtfInsQue(l,Fs->last_ltf);
  l->right_click_link=&TermRightClickLink;
  l->max_entries=4096;
  l->flags|=LTFF_ATTR_BY_PARTITION;

  StrCpy(l->desc,"Term");
  if (ltf_menu_file) {
    m=LtfRead(ltf_menu_file);
    m->flags|=LTFF_ATTR_BY_PARTITION|LTFF_ALLOW_UNDO;
    l->menu_ltf=m;
    LtfInsQueRev(SysAuxLtfInit(TRUE),Fs->next_ltf);
  } else
    LtfInsQueRev(SysAuxLtfInit(FALSE),Fs->next_ltf);

  if (pulldown_menu_file)
    Fs->cur_menu=MenuFile(pulldown_menu_file);
  else
    Fs->cur_menu=MenuFile("::/LT/Doc/EditPullDown.TXZ");

  Fs->update_win=&LtfUpdateTaskLtfs;
  Fs->scroll_speed=7;
  WinScrollsInit(Fs);
  Preempt(old_preempt);
  Raw(OFF);
}

#help_index "Ltf/Input"
public U1 *LtfGetLine(Ltf *l,LtfEntry *cl,I8 *cur_col=NULL,LtfEntry **_cl_end=NULL)
{
  LtfEntry *cl2=cl;
  BoolI1 unlock=LtfLock(l);
  U1 *result,*dst,*src,*start;
  U8 i=0;
  if (cur_col)
    *cur_col=-1;
  while (cl2!=l && cl2->btype!=LTFT_CR) {
    if (Bt(ltf_tag_types,cl2->btype)) {
      src=cl2->tag;
      i+=StrLen(src);
    } else if (cl2->btype==LTFT_TAB)
      i++;
    cl2=cl2->next;
  }
  result=MAlloc(i+1);
  dst=result;
  while (cl!=l && cl->btype!=LTFT_CR) {
    start=dst;
    if (Bt(ltf_tag_types,cl->btype)) {
      src=cl->tag;
      while (*src)
        *dst++=*src++;
    } else if (cl->btype==LTFT_TAB)
      *dst++=CH_TAB;
    if (cl==l->cur_entry && cur_col)
      *cur_col=start-result+l->cur_data_col;
    cl=cl->next;
  }
  if (_cl_end) *_cl_end=cl;
  *dst=0;
  if (cl==l->cur_entry && cur_col && !l->cur_data_col)
    *cur_col=dst-result;
  if (unlock)
    LtfUnlock(l);
  return result;
}

#help_index "Ltf/Output"
public U0 LtfDump(Ltf *l,U8 uS_delay=0)
{
  U1 *st;
  LtfEntry *cl,*cl2;
  BoolI1 unlock=LtfLock(l);
  cl=l->root.next;
  while (cl!=l) {
    st=LtfGetLine(l,cl,NULL,&cl2);
    PutS(st);
    Free(st);
    cl=cl2;
    if (cl->btype==LTFT_CR) {
      CrLf;
      BusyWait(uS_delay);
      cl=cl->next;
    }
  }
  if (unlock)
    LtfUnlock(l);
}

public BoolI8 View()
{
  U8 ch=0,sc=0;
  BoolI1 old_preempt=Preempt(OFF);
  while (ch!=CH_ESC && ch!=CH_CTRLQ) {
    Preempt(OFF);
    if (ScanKey(&ch,&sc)) {
      Preempt(old_preempt);
      PutKey(ch,sc);
      LtfRecalc;
      if (ch==CH_ESC || ch==CH_CTRLQ) {
        Preempt(OFF);
        if (LtfCur && LtfCur->find_replace->filter_lines) {
          EdUndoFilter(LtfCur);
          ch=0; sc=0;//don't exit
        }
        Preempt(old_preempt);
      }
    } else {
      LBts(&Fs->task_flags,TASKf_IDLE);
      if (!(Fs->parent_task && Fs->parent_task->popup_task==Fs)) {
        LBts(&Fs->task_flags,TASKf_AWAITING_MSG);
        Preempt(old_preempt);
        TaskNext;
      } else {
        Preempt(old_preempt);
        WinSync;
      }
      LBtr(&Fs->task_flags,TASKf_IDLE);
    }
  }
  Preempt(old_preempt);
  return ch==CH_ESC;
}


public LtfEntry *LtfPutLine(LtfEntry *cl)
{
  U1 ch,*ptr,*ptr2;
  while (cl->btype!=LTFT_ERROR && cl->btype!=LTFT_CR) {
    if (Bt(ltf_tag_types,cl->btype)) {
      ptr=cl->tag;
      do {
        ptr2=ptr;
        while (ch=*ptr)
          if (ch=='$$')
            break;
          else
            ptr++;
        *ptr=0;
        PutS(ptr2);
        *ptr=ch;
        if (ch=='$$') {
          PutS("$$$$");
          ptr++;
        }
      } while (ch);
    } else if (cl->btype==LTFT_TAB)
      PutChar(CH_TAB);
    cl=cl->next;
  }
  CrLf;
  return cl->btype==LTFT_ERROR ? cl:cl->next;
}

#help_index "Ltf/Input"
public U1 *LtfMGetS(U8 flags=0)
//Flags
{
  Ltf *l;
  LtfEntry *cl;
  BoolI1 old_preempt=IsPreempt;
  U1 *result;
  U8 ch,sc;
  PutS("$$FU$$$$BU$$");
  do {
    if (ScanKey(&ch,&sc)) {
      if (ch==CH_ESC || ch==CH_CTRLQ) { //Check for exit filter mode
        Preempt(OFF);
        if (LtfCur && LtfCur->find_replace->filter_lines) {
          PutKey(ch,sc);
          LtfRecalc;

          EdUndoFilter(LtfCur);
          ch=0; sc=0; //don't exit
        }
        Preempt(old_preempt);
      }
      if (ch==CH_ESC) {
        l=Fs->next_ltf;
        while (l!=(&Fs->next_ltf)><(U1 *)-offset(Ltf.next_ltf) &&
            l->ltf_in_queue_signature==LTF_IN_QUEUE_SIGNATURE_VAL) {
          LtfLock(l);
          if (!(l->flags&LTFF_DONT_SHOW) &&
              (!l->best_d || !(l->flags&LTFF_AUX_LTF)) &&
              l->ltf_in_queue_signature==LTF_IN_QUEUE_SIGNATURE_VAL && l->cur_entry!=l) {
            cl=LtfCopyEntry(l,l->cur_entry);
            if (l->flags&LTFF_AUX_LTF && LtfCur)
              LtfBottom;
            else
              LtfBottom(l);
            LtfEntryRun(l,cl,TRUE);
            LtfDelEntry(l,cl);
            LtfUnlock(l);
            break;
          }
          LtfUnlock(l);
          l=l->next_ltf;
        }
      } if (ch==CH_CTRLQ) {
        if (flags&GETSF_CTRLQ_EXIT)
          Exit;
        else {
          result=StrNew("");
          goto mgets_done;
        }
      } else {
        PutKey(ch,sc);
        LtfRecalc;
      }
    } else {
      Preempt(OFF);
      LBts(&Fs->task_flags,TASKf_IDLE);
      if (!(Fs->parent_task && Fs->parent_task->popup_task==Fs)) {
        LBts(&Fs->task_flags,TASKf_AWAITING_MSG);
        TaskNext;
      } else
        WinSync;
      LBtr(&Fs->task_flags,TASKf_IDLE);
      Preempt(old_preempt);
    }
//Ctrl shift <CR> is a blank line without entry
  } while (ch!=CH_CR || sc & SCF_CTRL && sc & SCF_SHIFT);

  Preempt(OFF);
  l=LtfCur;
  LtfLock(l);
  cl=l->cur_entry;
  do cl=cl->last;
  while (cl!=l && cl->btype!=LTFT_CR &&
    cl->btype!=LTFT_USER_FOREGROUND && cl->btype!=LTFT_USER_BACKGROUND);


  do cl=cl->last;
  while (cl!=l && cl->btype!=LTFT_CR &&
    cl->btype!=LTFT_USER_FOREGROUND && cl->btype!=LTFT_USER_BACKGROUND);

  cl=cl->next;
  result=LtfGetLine(l,cl,NULL);
  LtfUnlock(l);
mgets_done:
  PutS("$$FU$$$$FG$$$$BG$$");
  Preempt(old_preempt);
  return result;
}

#help_index "Char/Input"

public I8 PmtI8(U1 *msg,I8 dft,I8 lo=MIN_I8,I8 hi=MAX_I8)
{
  I8 result;
  BoolI1 okay;
  U1 *st;
  while (TRUE) {
    PrintF(msg,dft);
    st=MGetS;
    if (!*st) {
      Free(st);
      return dft;
    }
    try {
      okay=FALSE;
      result=ExePrintF3("ToI8(%s);",st);
      okay=TRUE;
    } catch
      Fs->catch_except=TRUE;
    Free(st);
    if (okay && lo<=result<=hi)
      return result;
  }
}

public F8 PmtF8(U1 *msg,F8 dft,F8 lo=MIN_F8,F8 hi=MAX_F8)
{
  F8 result;
  BoolI1 okay;
  U1 *st;
  while (TRUE) {
    PrintF(msg,dft);
    st=MGetS;
    if (!*st) {
      Free(st);
      return dft;
    }
    try {
      okay=FALSE;
      result=ExePrintF3("ToF8(%s);",st)><(F8);
      okay=TRUE;
    } catch
      Fs->catch_except=TRUE;
    Free(st);
    if (okay && lo<=result<=hi)
      return result;
  }
}

public U1 *PmtStr(U1 *msg=NULL,U1 *dft=NULL)
{
  U1 *st;
  if (msg) {
    if (dft)
      PrintF(msg,dft);
    else
      PrintF(msg);
  }
  st=MGetS;
  if (!*st) {
    Free(st);
    if (dft)
      return StrNew(dft);
    else
      return StrNew("");
  }
  return st;
}

public LTDate PmtLTDate(U1 *msg,LTDate dft,LTDate lo=MIN_I8,LTDate hi=MAX_I8)
{
  LTDate result;
  U1 *st;
  while (TRUE) {
    PrintF(msg,dft,dft);
    st=MGetS;
    if (!*st) {
      Free(st);
      return dft;
    }
    result=A2LTDate(st);
    Free(st);
    if (result>=lo && result<=hi)
      return result;
  }
}

#help_index "Ltf"

#define RIGHT_INCLUDE   0
#define RIGHT_DEBUG     1
#define RIGHT_COMPILE   2
#define RIGHT_LOAD      3
#define RIGHT_AINCLUDE  4
#define RIGHT_AUTOFILE  5
#define RIGHT_COPY      6
#define RIGHT_MOVE      7
#define RIGHT_DELETE    8

I8 PopUpCancelIncludeDelAuto(U1 *header=NULL,U1 *footer=NULL)
{
  I8 i;
  Ltf *l=LtfNew;
  if (header) LtfPutS(l,header);
  LtfPutS(l,"$$CM+LX,1,3 $$$$BT, \"INCLUDE       (.CPZ)\",RIGHT_INCLUDE$$");
  LtfPutS(l,"$$CM+LX,25,0$$$$BT, \"DEBUG               \",RIGHT_DEBUG$$");
  LtfPutS(l,"$$CM+LX,1,3 $$$$BT, \"STATIC COMPILE(.SPZ)\",RIGHT_COMPILE$$");
  LtfPutS(l,"$$CM+LX,25,0$$$$BT, \"LOAD          (.BIZ)\",RIGHT_LOAD$$");
  LtfPutS(l,"$$CM+LX,1,3 $$$$BT, \"ADAM_INCLUDE  (.APZ)\",RIGHT_AINCLUDE$$");
  LtfPutS(l,"$$CM+LX,25,0$$$$BT, \"AUTOFILE      (.AUZ)\",RIGHT_AUTOFILE$$");
  LtfPutS(l,"$$CM+LX,1,3 $$$$BT, \"COPY                \",RIGHT_COPY$$");
  LtfPutS(l,"$$CM+LX,25,0$$$$BT, \"MOVE                \",RIGHT_MOVE$$");
  LtfPutS(l,"$$CM+LX,1,3 $$$$BT, \"DELETE              \",RIGHT_DELETE$$");
  LtfPutS(l,"$$CM+LX,25,0$$$$BT, \"CANCEL              \",-1$$\r\n");
  if (footer) LtfPutS(l,footer);
  i=PopUpMenu(l);
  LtfDel(l);
  return i;
}

I8 EdLeftClickLink(Ltf *l,LtfEntry *cl)
{ //called with l locked, exit unlocked
  BoolI1 result;
  U1 *st;
  if (cl->flags & LTFLF_AUX_STR)
    st=StrNew(cl->aux_str);
  else
    st=StrNew(cl->tag);
  LtfUnlock(l);
  result=Ed(st);
  Free(st);
  return result;
}

I8 TermRightClickLink(Ltf *l,LtfEntry *cl)
{ //called with l locked, exit unlocked
  BoolI1 send_cr=FALSE,result=FALSE;
  U1 *st;
  I8 i;
  EditFileNameStruct fn;
  if (cl->flags & LTFLF_AUX_STR)
    st=cl->aux_str;
  else
    st=cl->tag;
  st= st[2]==':' ? st+3:st;
  LtfUnlock(l);
  if ((i=PopUpCancelIncludeDelAuto(st))>=0) {
    LtfBottom(l);
    switch (i) {
      case RIGHT_INCLUDE:
        if (Occurrences(st,'.') && !WildCardMatch("*.CP?",st)) {
          if (!PopUpCancelOk(ST_WARN_ST "Not .CP? File\r\n\r\n")) {
            send_cr=TRUE;
            break;
          }
        }
        cout "#include \"",st,"\";\r\n$$FU$$$$FG$$$$BG$$";
        ExeFile(st);
        result=TRUE;
        break;
      case RIGHT_DELETE:
        Del(st);
        result=TRUE;
        break;
      case RIGHT_AUTOFILE:
        if (Occurrences(st,'.') && !WildCardMatch("*.AU?",st)) {
          if (!PopUpCancelOk(ST_WARN_ST "Not .AU? File\r\n\r\n")) {
            send_cr=TRUE;
            break;
          }
        }
        cout "AutoFile(\"",st,"\");\r\n$$FU$$$$FG$$$$BG$$";
        AutoStr("%F\r",st);
        result=TRUE;
        break;
      case RIGHT_AINCLUDE:
        if (Occurrences(st,'.') && !WildCardMatch("*.AP?",st)) {
          if (!PopUpCancelOk(ST_WARN_ST "Not .AP? File\r\n\r\n")) {
            send_cr=TRUE;
            break;
          }
        }
        cout "Adam(\"#include \\\"",st,"\\\"\" );\r\n$$FU$$$$FG$$$$BG$$";
        AdamFile(st,FALSE);
        result=TRUE;
        break;
      case RIGHT_COMPILE:
        if (Occurrences(st,'.') && !WildCardMatch("*.SP?",st)) {
          if (!PopUpCancelOk(ST_WARN_ST "Not .SP? File\r\n\r\n")) {
            send_cr=TRUE;
            break;
          }
        }
        cout "Cmp(\"",st,"\");\r\n$$FU$$$$FG$$$$BG$$";
        Cmp(st);
        result=TRUE;
        break;
      case RIGHT_LOAD:
        if (Occurrences(st,'.') && !WildCardMatch("*.BI?",st)) {
          if (!PopUpCancelOk(ST_WARN_ST "Not .BI? File\r\n\r\n")) {
            send_cr=TRUE;
            break;
          }
        }
        cout "Load(\"",st,"\");\r\n$$FU$$$$FG$$$$BG$$";
        Load(st);
        result=TRUE;
        break;
      case RIGHT_COPY:
        StrCpy(fn.name,st);
        if (LtfFormDo(fn.name,"EditFileNameStruct")) {
          Copy(st,fn.name);
          result=TRUE;
        }
        break;
      case RIGHT_MOVE:
        StrCpy(fn.name,st);
        if (LtfFormDo(fn.name,"EditFileNameStruct")) {
          Move(st,fn.name);
          result=TRUE;
        }
        break;
      case RIGHT_DEBUG:
        if (Occurrences(st,'.') && !WildCardMatch("*.CP?",st)) {
          if (!PopUpCancelOk(ST_WARN_ST "Not .CP? File\r\n\r\n")) {
            send_cr=TRUE;
            break;
          }
        }
        cout "IDE(\"",st,"\");\r\n$$FU$$$$FG$$$$BG$$";
        IDE(st);
        result=TRUE;
        break;
    }
  } else
    send_cr=TRUE;
  LtfBottom(l);
  cout "$$FU$$$$FG$$$$BG$$";
  if (send_cr)
    PutChar(CH_CR);
  return result;
}

#help_index "Ltf/Cmd Line (Typically);Cmd Line (Typically)"

public U0 Man(U1 *st)
//Enter the name of a symbol and this
//will jump to the src code.
{
  U1 *name=MAlloc(3+StrLen(st)+1);
  StrCpy(name,"MN:");
  StrCat(name,st);
  Ed(name);
  Free(name);
}

#help_index "Debugging;Ltf/Cmd Line (Typically);Ltf/Output;Cmd Line (Typically)"

public U0 LtfDm(U1 *buf,U8 cnt=0x80)
//Dumps a chunk of mem, showing
//addresses.  It is live and can be
//edited.
{
  LtfEntry *ll;
  Ltf *l=LtfCur;
  BoolI1 unlock=LtfLock(l);
  ll=LtfPrintF(l,"$$HX-Z,%d,16$$",cnt);
  ll->data=buf;
  l->cur_entry=ll->next;
  LtfRecalc(l);
  if (unlock)
    LtfUnlock(l);
}

public U0 LtfD(U1 *buf,U8 cnt=0x80)
//Dumps a chunk of mem, showing
//offsets.  It is live and can be
//edited.
{
  LtfEntry *ll;
  Ltf *l=LtfCur;
  BoolI1 unlock=LtfLock(l);
  ll=LtfPrintF(l,"$$HX,%d,16$$",cnt);
  ll->data=buf;
  l->cur_entry=ll->next;
  LtfRecalc(l);
  if (unlock)
    LtfUnlock(l);
}

#help_index "Ltf/Output"
BoolI8 AKDLtfPutS(U1 *st)
{
  Ltf *l;
  if (l=LtfCur)
    LtfPutSPartial(l,st);
  return FALSE;
}

KeyDevAdd(&AKDLtfPutKey,&AKDLtfPutS,0x80000000,TRUE);
fp_mgets=&LtfMGetS;
fp_ltf_cur=&LtfCur;

#help_index "Ltf"