TempleOSCD_150216.ISO

Adam/AutoComplete/ACDict.CPP

@@ -0,0 +1,295 @@
+#help_index "AutoComplete/Dictionary"
+
+public U0 ACDWordsLoad()
+{//Put words from word list into hash table.
+  I64 size;
+  CHashGeneric *temph;
+  U8 *in_ptr,*in_start,*st2;
+  U16 *d;
+  acd.num_words=0;
+  if (in_ptr=FileRead(ACD_WORD_FILENAME,&size)) {
+    in_start=in_ptr;
+    Free(acd.word_lst);
+    acd.word_lst=AMAlloc(size);
+    MemCpy(acd.word_lst,in_start,size);
+    acd.word_lst_size=size;
+
+    while (in_ptr<in_start+size) {
+      if (*in_ptr==ACD_WORD_CHAR)
+	in_ptr++;
+      if (*in_ptr) {
+	st2=MStrUtil(in_ptr,SUF_TO_UPPER);
+	temph=ACAlloc(sizeof(CHashGeneric)+StrLen(st2)+1);
+	StrCpy(temph+1,st2);
+	Free(st2);
+	in_ptr+=StrLen(in_ptr)+1;
+	temph->str=temph+1;
+	temph->use_cnt=1;
+	temph->type=HTT_DICT_WORD;
+	d=in_ptr;
+	temph->user_data0=*d;
+	in_ptr+=2;
+	HashAdd(temph,ac.hash_table);
+	acd.num_words++;
+      } else
+	in_ptr+=3;
+    }
+    Free(in_start);
+  }
+}
+
+public U8 *ACDDefGet(U8 *st,I64 def_num=1)
+{//MAlloc str holding single dict definition of word.
+  CFile *f;
+  CHashGeneric *temph;
+  U8 *result=NULL,*buf,*in_ptr,
+     *st2=MStrUtil(st,SUF_TO_UPPER);
+  temph=HashFind(st2,ac.hash_table,HTT_DICT_WORD);
+  Free(st2);
+  if (temph) {
+    if (f=FOpen(ACD_DEF_FILENAME,"r")) {
+      buf=MAlloc(ACD_BLK_SIZE*2+1);
+      buf[ACD_BLK_SIZE*2]=0; //terminate
+      FRBlks(f,buf,temph->user_data0*ACD_BLK_SIZE/BLK_SIZE,ACD_BLK_SIZE*2/BLK_SIZE);
+      FClose(f);
+      in_ptr=buf;
+      while (in_ptr<buf+ACD_BLK_SIZE*2) {
+	while (*in_ptr!=ACD_WORD_CHAR && in_ptr<buf+ACD_BLK_SIZE*2)
+	  in_ptr++;
+	if (*in_ptr++==ACD_WORD_CHAR) {
+	  if (!StrICmp(st,in_ptr)) {
+	    while (def_num && *in_ptr!=ACD_WORD_CHAR
+		   && in_ptr<buf+ACD_BLK_SIZE*2) {
+	      if (*in_ptr==ACD_DEF_CHAR) {
+		if (!--def_num)
+		  break;
+		else
+		  in_ptr++;
+	      } else
+		in_ptr++;
+	    }
+	    if (*in_ptr++==ACD_DEF_CHAR) {
+	      result=StrNew(in_ptr);
+	      break;
+	    }
+	  }
+	}
+      }
+      Free(buf);
+    }
+  }
+  return result;
+}
+
+public U8 *ACDDefsGet(U8 *st)
+{//MAlloc str with all dict definitions of word.
+  CFile *f;
+  CHashGeneric *temph;
+  U8 *result=NULL,*buf,*in_ptr,*in_ptr2,
+     *st2=MStrUtil(st,SUF_TO_UPPER);
+  temph=HashFind(st2,ac.hash_table,HTT_DICT_WORD);
+  Free(st2);
+  if (temph) {
+    if (f=FOpen(ACD_DEF_FILENAME,"r")) {
+      buf=MAlloc(ACD_BLK_SIZE*2+1);
+      buf[ACD_BLK_SIZE*2]=0; //terminate
+      FRBlks(f,buf,temph->user_data0*ACD_BLK_SIZE/BLK_SIZE,ACD_BLK_SIZE*2/BLK_SIZE);
+      FClose(f);
+      in_ptr=buf;
+      while (in_ptr<buf+ACD_BLK_SIZE*2) {
+	while (*in_ptr!=ACD_WORD_CHAR && in_ptr<buf+ACD_BLK_SIZE*2)
+	  in_ptr++;
+	if (*in_ptr++==ACD_WORD_CHAR) {
+	  if (!StrICmp(st,in_ptr)) {
+	    in_ptr2=in_ptr;
+	    in_ptr--;
+	    while (*in_ptr2!=ACD_WORD_CHAR
+		   && in_ptr2<buf+ACD_BLK_SIZE*2) {
+	      in_ptr2++;
+	    }
+	    result=MAlloc(in_ptr2+1-in_ptr);
+	    MemCpy(result,in_ptr,in_ptr2-in_ptr);
+	    result[in_ptr2-in_ptr]=ACD_END_CHAR;
+	    break;
+	  }
+	}
+      }
+      Free(buf);
+    }
+  }
+  return result;
+}
+
+/*Fmt of word lst entry:
+  U8 ACD_WORD_CHAR
+  U8 word[] with terminating zero
+  I16 block;
+*/
+public U8 *ACDWordPtAt(U8 *st)
+{//Point to word in word list.
+  I64 i;
+  U8 *start=acd.word_lst,*r=start,
+     *end=acd.word_lst+acd.word_lst_size;
+  if (!st || !*st)
+    return acd.word_lst;
+  if (acd.word_lst_size) {
+    while (start+3<end) {
+      r=(start+end)>>1;
+      while (TRUE) {
+	while (*r!=ACD_WORD_CHAR && r>acd.word_lst)
+	  r--;
+	if ((r[2]==ACD_WORD_CHAR||r[1]==ACD_WORD_CHAR)&&r-3>acd.word_lst)
+	  r--;
+	else
+	  break;
+      }
+      if (*r==ACD_WORD_CHAR) {
+	i=StrICmp(st,r+1);
+	if (i<0)
+	  end=r-1;
+	else if (i>0)
+	  start=r+StrLen(r)+3;
+	else
+	  return r;
+      } else
+	break;
+    }
+    r=(start+end)>>1;
+    while (TRUE) {
+      while (*r!=ACD_WORD_CHAR && r>acd.word_lst)
+	r--;
+      if ((r[2]==ACD_WORD_CHAR||r[1]==ACD_WORD_CHAR)&&r-3>acd.word_lst)
+	r--;
+      else
+	break;
+    }
+    if (*r==ACD_WORD_CHAR && StrICmp(st,r+1)>0)
+      r+=StrLen(r)+3;
+  }
+  if (*r==ACD_WORD_CHAR)
+    return r;
+  else
+    return acd.word_lst;
+}
+
+U0 ACDDictWordsAdd(CDoc *doc,U8 *st)
+{
+  I64 i;
+  U8 *ptr;
+  if (st && *st && (ptr=ACDWordPtAt(st))) {
+    for (i=0;i<ACD_MAX_FILLINS;i++) {
+      if (*ptr++!=ACD_WORD_CHAR)
+	break;
+      if (i)
+	DocPrint(doc,"\n");
+      acd.fillins[i]=ptr-1;
+      DocPrint(doc,"$$GREEN$$'%d'$$FG$$ %-23ts",i,ptr);
+      ptr+=StrLen(ptr)+3;
+    }
+    acd.num_fillins=i;
+  }
+}
+
+U0 ACDFillin(I64 n)
+{
+  U8 *s;
+  I64 len;
+  if (0<=n<acd.num_fillins) {
+    s=acd.fillins[n]+1;
+    len=StrLen(s);
+    if (len>ac.partial_len)
+      Auto(s+ac.partial_len);
+  }
+}
+
+public U0 ACDDefsPut(CDoc *doc=NULL,U8 *st,I64 num=-1)
+{//Put to doc a dictionary definition(s) of a word.
+  U8 *st2,*st3;
+  I64 ch,i=0;
+  if (!st) return;
+  if (*st==ACD_WORD_CHAR)
+    st++;
+  DocPrint(doc,"$$WW,1$$$$RED$$%s:$$FG$$\n\n",st);
+  if (num<0) {
+    if (st3=ACDDefsGet(st)) {
+      st2=st3;
+      while (ch=*st2++) {
+	switch (ch) {
+	  case ACD_WORD_CHAR:
+	    break;
+	  case ACD_DEF_CHAR:
+	    DocPrint(doc,"$$GREEN$$(%d)$$FG$$ %s\n",
+	      ++i,st2);
+	    break;
+	  case ACD_PRONUNCIATION_CHAR:
+	    DocPrint(doc,"$$LTGREEN$$%s$$FG$$\n",st2);
+	    break;
+	  case ACD_POS_CHAR:
+	    DocPrint(doc,"$$BLACK$$%s$$FG$$\n",st2);
+	    break;
+	  case ACD_EXTRA_CHAR:
+	    DocPrint(doc,"$$LTBLUE$$%s$$FG$$\n",st2);
+	    break;
+	}
+	st2+=StrLen(st2)+1;
+      }
+      Free(st3);
+    }
+  } else {
+    while (st2=ACDDefGet(st,++i)) {
+      if (i==num)
+	DocPrint(doc,"$$GREEN$$(%d)$$FG$$ %s\n",
+	  i,st2);
+      Free(st2);
+    }
+  }
+}
+
+U0 ACDPopUpDef(U8 *st,I64 num=-1,CTask *parent=NULL)
+{
+  U8 *buf;
+  buf=MStrPrint("ACDDefsPut(DocPut,\"%s\",%d);View;",st,num);
+  PopUp(buf,parent);
+  Free(buf);
+}
+
+U0 ACDDef(I64 n,CTask *parent=NULL)
+{
+  if (0<=n<acd.num_fillins)
+    ACDPopUpDef(acd.fillins[n],-1,parent);
+}
+
+U0 ACFindMisspelled(CDoc *doc)
+{
+  Bool unlock=DocLock(doc);
+  CDocEntry *doc_e=doc->cur_entry;
+  I64 col=doc->cur_data_col,col2,ch;
+  do {
+    if (doc_e!=doc && doc_e->de_flags&DOCEF_TAG) {
+      while (col<doc_e->max_col) {
+	while (col<doc_e->max_col && !Bt(chars_bitmap_word,doc_e->tag[col]))
+	  col++;
+	if (col<doc_e->max_col) {
+	  col2=col;
+	  while (col2<doc_e->max_col && Bt(chars_bitmap_word,doc_e->tag[col2]))
+	    col2++;
+	  ch=doc_e->tag[col2];
+	  doc_e->tag[col2]=0;
+	  if (StrICmp(&doc_e->tag[col],ACDWordPtAt(&doc_e->tag[col])+1)) {
+	    doc_e->tag[col2]=ch;
+	    doc->cur_entry=doc_e;
+	    doc->cur_data_col=col;
+	    goto fm_done;
+	  }
+	  doc_e->tag[col2]=ch;
+	  col=col2;
+	}
+      }
+    }
+    doc_e=doc_e->next;
+    col=doc_e->min_col;
+  } while (doc_e!=doc->cur_entry);
+fm_done:
+  if (unlock)
+    DocUnlock(doc);
+}

Adam/AutoComplete/ACDictGen.CPP

@@ -0,0 +1,218 @@
+/*
+This file is a stand-alone program
+which will regenerate processed dictionary
+files from a raw Project Gutenberg
+dictionary file.
+
+Supply the raw dictionary filename in
+the call at the bottom of this file
+and #include this file.
+
+I ran $LK,"::/Misc/ToDolDoc.CPP"$ on it, first.
+
+See $LK,"::/Doc/Credits.TXT"$.
+*/
+
+I64 ACDNextCmd(U8 **_ptr)
+{
+  U8 ch,*ptr=*_ptr,*ptr2;
+  I64 result=-1;
+  do {
+    do {
+      if (!(ch=*ptr++)) goto ncmd_done;
+    } while (ch!='<');
+
+    ptr2=ptr;
+    do {
+      if (!(ch=*ptr2++)) goto ncmd_done;
+    } while (ch!='>');
+    *--ptr2=0;
+    result=LstMatch(ptr,"h1\0/h1\0def\0/def\0hw\0/hw\0tt\0/tt\0"
+"ety\0@fld\0@cd\0@blockquote\0@wordforms\0@note\0@altname\0@chform\0@cref\0@syn\0"
+"/ety\0@/fld\0@/cd\0@/blockquote\0@/wordforms\0@/note\0@/altname\0@/chform\0@/cref\0@/syn\0");
+    *ptr2++='>';
+    ptr=ptr2;
+  } while (result<0);
+
+ncmd_done:
+  *_ptr=ptr;
+  return result;
+}
+
+U8 *ACDNextEntry(U8 **_ptr)
+{
+  U8 *result,*ignore,ch,*ptr=*_ptr,buf[ACD_BLK_SIZE],*out_ptr=buf;
+  I64 l;
+  while (TRUE) {
+    while (TRUE) {
+      if (!(ch=*ptr++)) goto nentry_done;
+      if (ch!='<') {
+	*out_ptr++=ch;
+	if (ch=='$$')
+	  *out_ptr++=ch;
+      } else
+	break;
+    }
+    ignore="b>\0i>\0ppp>\0/b>\0/i>\0/p>\0"
+       "ets>\0col>\0spn>\0/ets>\0/col>\0/spn>\0er>\0as>\0cs>\0cd>\0ex>\0"
+       "/er>\0/as>\0/cs>\0/cd>\0/ex>\0"
+       "note>\0/note>\0blockquote>\0/blockquote>\0";
+    while (*ignore) {
+      l=StrLen(ignore);
+      if (!StrNCmp(ptr,ignore,l)) {
+	ptr+=l;
+	break;
+      } else
+	ignore+=l+1;
+    }
+    if (!*ignore)
+      break;
+  }
+nentry_done:
+  *out_ptr++=0;
+  result=StrNew(buf);
+  *_ptr=ptr-1;
+  return result;
+}
+
+I64 ACDCompareWords(U8 *e1,U8 *e2)
+{
+  return StrICmp(e1,e2);
+}
+
+U8 *ACDSortWords(U8 *start,I64 size,I64 word_cnt)
+{
+  U8 **ptr_array=MAlloc(sizeof(U8 *)*word_cnt),
+      *out_start=MAlloc(size),
+      *ptr=start,*ptr2;
+  I64 i=0;
+  while (*ptr) {
+    ptr_array[i++]=ptr;
+    ptr+=StrLen(ptr)+3;
+  }
+  "Sorting...\n"; Sleep(100);
+  QSortI64(ptr_array,word_cnt,&ACDCompareWords);
+  "Done...\n"; Sleep(100);
+
+  ptr=out_start;
+  for (i=0;i<word_cnt;i++) {
+    ptr2=ptr_array[i];
+    while (*ptr2)
+      *ptr++=*ptr2++;
+    *ptr++=*ptr2++; //zero
+    *ptr++=*ptr2++; //blk lo
+    *ptr++=*ptr2++; //blk hi
+  }
+  *ptr++=0;
+  return out_start;
+}
+
+U0 ACDGen(U8 *raw_dict_filename)
+{
+  I64 cmd,size,word_cnt=0,largest_entry=0;
+  U8 *st,*in_ptr=FileRead(raw_dict_filename,&size),*in_start=in_ptr,
+     *out_ptr=MAlloc(size),*out_start=out_ptr,
+     *word_ptr=MAlloc(size),*word_start=word_ptr,
+     *last_word="",*def_word_start=out_ptr,
+     *sorted_word_start;
+  U16 *d;
+  if (!in_ptr) return;
+  do {
+    cmd=ACDNextCmd(&in_ptr);
+    if (cmd==ACD_H1) {
+next_word:
+      if (out_ptr-def_word_start>largest_entry)
+	largest_entry=out_ptr-def_word_start;
+      def_word_start=out_ptr;
+      if (st=ACDNextEntry(&in_ptr)) {
+	if (*st) {
+	  if (StrICmp(st,last_word)) {
+	    word_cnt++;
+
+	    *word_ptr++=ACD_WORD_CHAR;
+	    last_word=word_ptr;
+	    StrCpy(word_ptr,st);
+	    word_ptr+=StrLen(st)+1;
+
+	    d=word_ptr;
+	    *d=(out_ptr-out_start)/ACD_BLK_SIZE;
+	    word_ptr+=2;
+ 
+	    *out_ptr++=ACD_WORD_CHAR;
+	    StrCpy(out_ptr,st);
+	    out_ptr+=StrLen(st)+1;
+	  }
+	  Free(st);
+
+	  do {
+	    do {
+	      cmd=ACDNextCmd(&in_ptr);
+	      if (cmd==ACD_H1)
+		goto next_word;
+	    } while (cmd>=0 && !(cmd==ACD_DEF||cmd==ACD_PRONUNCIATION||cmd==ACD_POS||cmd==ACD_EXTRA));
+	    if (cmd==ACD_DEF) {
+	      if(st=ACDNextEntry(&in_ptr)) {
+		if (*st) {
+		  *out_ptr++=ACD_DEF_CHAR;
+		  StrCpy(out_ptr,st);
+		  out_ptr+=StrLen(st)+1;
+		}
+		Free(st);
+	      }
+	    } else if (cmd==ACD_PRONUNCIATION) {
+	      if(st=ACDNextEntry(&in_ptr)) {
+		if (*st) {
+		  *out_ptr++=ACD_PRONUNCIATION_CHAR;
+		  StrCpy(out_ptr,st);
+		  out_ptr+=StrLen(st)+1;
+		}
+		Free(st);
+	      }
+	    } else if (cmd==ACD_POS) {
+	      if(st=ACDNextEntry(&in_ptr)) {
+		if (*st) {
+		  *out_ptr++=ACD_POS_CHAR;
+		  StrCpy(out_ptr,st);
+		  out_ptr+=StrLen(st)+1;
+		}
+		Free(st);
+	      }
+	    } else if (cmd==ACD_EXTRA) {
+	      if(st=ACDNextEntry(&in_ptr)) {
+		if (*st) {
+		  *out_ptr++=ACD_EXTRA_CHAR;
+		  StrCpy(out_ptr,st);
+		  out_ptr+=StrLen(st)+1;
+		}
+		Free(st);
+	      }
+	    }
+	  } while (cmd==ACD_DEF||cmd==ACD_PRONUNCIATION||cmd==ACD_POS||cmd==ACD_EXTRA);
+	} else
+	  Free(st);
+      }
+    }
+  } while (cmd>=0);
+  *out_ptr++=ACD_END_CHAR;
+  *word_ptr++=ACD_END_CHAR;
+
+  Free(in_start);
+
+  "Blk Size      :%d\n",ACD_BLK_SIZE;
+  "Blk Cnt       :%04X\n",(out_ptr-out_start+ACD_BLK_SIZE-1)/ACD_BLK_SIZE;
+  "Largest Entry :%d\n",largest_entry;
+  "Word Count    :%d\n",word_cnt;
+
+  FileWrite(ACD_DEF_FILENAME,out_start,out_ptr-out_start);
+  "Def File Size :%d\n",out_ptr-out_start;
+
+  sorted_word_start=ACDSortWords(word_start,word_ptr-word_start,word_cnt);
+  FileWrite(ACD_WORD_FILENAME,sorted_word_start,word_ptr-word_start);
+  "Word File Size:%d\n",word_ptr-word_start;
+
+  Free(out_start);
+  Free(word_start);
+  Free(sorted_word_start);
+}
+
+ACDGen("DICTIONARY.TXT");

Adam/AutoComplete/ACMain.CPP

@@ -0,0 +1,342 @@
+#help_index "AutoComplete"
+
+CHashAC *ACHashAdd(U8 *w)
+{
+  CHashAC *tempw=HashFind(w,ac.hash_table,HTT_WORD);
+  if (tempw) {
+    tempw->hits++;
+    return tempw;
+  }
+  tempw=ACAlloc(sizeof(CHashAC));
+  tempw->str=AStrNew(w);
+  tempw->type=HTT_WORD;
+  tempw->use_cnt=1;
+  tempw->hits=1;
+  HashAdd(tempw,ac.hash_table);
+  ac.num_words++;
+  return tempw;
+}
+
+U0 ACSingleFileAdd(U8 *buf)
+{
+  I64 ch;
+  U8 *ptr=buf,*ptr2,*ptr3;
+  while (TRUE) {
+    while (TRUE) {
+      if (ch=*ptr++) {
+	if (Bt(chars_bitmap_alpha_numeric,ch))
+	  break;
+      } else
+	return;
+    }
+    ptr3=ptr;
+    ptr2=ptr;
+    ptr--;
+    while (TRUE) {
+      if (ch=*ptr2++) {
+	if (Bt(chars_bitmap_alpha_numeric,ch))
+	  *ptr3++=ch;
+	else if (ch!=CH_CURSOR)
+	  break;
+      } else {
+	ptr2--;
+	break;
+      }
+    }
+    *ptr3=0;
+    ACHashAdd(ptr);
+    ptr=ptr2;
+  }
+}
+
+I64 ACSkipCrap(U8 *src,I64 len)
+{
+  I64 j;
+  j=len-1;
+  while (j>=0) {
+    if (Bt(chars_bitmap_alpha_numeric,src[j]))
+      break;
+    else
+      j--;
+  }
+  return j+1;
+}
+
+I64 ACPriorWordInStr(U8 *src,U8 *dst,I64 len,I64 buf_size)
+{
+  I64 i,j=0,k;
+  i=len-1;
+  while (i>=0)
+    if (!Bt(chars_bitmap_alpha_numeric,src[i]))
+      break;
+    else
+      i--;
+  if (i>=-1 && len>0)
+    for (k=i+1;k<len && j<buf_size-1;k++)
+      dst[j++]=src[k];
+  dst[j]=0;
+  return i+1;
+}
+
+U0 ACFillIn(I64 n)
+{
+  U8 *s;
+  if (0<=--n<ac.num_fillins) {
+    s=ac.fillin_matches[n]->str;
+    if (StrLen(s)>ac.partial_len)
+      Auto(s+ac.partial_len);
+  }
+}
+
+U0 ACMan(I64 n,CTask *parent_task=NULL)
+{
+  CHashAC *tempw;
+  CHashSrcSym *temph;
+  Bool old_preempt=Preempt(OFF);
+  if (0<=--n<ac.num_fillins && (tempw=ac.fillin_matches[n]) &&
+	(temph=HashFind(tempw->str,Fs->hash_table,HTG_SRC_SYM)) &&
+	temph->src_link) {
+    Preempt(old_preempt);
+    PopUpEd(temph->src_link,parent_task);
+  }
+  Preempt(old_preempt);
+}
+
+U0 ACFillInAdd(CHashAC *tempw)
+{
+  I64 k;
+  if (ac.num_fillins<AC_MAX_FILLINS || tempw->hits>ac.fillin_hits[ac.num_fillins-1]) {
+    for (k=ac.num_fillins-1;k>=0;k--) {
+      if (tempw->hits<=ac.fillin_hits[k])
+	break;
+      else {
+	ac.fillin_matches[k+1]=ac.fillin_matches[k];
+	ac.fillin_hits[k+1]   =ac.fillin_hits[k];
+      }
+    }
+    ac.fillin_matches[k+1]=tempw;
+    ac.fillin_hits[k+1]   =tempw->hits;
+    if (ac.num_fillins<AC_MAX_FILLINS)
+      ac.num_fillins++;
+  }
+}
+
+U0 ACPutChoices(CDoc *focus_l,CDocEntry *doc_e,CTask *focus_task)
+{
+  I64 i,data_col;
+  U8 *buf,*buf1,*src=NULL,*st;
+  CHashAC *tempw;
+  F64 timeout_time=tS+0.5;
+  CHashSrcSym *temph;
+  CDoc *doc=DocPut;
+
+  src=DocScanLine(focus_l,doc_e,&data_col);
+  DocUnlock(focus_l);
+  i=StrLen(src);
+  buf =MAlloc(MaxI64(i+1,256));
+  buf1=MAlloc(MaxI64(i+1,256));
+  if (data_col==-1)
+    data_col=0;
+  data_col=ACPriorWordInStr(src,buf,data_col,256);
+  ac.partial_len=StrLen(buf);
+  data_col=ACSkipCrap(src,data_col);
+  data_col=ACPriorWordInStr(src,buf1,data_col,256);
+
+  if (!ac.cur_word || StrCmp(ac.cur_word,buf)) {
+    st=ac.cur_word;
+    ac.cur_word=AStrNew(buf);
+    Free(st);
+    ac.num_fillins=0;
+    if (*ac.cur_word) {
+      Preempt(ON);
+      for (i=0;i<=ac.hash_table->mask;i++) {
+	tempw=ac.hash_table->body[i];
+	while (tempw && tS<timeout_time) {
+	  if (!MemCmp(ac.cur_word,tempw->str,StrLen(ac.cur_word)))
+	    ACFillInAdd(tempw);
+	  tempw=tempw->next;
+	}
+      }
+      Preempt(OFF);
+    }
+    DocRst(doc,TRUE);
+    doc->flags|=DOCF_MIN_SIZE;
+    DocCursor;
+    Fs->border_src=BDS_CONST;
+    Fs->text_attr =Fs->border_attr=LTGRAY<<4+BLUE;
+    if (ac.cur_word && *ac.cur_word) {
+      DocPrint(doc,"$$PURPLE$$Word:%s$$FG$$\n",ac.cur_word);
+      for (i=0;i<ac.num_fillins;i++) {
+	st=ac.fillin_matches[i]->str;
+	DocPrint(doc,"$$GREEN$$F%02d$$FG$$ ",i+1);
+	if (TaskValidate(focus_task) &&
+	      (temph=HashFind(st,focus_task->hash_table,HTG_SRC_SYM)) &&
+	      temph->src_link) {
+	  if (temph->type&HTF_PUBLIC)
+	    DocPrint(doc,"$$RED$$");
+	  DocPrint(doc,"$$TX+UL+L+PU,\"%Q\",A=\"%s\"$$$$FG$$\n",st,temph->src_link);
+	} else
+	  DocPrint(doc,"%s\n",st);
+      }
+      if (acd.has_words)
+	ACDDictWordsAdd(doc,ac.cur_word);
+    } else if (FileFind("::/Doc/StandBy.TXT.Z"))
+      DocType(doc,"::/Doc/StandBy.TXT.Z",0);
+
+    DocRecalc(doc);
+  }
+
+  if (!LBts(&Fs->display_flags,DISPLAYf_SHOW))
+    WinZBufUpdate;
+
+  Free(src);
+  Free(buf);
+  Free(buf1);
+}
+
+U0 ACTask(I64)
+{
+  CTask *focus_task,*original_focus_task;
+  CDoc *doc;
+  CDocEntry *doc_e;
+  I64 ch;
+  DocTermNew;
+  WinHorz(51,Fs->win_right);
+  LBts(&Fs->display_flags,DISPLAYf_WIN_ON_TOP);
+  Fs->win_inhibit=WIG_TASK_DFT-WIF_SELF_BORDER-WIF_SELF_IP_L-WIF_SELF_IP_R-WIG_DBL_CLICK;
+  Free(ac.cur_word);
+  ac.cur_word=NULL;
+  while (TRUE) {
+    original_focus_task=focus_task=sys_focus_task;
+    while (TaskValidate(focus_task) && Bt(&focus_task->task_flags,TASKf_INPUT_FILTER_TASK))
+      focus_task=focus_task->parent_task;
+    if (TaskValidate(focus_task) && (doc=DocPut(focus_task)) &&
+	  focus_task!=Fs && Bt(&focus_task->display_flags,DISPLAYf_SHOW)) {
+      DocLock(doc);
+      if (TaskValidate(focus_task) && original_focus_task==sys_focus_task &&
+	    doc && doc==DocPut(focus_task) && (doc_e=doc->cur_entry)) {
+	if (doc_e==doc) doc_e=doc_e->last;
+	while (doc_e->last!=doc && (doc_e->type_u8==DOCT_NEW_LINE ||
+	      doc_e->type_u8==DOCT_SOFT_NEW_LINE))
+	  doc_e=doc_e->last;
+	while (doc_e->last->type_u8!=DOCT_NEW_LINE && doc_e->last!=doc)
+	  doc_e=doc_e->last;
+	ACPutChoices(doc,doc_e,focus_task);
+      } else
+	DocUnlock(doc);
+    }
+    Sleep(333);
+    if (ScanMsg(&ch,,1<<MSG_KEY_DOWN) && (ch==CH_ESC||ch==CH_SHIFT_ESC))
+      break;
+    doc=DocPut;
+    DocLock(doc);
+    if (doc->cur_entry->de_flags & DOCEF_LINK) {
+      '' CH_SPACE;
+      doc->cur_entry=doc;
+    }
+    DocUnlock(doc);
+  }
+  ac.task=NULL;
+}
+
+U0 ACMainFileLstTraverse(U8 *files_find_mask)
+{
+  U8 *buf;
+  CDirEntry *tempde,*tempde1;
+  try {
+    tempde=tempde1=FilesFind(files_find_mask,FUF_RECURSE|FUF_JUST_TXT|FUF_JUST_FILES|FUF_CLUSTER_ORDER);
+    while (tempde) {
+      "%s\n",tempde->full_name;
+      buf=FileRead(tempde->full_name);
+      ACSingleFileAdd(buf);
+      Free(buf);
+      tempde=tempde->next;
+    }
+  } catch
+    Fs->catch_except=TRUE;
+  DirTreeDel(tempde1);
+}
+
+public Bool AutoComplete(Bool val=OFF)
+{//Turn AutoComplete OFF (or ON).
+  Bool	old_autocomplete=FALSE,
+	old_preempt=Preempt(OFF);
+  if (val) {
+    while (Bt(&ac.flags,ACf_INIT_IN_PROGRESS))
+      Sleep(10);
+    if (TaskValidate(ac.task))
+      old_autocomplete=TRUE;
+    else {
+      ac.task=Spawn(&ACTask,NULL,"AutoComplete");
+      TaskWait(ac.task);
+    }
+    WinToTop(ac.task);
+  } else {
+    if (TaskValidate(ac.task)) {
+      old_autocomplete=TRUE;
+      Kill(ac.task);
+      while (TaskValidate(ac.task))
+	Yield;
+      ac.task=NULL;
+    }
+  }
+  Preempt(old_preempt);
+  return old_autocomplete;
+}
+
+U0 ACProgressTask(Bool *_start_flag)
+{
+  I64 start=dsk.write_cnt;
+  progress1=0;
+  progress1_max=(Size(ACD_DEF_FILENAME_Z,"+x+s")+BLK_SIZE-1)>>BLK_SIZE_BITS;
+  StrCpy(progress1_desc,"Uncompressing Dictionary");
+  start=dsk.write_cnt;
+  *_start_flag=TRUE;
+  while (progress1<progress1_max) {
+    progress1=dsk.write_cnt-start;
+    Sleep(10);
+  }
+  *progress1_desc=progress1=progress1_max=0;
+}
+
+public U0 ACInit(U8 *mask=NULL)
+{//Read files and build AutoComplete statistics.
+  Bool start_flag;
+  CBlkDev *bd=Let2BlkDev;
+
+  while (LBts(&ac.flags,ACf_INIT_IN_PROGRESS))
+    Yield;
+  AutoComplete;
+
+  if (IsDrvWritable && FileFind(ACD_DEF_FILENAME_Z) && !FileFind(ACD_DEF_FILENAME)) {
+    if (bd->type!=BDT_RAM) {
+      start_flag=FALSE;
+      Spawn(&ACProgressTask,&start_flag);
+      while (!start_flag)
+	Yield;
+    }
+    Move(ACD_DEF_FILENAME_Z,ACD_DEF_FILENAME);
+  }
+
+  HashTableDel(ac.hash_table);
+  ac.hash_table=HashTableNew(2048,adam_task);
+
+  ac.num_words=0;
+  Free(ac.cur_word);
+  ac.cur_word=NULL;
+
+  if (mask)
+    ACMainFileLstTraverse(mask);
+
+  ACDWordsLoad;
+  LBtr(&ac.flags,ACf_INIT_IN_PROGRESS);
+  AutoComplete(ON);
+}
+
+I64 AutoCompleteSize()
+{
+  if (ac.hash_table)
+    return HashTableSize2(ac.hash_table)+MSize2(acd.word_lst);
+  else
+    return 0;
+}

Adam/AutoComplete/AutoComplete.CPP

@@ -0,0 +1,67 @@
+#help_index "AutoComplete"
+#help_file "::/Doc/AutoComplete"
+
+//See $LK,"::/Doc/AutoComplete.TXT"$
+
+#define ACf_INIT_IN_PROGRESS	0
+
+#define AC_MAX_FILLINS 10
+
+public class CAutoCompleteGlbls
+{
+  I64	num_words;
+  CHashTable *hash_table;
+  U8	*cur_word;
+  I64	flags;
+  CTask	*task;
+  I64	partial_len,num_fillins,
+	fillin_hits	[AC_MAX_FILLINS+1];
+  CHashAC *fillin_matches[AC_MAX_FILLINS+1];
+
+} ac={0,NULL,NULL,0,NULL,0,0,
+{0,0,0,0,0,0,0,0,0,0,0},
+{NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}};
+
+//Dictionary Stuff
+#help_index "AutoComplete/Dictionary"
+
+#define ACD_WORD_FILENAME	"/Adam/AutoComplete/ACWords.DAT.Z"
+#define ACD_DEF_FILENAME	"/Adam/AutoComplete/ACDefs.DAT"
+#define ACD_DEF_FILENAME_Z	"/Adam/AutoComplete/ACDefs.DAT.Z"
+
+#define ACD_H1			0
+#define ACD_H1_END		1
+#define ACD_DEF			2
+#define ACD_DEF_END		3
+#define ACD_PRONUNCIATION	4
+#define ACD_PRONUNCIATION_END	5
+#define ACD_POS			6
+#define ACD_POS_END		7
+#define ACD_EXTRA		8
+#define ACD_EXTRA_END		9
+#define ACD_BLK_SIZE		0x4000
+
+#define ACD_END_CHAR		0x00
+#define ACD_WORD_CHAR		0x01
+#define ACD_DEF_CHAR		0x02
+#define ACD_PRONUNCIATION_CHAR	0x03
+#define ACD_POS_CHAR		0x04
+#define ACD_EXTRA_CHAR		0x05
+
+#define ACD_MAX_FILLINS 10
+
+public class CAutoCompleteDictGlbls
+{
+  U8	*word_lst;
+  I64	word_lst_size,num_words,num_fillins;
+  U8	*fillins[ACD_MAX_FILLINS];
+  Bool	has_words,has_defs;
+} acd={NULL,0,0,0,{0,0,0,0,0,0,0,0,0,0},FALSE,FALSE};
+acd.has_words=FileFind(ACD_WORD_FILENAME);
+acd.has_defs =FileFind(ACD_DEF_FILENAME)||FileFind(ACD_DEF_FILENAME_Z);
+
+extern U0 ACDWordsLoad();
+extern U0 ACDDictWordsAdd(CDoc *doc,U8 *st);
+
+#include "ACMain"
+#include "ACDict"