Initial (manual) import

TempleOSCD/Adam/AutoComplete/ACDictGen.HC

@@ -0,0 +1,263 @@
+/*
+This file is a stand-alone program
+which will regenerate processed dictionary
+files from a raw Project Gutenberg
+dictionary file.
+
+$TX,"http://www.templeos.org/files/DICTIONARY.DD",HTML="http://www.templeos.org/files/DICTIONARY.DD"$
+
+See $LK,"::/Doc/Credits.DD"$.
+*/
+
+U0 ACDPreprocess(U8 *in_name,U8 *out_name)
+{/*
+<cr><nl>--> <nl>
+$$	--> $$$$
+\'89	--> ‰
+*/
+  I64 ch,i;
+  U8 *src,*dst;
+  CDoc *doc;
+  CDocEntry *doc_e;
+  if (doc=DocRead(in_name,DOCF_PLAIN_TEXT_TABS|DOCF_DBL_DOLLARS)) {
+    doc_e=doc->head.next;
+    while (doc_e!=doc) {
+      if (doc_e->type_u8==DOCT_TEXT) {
+	src=dst=doc_e->tag;
+	while (ch=*src++) {
+	  if (ch=='\\' && *src=='\'') {
+	    src++;
+	    i=0;
+	    ch=ToUpper(*src++);
+	    if ('0'<=ch<='9')
+	      i+=ch-'0';
+	    else if ('A'<=ch<='F')
+	      i+=ch-'A'+10;
+	    i<<=4;
+	    ch=ToUpper(*src++);
+	    if ('0'<=ch<='9')
+	      i+=ch-'0';
+	    else if ('A'<=ch<='F')
+	      i+=ch-'A'+10;
+	    *dst++=i;
+	  } else
+	    *dst++=ch;
+	}
+	*dst=0;
+      }
+      doc_e=doc_e->next;
+    }
+    StrCpy(doc->filename.name,out_name);
+    DocWrite(doc);
+    DocDel(doc);
+  }
+}
+
+I64 ACDNextCmd(U8 **_ptr)
+{
+  U8 *ptr=*_ptr,*ptr2;
+  I64 ch,res=-1;
+  do {
+    do {
+      if (!(ch=*ptr++)) goto ncmd_done;
+    } while (ch!='<');
+
+    ptr2=ptr;
+    do {
+      if (!(ch=*ptr2++)) goto ncmd_done;
+    } while (ch!='>');
+    *--ptr2=0;
+    res=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 (res<0);
+
+  ncmd_done:
+  *_ptr=ptr;
+  return res;
+}
+
+U8 *ACDNextEntry(U8 **_ptr)
+{
+  U8 *res,*ignore,*ptr=*_ptr,buf[ACD_BLK_SIZE],*out_ptr=buf;
+  I64 ch,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;
+  res=StrNew(buf);
+  *_ptr=ptr-1;
+  return res;
+}
+
+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 *in_file)
+{
+  I64 cmd,size,word_cnt=0,largest_entry=0;
+  U8 *st,*in_ptr=FileRead(in_file,&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);
+}
+
+Cd(__DIR__);
+ACDPreprocess("DICTIONARY.DD","DICTIONARY2.DD");
+ACDGen("DICTIONARY2.DD");

TempleOSCD/Adam/AutoComplete/ACFill.HC

@@ -0,0 +1,261 @@
+#help_index "AutoComplete/Dictionary"
+public U8 *ACDDefGet(U8 *st,I64 def_num=1)
+{//MAlloc str holding single dict definition of word.
+  CFile *f;
+  CHashGeneric *tmph;
+  U8 *res=NULL,*buf,*in_ptr,
+	*st2=MStrUtil(st,SUF_TO_UPPER);
+  tmph=HashFind(st2,ac.hash_table,HTT_DICT_WORD);
+  Free(st2);
+  if (tmph) {
+    if (f=FOpen(ACD_DEF_FILENAME,"r")) {
+      buf=MAlloc(ACD_BLK_SIZE*2+1);
+      buf[ACD_BLK_SIZE*2]=0; //terminate
+      FRBlks(f,buf,tmph->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) {
+	      res=StrNew(in_ptr);
+	      break;
+	    }
+	  }
+	}
+      }
+      Free(buf);
+    }
+  }
+  return res;
+}
+
+public U8 *ACDDefsGet(U8 *st)
+{//MAlloc str with all dict definitions of word.
+  CFile *f;
+  CHashGeneric *tmph;
+  U8 *res=NULL,*buf,*in_ptr,*in_ptr2,
+	*st2=MStrUtil(st,SUF_TO_UPPER);
+  tmph=HashFind(st2,ac.hash_table,HTT_DICT_WORD);
+  Free(st2);
+  if (tmph) {
+    if (f=FOpen(ACD_DEF_FILENAME,"r")) {
+      buf=MAlloc(ACD_BLK_SIZE*2+1);
+      buf[ACD_BLK_SIZE*2]=0; //terminate
+      FRBlks(f,buf,tmph->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++;
+	    }
+	    res=MAlloc(in_ptr2+1-in_ptr);
+	    MemCpy(res,in_ptr,in_ptr2-in_ptr);
+	    res[in_ptr2-in_ptr]=ACD_END_CHAR;
+	    break;
+	  }
+	}
+      }
+      Free(buf);
+    }
+  }
+  return res;
+}
+
+/*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 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)
+      In(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 ACMisspelledFind(CDoc *doc)
+{
+  Bool unlock=DocLock(doc);
+  CDocEntry *doc_e=doc->cur_entry;
+  I64 col=doc->cur_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(char_bmp_word,doc_e->tag[col]))
+	  col++;
+	if (col<doc_e->max_col) {
+	  col2=col;
+	  while (col2<doc_e->max_col && Bt(char_bmp_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_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);
+}
+
+#help_index "AutoComplete"
+U0 ACFillIn(I64 n)
+{
+  U8 *s;
+  if (0<=--n<ac.num_fillins) {
+    s=ac.fillin_matches[n]->str;
+    if (StrLen(s)>ac.partial_len)
+      In(s+ac.partial_len);
+  }
+}
+
+U0 ACMan(I64 n,CTask *parent_task=NULL)
+{
+  CHashAC *tmpw;
+  CHashSrcSym *tmph;
+  if (0<=--n<ac.num_fillins && (tmpw=ac.fillin_matches[n]) &&
+	(tmph=HashFind(tmpw->str,Fs->hash_table,HTG_SRC_SYM)) &&
+	tmph->src_link)
+    PopUpEd(tmph->src_link,parent_task);
+}

TempleOSCD/Adam/AutoComplete/ACInit.HC

@@ -0,0 +1,169 @@
+#help_index "AutoComplete/Dictionary"
+acd.has_words=FileFind(ACD_WORD_FILENAME);
+acd.has_defs =FileFind(ACD_DEF_FILENAME)||FileFind(ACD_DEF_FILENAME_Z);
+
+public U0 ACDWordsLoad()
+{//Put words from word list into hash table.
+  I64 size;
+  CHashGeneric *tmph;
+  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);
+	tmph=ACAlloc(sizeof(CHashGeneric)+StrLen(st2)+1);
+	StrCpy(tmph+1,st2);
+	Free(st2);
+	in_ptr+=StrLen(in_ptr)+1;
+	tmph->str=tmph+1;
+	tmph->use_cnt=1;
+	tmph->type=HTT_DICT_WORD;
+	d=in_ptr;
+	tmph->user_data0=*d;
+	in_ptr+=2;
+	HashAdd(tmph,ac.hash_table);
+	acd.num_words++;
+      } else
+	in_ptr+=3;
+    }
+    Free(in_start);
+  }
+}
+
+#help_index "AutoComplete"
+CHashAC *ACHashAdd(U8 *w)
+{
+  CHashAC *tmpw=HashFind(w,ac.hash_table,HTT_WORD);
+  if (tmpw) {
+    tmpw->hits++;
+    return tmpw;
+  }
+  tmpw=ACAlloc(sizeof(CHashAC));
+  tmpw->str=AStrNew(w);
+  tmpw->type=HTT_WORD;
+  tmpw->use_cnt=1;
+  tmpw->hits=1;
+  HashAdd(tmpw,ac.hash_table);
+  ac.num_words++;
+  return tmpw;
+}
+
+U0 ACSingleFileAdd(U8 *buf)
+{
+  I64 ch;
+  U8 *ptr=buf,*ptr2,*ptr3;
+  while (TRUE) {
+    while (TRUE) {
+      if (ch=*ptr++) {
+	if (Bt(char_bmp_alpha_numeric,ch))
+	  break;
+      } else
+	return;
+    }
+    ptr3=ptr;
+    ptr2=ptr;
+    ptr--;
+    while (TRUE) {
+      if (ch=*ptr2++) {
+	if (Bt(char_bmp_alpha_numeric,ch))
+	  *ptr3++=ch;
+	else if (ch!=CH_CURSOR)
+	  break;
+      } else {
+	ptr2--;
+	break;
+      }
+    }
+    *ptr3=0;
+    ACHashAdd(ptr);
+    ptr=ptr2;
+  }
+}
+
+U0 ACMainFileLstTraverse(U8 *files_find_mask)
+{
+  U8 *buf;
+  CDirEntry *tmpde,*tmpde1;
+  try {
+    tmpde=tmpde1=FilesFind(files_find_mask,
+	  FUF_RECURSE|FUF_JUST_TXT|FUF_JUST_FILES|FUF_CLUSTER_ORDER);
+    while (tmpde) {
+      "%s\n",tmpde->full_name;
+      buf=FileRead(tmpde->full_name);
+      ACSingleFileAdd(buf);
+      Free(buf);
+      tmpde=tmpde->next;
+    }
+  } catch
+    Fs->catch_except=TRUE;
+  DirTreeDel(tmpde1);
+}
+
+U0 ACProgressTask(Bool *_start_flag)
+{
+  I64 start=blkdev.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=blkdev.write_cnt;
+  *_start_flag=TRUE;
+  while (progress1<progress1_max) {
+    progress1=blkdev.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;
+
+  LBtr(&sys_run_level,RLf_AUTO_COMPLETE);
+  AutoComplete;
+  while (LBts(&ac.flags,ACf_INIT_IN_PROGRESS))
+    Yield;
+  if (DrvIsWritable && 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);
+  LBts(&sys_run_level,RLf_AUTO_COMPLETE);
+  AutoComplete(ON);
+}
+
+I64 AutoCompleteSize()
+{
+  if (ac.hash_table)
+    return HashTableSize2(ac.hash_table)+MSize2(acd.word_lst);
+  else
+    return 0;
+}

TempleOSCD/Adam/AutoComplete/ACTask.HC

@@ -0,0 +1,284 @@
+#help_index "AutoComplete/Dictionary"
+U0 ACDDictWordsAdd(U8 *st)
+{
+  I64 i;
+  U8 *ptr;
+  if (st && *st && (ptr=ACDWordPtAt(st))) {
+    for (i=0;i<ACD_FILLINS_NUM;i++) {
+      if (*ptr++!=ACD_WORD_CHAR)
+	break;
+      if (i) '\n';
+      acd.fillins[i]=ptr-1;
+      "$$GREEN$$'%d'$$FG$$ %-23ts",i,ptr;
+      ptr+=StrLen(ptr)+3;
+    }
+    acd.num_fillins=i;
+  }
+}
+
+#help_index "AutoComplete"
+U0 ACDocRst(I64 left,I64 top)
+{
+  CDoc *doc=DocPut;
+  DocRst(doc,TRUE);
+  doc->flags|=DOCF_SIZE_MIN;
+  Fs->border_src=BDS_CONST;
+  Fs->border_attr=LTGRAY<<4+DrvTextAttrGet(':')&15;
+  Fs->text_attr  =LTGRAY<<4+BLUE;
+  LBtr(&Fs->display_flags,DISPLAYf_SHOW);
+  WinHorz(left,Fs->win_right);
+  WinVert(top,Fs->win_bottom);
+  DocCursor;
+}
+
+I64 ACSkipCrap(U8 *src,I64 len)
+{
+  I64 j;
+  j=len-1;
+  while (j>=0) {
+    if (Bt(char_bmp_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(char_bmp_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 ACFillInAdd(CHashAC *tmpw)
+{
+  I64 k;
+  if (ac.num_fillins<AC_FILLINS_NUM ||
+	tmpw->hits>ac.fillin_hits[ac.num_fillins-1]) {
+    for (k=ac.num_fillins-1;k>=0;k--) {
+      if (tmpw->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]=tmpw;
+    ac.fillin_hits[k+1]   =tmpw->hits;
+    if (ac.num_fillins<AC_FILLINS_NUM)
+      ac.num_fillins++;
+  }
+}
+
+U0 ACPutChoices(CDoc *focus_l,CDocEntry *doc_e,CTask *focus_task,
+	Bool force_refresh)
+{
+  I64 i,data_col;
+  U8 *buf,*buf1,*src=NULL,*st;
+  CHashAC *tmpw;
+  F64 timeout_time=tS+0.5;
+  CHashSrcSym *tmph;
+
+  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) || force_refresh) {
+    st=ac.cur_word;
+    ac.cur_word=AStrNew(buf);
+    Free(st);
+    ac.num_fillins=0;
+    if (*ac.cur_word)
+      for (i=0;i<=ac.hash_table->mask && tS<timeout_time;i++) {
+	tmpw=ac.hash_table->body[i];
+	while (tmpw) {
+	  if (!MemCmp(ac.cur_word,tmpw->str,StrLen(ac.cur_word)))
+	    ACFillInAdd(tmpw);
+	  tmpw=tmpw->next;
+	}
+      }
+    ACDocRst(51,13);
+    if (ac.cur_word && *ac.cur_word) {
+      "$$PURPLE$$Word:%s$$FG$$\n",ac.cur_word;
+      for (i=0;i<ac.num_fillins;i++) {
+	st=ac.fillin_matches[i]->str;
+	"$$GREEN$$F%02d$$FG$$ ",i+1;
+	if (TaskValidate(focus_task) &&
+	      (tmph=HashFind(st,focus_task->hash_table,HTG_SRC_SYM)) &&
+	      tmph->src_link) {
+	  if (tmph->type&HTF_PUBLIC)
+	    "$$RED$$";
+	  "$$TX+UL+L+PU,\"%$$Q\",A=\"%s\"$$$$FG$$\n",st,tmph->src_link;
+	} else
+	  "%s\n",st;
+      }
+      if (acd.has_words)
+	ACDDictWordsAdd(ac.cur_word);
+    } else if (FileFind("::/Doc/StandBy.DD.Z"))
+      Type("::/Doc/StandBy.DD.Z",0);
+  }
+  Free(src);
+  Free(buf);
+  Free(buf1);
+}
+
+U0 ACTaskNormal(I64 sc,I64 last_sc,
+	CTask *focus_task,CTask *original_focus_task)
+{
+  CDoc *doc;
+  CDocEntry *doc_e;
+  if ((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,ToBool(sc!=last_sc));
+    } else
+      DocUnlock(doc);
+  }
+  if (!LBts(&Fs->display_flags,DISPLAYf_SHOW))
+    WinZBufUpdate;
+}
+
+U0 ACTaskCtrl(I64 sc,I64 last_sc,
+	CTask *focus_task,CTask *original_focus_task)
+{
+  if (TaskValidate(focus_task) &&
+	(focus_task->scroll_x || focus_task->scroll_y)) {
+    if (LBtr(&Fs->display_flags,DISPLAYf_SHOW))
+      WinZBufUpdate;
+  } else {
+    if (sc!=last_sc) {
+      if (sc&SCF_ALT) {
+	ACDocRst(27,3);
+	if (TaskValidate(original_focus_task) &&
+	      !Bt(&original_focus_task->win_inhibit,WIf_SELF_KEY_DESC))
+	  KeyMapFamily(original_focus_task,0,
+		ToBool(!(sc&SCF_SHIFT)),ToBool(sc&SCF_SHIFT));
+	KeyMapCtrlAltFamily(
+	      ToBool(!(sc&SCF_SHIFT)),ToBool(sc&SCF_SHIFT));
+      } else if (TaskValidate(original_focus_task) &&
+	    !Bt(&original_focus_task->win_inhibit,WIf_SELF_KEY_DESC)) {
+	ACDocRst(27,3);
+	KeyMapFamily(original_focus_task,SCF_CTRL,
+	      ToBool(!(sc&SCF_SHIFT)),ToBool(sc&SCF_SHIFT));
+      }
+    }
+    if (!LBts(&Fs->display_flags,DISPLAYf_SHOW))
+      WinZBufUpdate;
+  }
+}
+
+U0 ACTaskAlt(I64 sc,I64 last_sc,
+	CTask *,CTask *original_focus_task)
+{
+  if (sc!=last_sc && TaskValidate(original_focus_task) &&
+	!Bt(&original_focus_task->win_inhibit,WIf_SELF_KEY_DESC)) {
+    ACDocRst(27,3);
+    KeyMapFamily(original_focus_task,SCF_ALT,
+	  ToBool(!(sc&SCF_SHIFT)),ToBool(sc&SCF_SHIFT));
+  }
+  if (!LBts(&Fs->display_flags,DISPLAYf_SHOW))
+    WinZBufUpdate;
+}
+
+U0 ACTaskEndCB()
+{
+  ac.task=NULL;
+  Exit;
+}
+
+U0 ACTask(I64)
+{
+  CTask *focus_task,*original_focus_task;
+  I64 ch,scan_code=0,last_scan_code=0;
+  CDoc *doc;
+  Fs->task_end_cb=&ACTaskEndCB;
+  DocTermNew;
+  LBts(&Fs->display_flags,DISPLAYf_SHOW);
+  WinHorz(51,Fs->win_right);
+  LBts(&Fs->display_flags,DISPLAYf_WIN_ON_TOP);
+  Fs->win_inhibit=WIG_TASK_DFT-WIF_SELF_BORDER
+	-WIF_SELF_MS_L-WIF_SELF_MS_R-WIG_DBL_CLICK;
+  Free(ac.cur_word);
+  ac.cur_word=NULL;
+  while (TRUE) {
+    if (scan_code&(SCF_CTRL|SCF_ALT) ||
+	  GetTSC>KbdMsEvtTime+cnts.time_stamp_freq>>1) {
+      last_scan_code=scan_code;
+      scan_code=kbd.scan_code;
+    }
+    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 (scan_code&SCF_CTRL)
+      ACTaskCtrl(scan_code,last_scan_code,focus_task,original_focus_task);
+     else if (TaskValidate(focus_task)) {
+      if (scan_code&SCF_ALT)
+	ACTaskAlt(scan_code,last_scan_code,focus_task,original_focus_task);
+      else
+	ACTaskNormal(scan_code,last_scan_code,focus_task,original_focus_task);
+    }
+    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);
+  }
+}
+
+public Bool AutoComplete(Bool val=OFF)
+{//Turn AutoComplete OFF or ON.
+  Bool	old_autocomplete=FALSE;
+  while (Bt(&ac.flags,ACf_INIT_IN_PROGRESS))
+    Sleep(10);
+  if (val) {
+    if (Bt(&sys_run_level,RLf_AUTO_COMPLETE)) {
+      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)) {
+      if (Bt(&sys_run_level,RLf_AUTO_COMPLETE))
+	old_autocomplete=TRUE;
+      Kill(ac.task);
+      DeathWait(&ac.task);
+    }
+  }
+  return old_autocomplete;
+}

TempleOSCD/Adam/AutoComplete/MakeAC.HC

@@ -0,0 +1,6 @@
+//See $LK,"::/Doc/AutoComplete.DD"$
+Cd(__DIR__);;
+#include "ACFill"
+#include "ACTask"
+#include "ACInit"
+Cd("..");;