Initial import of 5.0 source code with minor changes to use termios on Linux.

1 files changed, 2860 insertions, 0 deletions

diff --git a/comc.c b/comc.c
new file mode 100644
index 0000000..b938aad
--- /dev/null
+++ b/comc.c
@@ -0,0 +1,2860 @@
+/*Copyright (c) Anker Berg-Sonne, 1985,1986,1987*/
+#include "proto.h"
+
+extern regexp *Exp;
+
+/*      Save the current virtual cursor position and attributes and set them
+	to the new values given.
+*/
+void Fast Sav_Set(int *S_Line,long *S_Col,char *S_Attributes,int N_Line,
+ long N_Col,char N_Attributes)
+{(*S_Line)=My_Line;
+ (*S_Col)=My_Col;
+ Opt_Cursor(N_Line,N_Col);
+ if (S_Attributes!=NULL)
+ {*S_Attributes=Cur_Attributes;
+  Cur_Attributes=N_Attributes;
+ }
+#if defined(VMS) | defined(UNIX)
+ if (Shifted_Out)
+ {Out_Zap();
+  putchar(15);
+ }
+#endif
+}
+
+/*      Restore the virtual cursor position and attributes to the saved values.
+*/
+void Fast Set_Save(int S_Line,long S_Col,char S_Attributes)
+{Opt_Cursor(S_Line,S_Col);
+ Cur_Attributes=S_Attributes;
+#if defined(VMS) | defined(UNIX)
+ if (Shifted_Out)
+ {Out_Zap();
+  putchar(14);
+ }
+#endif
+}
+
+void Fast Clr_Typeahead()
+{
+#if defined(DOS) & !defined(Windows)
+ while ((bdos(0x0B,0,0)&0x00FF)!=0)
+  bdos(0x07,0,0);
+#endif
+#if defined(OS2)
+ if (!Mouse_OK)
+  KbdFlushBuffer(0);
+#endif
+}
+
+/*      Print the string given on the bottom line of the display and input
+        a Y or a N. Return true if the reponse was a Y.
+*/
+int Fast Yes_No(char *S)
+{
+#if defined(ATARI) & defined(GEM)
+ return GEM_Yes_No(S);
+#elif (defined(DOS) | defined(NT)) & defined(Windows)
+ return Win_Yes_No(S);
+#elif defined(DOS) & defined(TV)
+ return TV_Yes_No(S);
+#else
+ int Sav_Line, Sav_Update;
+ long Sav_Col, Sav_Shift;
+ char Sav_Attributes;;
+#if defined(VMS) | defined(UNIX) 
+ if (Gotmouse)	/* 290a */
+  Disable_Mouse();
+#endif
+ /*Clr_Typeahead();*/
+ Mark_Cursor();
+ Set_Physical();
+ Sav_Set(&Sav_Line,&Sav_Col,&Sav_Attributes,Scr_Length,(long)1,A_Bold);
+ Sav_Shift=Scr_Shift;
+ Scr_Shift=0;
+ Sav_Update=Update_Flag;
+ Update_Flag=1;
+ strcpy(Dsk_Rec,S);
+ strcat(Dsk_Rec,Yes_No_Txt);
+ Opt_String(Dsk_Rec);
+ Opt_Erase_Line();
+ Err_Display=0;
+ Get16();
+ while (Character!=Chr_Y&&Character!=tolower(Chr_Y)&&
+  Character!=Chr_N&&Character!=tolower(Chr_N)&&Character!=21)
+ {Clr_Typeahead();
+#if defined(DOS) & !defined(Windows)
+  if (!In_Int24)
+#endif
+   Out_C('\7');
+  Get16();
+ }
+ Opt_Char((char)Character);
+ Set_Save(Sav_Line,Sav_Col,Sav_Attributes);
+ Set_Logical();
+ Scr_Shift=Sav_Shift;
+ Update_Flag=Sav_Update;
+ Unmark_Cursor();
+#if defined(VMS) | defined(UNIX)
+ if (Gotmouse)	/* 290a */
+  Enable_Mouse();
+#endif
+ Out_Zap();
+ Err_Display=1;
+#if (defined(DOS) | defined(NT)) & defined(Windows)
+ if (Working_Flag)
+  Win_Clear_Working();
+#endif
+ Working_Flag=0;
+ if (Character==21)
+ {Error(3,Txt_Cancelled);
+  return 0;
+ }
+ return(Character==Chr_Y||Character==tolower(Chr_Y));
+#endif
+}
+
+/*      Save the output file of the current buffer. Set Not_End to false if
+        no other buffers contain unsaved changes. If there are unsaved changes
+        ask the operator whether he wished to exit sedt and set Not_End to
+        false if he responds with a Y.
+*/
+void Fast Exit_Sedt()
+/*Exit from Sedt*/
+{int Buffer;
+ char *P;
+ if ((P=Outfile)==NULL||P[0]==0)
+  Error(2,No_File_Txt); else
+ {if (!Read_Only[Cur_Buffer]||Yes_No(Txt_Read_Only))
+   Wr_Buffer(P);
+  if (Err_Flag)
+   return;
+  Clr_Changes();
+#if (defined(DOS) | defined(NT)) & defined(Windows)
+  Win_Quit();
+  if ((Any_Changes[Cur_Buffer]&1)&&!Read_Only[Cur_Buffer])
+   return;
+  if (Err_Flag)
+   return;
+#else
+#if defined(ATARI) & defined(GEM)
+  GEM_Quit();
+#else
+  Not_End=0;
+  Buffer=Cur_Buffer;
+  {register int I;
+   Sav_Window(Cur_Buffer);
+   for (I=0;I<Maxbuffers;I++)
+   {if ((++Buffer)==Maxbuffers)
+     Buffer=0;
+    if (Dl_Pointers[Pointers+Buffer][0]!=0)
+    {if ((Any_Changes[Buffer]&1)&&!Read_Only[Buffer])
+     {Not_End=!Yes_No(Unsaved_Chng_Txt);
+      if (Not_End)
+		{if (Err_Flag)
+		  return;
+		 Ch_Window(Buffer);
+		}
+		break;
+	  }
+	 }
+	}
+#if defined(UNIX) | defined(DOS)
+	if (!Not_End)
+	 for (I=0;I<Maxbuffers;I++)
+	 {if ((++Buffer)==Maxbuffers)
+		Buffer=0;
+	  if (Reservation&&File_Reserved[Buffer])
+	  {Load_Window(Buffer);
+		if (chmod(Outfile,File_Protection[Buffer])!=0)
+		Plain_Message(No_Reset_Txt); else
+		 Plain_Message(Reset_Txt);
+	  }
+	 }
+#endif
+  }
+#endif
+#endif
+ }
+ Return_Value=Count;
+}
+
+void Fast Rem_Autosave()
+{
+#if defined(VMS)
+ char Autofile[80];
+#else
+ char Autofile[512];
+#endif
+ Filnam(Outfile,Autofile);
+#if defined(UNIX)
+ strcat(Autofile,".aus");
+#else
+ strcat(Autofile,".AUS");
+#endif
+#if defined(VMS)
+ delete(Autofile);
+#else
+ unlink(Autofile);
+#endif
+ Auto_Saved=0;
+}
+
+/*      
+ * VKS Exit: Always save document in buffer 0 and let the user deside
+ *           what he wants to do with other changed buffers
+ */
+void Fast VKS_Exit()
+{
+	int	i;
+	Not_End = 0;
+	for(i = 1; i < Maxbuffers; i++)
+		if((Any_Changes[i] & 1) && ! Read_Only[i])
+    		{
+			Ch_Window(i);
+			if(Not_End=!Yes_No(Unsaved_Chng_Txt))
+				break;
+
+			Any_Changes[i] = 0;
+		}
+
+
+	if(! Not_End)
+	{
+		Ch_Window(0);
+		Exit_Sedt();
+	}
+	else
+		Return_Value = Count;
+}
+
+/*      
+ * PowerQuit: Don't bother the user who wants to quit. He is a grown up
+ *            individual who blames himself if he makes a mistake ;-)
+ */
+void Fast VKS_Quit()
+{
+	int	i;
+	for(i = 0; i < Maxbuffers; i++)
+		Any_Changes[i] = 0;
+	
+	Quit();
+}
+
+/*      Quit from the SEDT session if there are no buffers with unsaved 
+        changes or the user confirms quitting.
+*/
+void Fast Quit()
+{int Buffer;
+#if (defined(DOS) | defined(NT)) & defined(Windows)
+ Win_Quit();
+ if ((Any_Changes[Cur_Buffer]&1)&&!Read_Only[Cur_Buffer])
+  return;
+ if (Err_Flag)
+  return;
+#else
+#if defined(ATARI) & defined(GEM)
+ GEM_Quit();
+#else
+ Not_End=0;
+ Buffer=Cur_Buffer;
+ {register int I;
+  Sav_Window(Cur_Buffer);
+  for (I=0;I<Maxbuffers;I++)
+  {if ((++Buffer)==Maxbuffers)
+    Buffer=0;
+   if (Dl_Pointers[Pointers+Buffer][0]!=0)
+   {if ((Any_Changes[Buffer]&1)&&!Read_Only[Buffer])
+    {Not_End=!Yes_No(Unsaved_Chng_Txt);
+     if (Not_End&&Buffer!=Cur_Buffer)
+     {if (Err_Flag)
+       return;
+      Ch_Window(Buffer);
+     }
+     break;
+    }
+   }
+  }
+#if defined(UNIX) | defined(DOS)
+  if (!Not_End)
+	for (I=0;I<Maxbuffers;I++)
+	{if ((++Buffer)==Maxbuffers)
+	  Buffer=0;
+	 if (Reservation&&File_Reserved[Buffer])
+	 {Load_Window(Buffer);
+		if (chmod(Outfile,File_Protection[Buffer])!=0)
+	  Plain_Message(No_Reset_Txt); else
+		Plain_Message(Reset_Txt);
+    }
+   }
+#endif
+ }
+#endif
+#endif
+ Return_Value=Count;
+}
+
+/*      Insert Tab and Space characters until the cursor is at column Col
+*/
+void Fast Tab_To(long Col)
+{int C;
+ B_Goto(Current,My_Pos);
+ if (Replace_Mode)
+ {Set_Region();
+  while (My_Col<Col)
+  {if (Current->Pos>=End_Region||Chk_EL(Current,C=B_Get(Current)))
+   {if (!Tab_Expand)
+     while (((My_Col-1)/8+1)*8+1<=Col)
+      Ins_Char(9);
+    while (My_Col<Col)
+     Ins_Char(' ');
+    break;
+   } else
+   {if (C==9&&My_Col+Char_Rep(C,NULL)>Col)
+    {while (My_Col<Col)
+      Ins_Char(' ');
+    } else
+    {My_Col+=Char_Rep(C,NULL);
+     My_Pos++;
+    }
+   }
+  }
+ } else
+ {if (!Tab_Expand)
+   while (((My_Col-1)/8+1)*8+1<=Col)
+    Ins_Char(9);
+  while (My_Col<Col)
+   Ins_Char(' ');
+ }
+}
+
+void Fast A_New_Line()
+{long Sel_Pos;
+ int Sav_Show_Errors, Sav_Replace_Mode;
+ Set_Region();
+ if (Replace_Mode&&My_Pos<=End_Region)
+ {Sav_Show_Errors=Show_Errors;
+  Show_Errors=0;
+  Init_Entity();
+  Line();
+  Move_Entity();
+  if (Err_Flag||(My_Pos>=End_Region&&My_Col!=1))
+  {Err_Flag=0;
+   New_Line((long)1);
+   Set_Changes();
+  }
+  Show_Errors=Sav_Show_Errors;
+ } else
+ {Sav_Replace_Mode=Replace_Mode;
+  Replace_Mode=0;
+  New_Line((long)1);
+  Set_Changes();
+  Replace_Mode=Sav_Replace_Mode;
+ }
+ if (Blk_Mode&&(Sel_Pos=Points[0])!=0)
+ {if (Sel_Pos<My_Pos)
+   Fill_Screen(Rel_First,0);
+ }
+}
+
+/*      Insert a line terminator and move to the new line. Advance the cursor 
+        to the left margin position.
+*/
+void Fast New_Line(long Indent)
+{while (Count--&&!Check_CC())
+ {B_Goto(Current,My_Pos);
+#if ! (defined(UNIX) | defined(MPE))
+  Put_A_Char('\r');
+  Do_New_Line(2,Indent);
+#else
+  Do_New_Line(1,Indent);
+#endif
+ }
+}
+
+void Fast Do_New_Line(int N,long Indent)
+{Put_A_Char('\n');
+ Buf_Lines++;
+ if (Auto_Margin&&Indent)
+  Find_Margin();
+ if (Float_Cursor&&Rel_Last!=Margin)
+ {Opt_Scroll(-1,1,Rel_Last);
+  Fill_Screen(0,1);
+  My_Pos+=N;
+  This_Line++;
+  My_Line=Home= ++Home;
+  Rel_First--;
+  Rel_Last--;
+ } else
+ {My_Pos+=N;
+  This_Line++;
+  B_Goto(Current,My_Pos);
+  if (Rel_First!=0)
+  {Opt_Scroll(1,Rel_First,0);
+   Fill_Screen(-1,0);
+  } else
+   Fill_Screen(0,0);
+ }
+ My_Col=1;
+ if (Indent)
+ {if (Auto_Margin)
+   Tab_To(Word_Wrap); else
+  if (Left_Margin!=1)
+   Tab_To(Left_Margin);
+ }
+}
+
+/*      Find the column position of the leftmost non-blank character on the 
+        line and set the automatic margin to this column.
+*/
+int Fast Find_Margin()
+{register int This_Col;
+ register char This_C;
+ long B_End, This_Pos;
+ B_End=Current->Bufsize+1;
+ This_Col=1;
+ B_Goto(Current,My_Pos);
+ if (B_B_Search(Current,'\n',(long)1))
+  B_Get(Current);
+ This_Pos=Current->Pos;
+ while (This_Pos!=B_End&&((This_C=B_Get(Current))==' '||This_C==9))
+ {This_Col=This_C==' '?This_Col+1:((This_Col-1)/8+1)*8+1;
+  This_Pos++;
+ }
+#if ! (defined(UNIX) | defined(MPE))
+ if (This_C=='\n'||This_C=='\r')
+#else
+ if (This_C=='\n')
+#endif
+ {if (Word_Wrap!=1)
+  {Word_Wrap=1;
+  if (Show_Ruler)
+    S_Ruler();
+  }
+ } else
+ if (Word_Wrap!=This_Col)
+ {Word_Wrap=This_Col;
+  if (Show_Ruler)
+   S_Ruler();
+ }
+ B_Goto(Current,My_Pos);
+ return Word_Wrap!=0;
+}
+
+/*      Delete an entity from the buffer.
+*/
+void Fast Del_It()
+{register int Index;
+ if (!Get_Entity()||Skip)
+  return;
+ Index=Get_E_Type();
+ if (Blk_Mode&&(E_Type==E_Paste||E_Type==E_NPaste))
+  Blk_Rem_It(Index); else
+  Rem_It(Index);
+ Set_Changes();
+}
+
+/*      Copy an entity into a delete buffer.
+*/
+void Fast Get()
+{register int Index;
+ if (!Get_Entity()||Skip)
+  return;
+ Index=Get_E_Type();
+ if (E_Type==E_Paste)
+  Clear_Region();
+ if (Blk_Mode&&(E_Type==E_Paste||E_Type==E_NPaste))
+  Blk_Rem_It(Index); else
+  Rem_It(Index);
+}
+
+/*      Return the appropriate delete buffer for an entity.
+*/
+int Fast Get_E_Type()
+{switch (E_Type)
+ {case E_Char:
+   return(Char_String);
+  case E_Word:
+   return(Word_String);
+  case E_Line:
+   return(Line_String);
+  case E_Paste:
+  case E_NPaste:
+   return(Past_String);
+  case E_Par:
+   return(Paragraph_String);
+  case E_Pag:
+   return(Page_String);
+  case E_Sen:
+   return(Sen_String);
+  default:
+   return(Unknown_String);
+ }
+}
+
+/*      Set default direction forward
+*/
+void Fast Advance()
+{Com_Direction=Def_Direction=1;
+ Hdr_Changes=1;
+}
+
+/*      Set default direction backward
+*/
+void Fast Backup()
+{Com_Direction=Def_Direction=0;
+ Hdr_Changes=1;
+}
+
+/*      Sets the Select point to the current cursor position
+*/
+void Fast Select()
+{long *P;
+ if ((P=Points)[0]!=0)
+ {Init_Entity();
+  E_Type=E_Paste;
+  Sel_Range();
+  Clear_Region();
+ }
+ P[0]=My_Pos;
+}
+
+/*      Inserts the contents of the paste buffer at the current cursor 
+        position.
+*/
+void Fast Paste()
+{
+#if (defined(DOS) | defined(NT)) & defined(Windows)
+ Win_Load_Clip();
+#endif
+ while (Count--&&!Check_CC())
+  Undelete(Past_String);
+}
+
+/*      Inserts the contents of the character delete buffer at the current 
+        cursor position.
+*/
+void Fast Und_Char()
+{while (Count--&&!Check_CC())
+  Undelete(Char_String);
+}
+
+/*      Inserts the contents of the word delete buffer at the current 
+        cursor position.
+*/
+void Fast Und_Word()
+{while (Count--&&!Check_CC())
+  Undelete(Word_String);
+}
+
+/*      Inserts the contents of the line delete buffer at the current 
+        cursor position.
+*/
+void Fast Und_Line()
+{while (Count--&&!Check_CC())
+  Undelete(Line_String);
+}
+
+/*      Inserts the contents of the paragraph delete buffer at the current 
+        cursor position.
+*/
+void Fast Und_Par()
+{while (Count--&&!Check_CC())
+  Undelete(Paragraph_String);
+}
+
+/*      Inserts the contents of the page delete buffer at the current 
+        cursor position.
+*/
+void Fast Und_Pg()
+{while (Count--&&!Check_CC())
+  Undelete(Page_String);
+}
+
+/*      Inserts the contents of the unknown type delete buffer at the current 
+        cursor position.
+*/
+void Fast Und_Unknown()
+{while (Count--&&!Check_CC())
+  Undelete(Unknown_String);
+}
+
+/*      Inserts the contents of the sentence delete buffer at the current 
+        cursor position.
+*/
+void Fast Und_Sen()
+{while (Count--&&!Check_CC())
+  Undelete(Sen_String);
+}
+
+/*      Switch to a different window.
+*/
+void Fast Window()
+{if (Count>=Maxbuffers)
+  Error(2,Illegal_Window_Txt); else
+  Ch_Window((int)Count);
+}
+
+/*      Insert the Ascii character value Count at the current cursor position.
+*/
+void Fast Ascii()
+{if (Count>255)
+ {Error(2,Illegal_ASCII_Txt);
+  return;
+ }
+ Ins_Char((int)Count);
+ Set_Changes();
+}
+
+/*      Get the delimited command argument into the array Com_Arg.
+*/
+int Fast Get_Arg()
+{register char C;
+ char Delim;
+ register int I;
+ if (Com.Pos>Com.Bufsize)
+ {Delim_Error();
+  return(0);
+ }
+ I=0;
+ Delim=B_Get(&Com);
+ while (1)
+ {if (Com.Pos>Com.Bufsize)
+  {Delim_Error();
+   return 0;
+  }
+  if ((C=B_Get(&Com))==Delim)
+   break;
+  Com_Arg[I++]=C;
+  if (I>=1024)
+  {Error(2,Too_Long_Arg_Txt);
+   return(0);
+  }
+ }
+ Com_Arg[I]=0;
+ Arg_Length=I;
+ return(1);
+}
+
+/*      Insert the contents of a file at the current cursor position.
+*/
+void Fast File_Get()
+{int Was_Empty;
+ if (!Get_Arg()||Skip)
+  return;
+ Was_Empty=Current->Bufsize==0&&Outfile==NULL;
+ B_Goto(Current,My_Pos);
+ Include_File(Com_Arg,File_Not_Found_Txt);
+ Fill_Screen(0,Rel_Last);
+ if (!Err_Flag&&!Was_Empty)
+  Set_Changes();
+}
+
+/*      Zero the current buffer. If unsaved changes have been made ask for
+        confirmation.
+*/
+void Fast Zero()
+{long *P;
+ if ((Any_Changes[Cur_Buffer]&1)&&!Read_Only[Cur_Buffer])
+  if (!Yes_No(Unsaved_Chng_Sure_Txt))
+   return;
+#if defined(UNIX) | defined(DOS)
+ if (Reservation&&File_Reserved[Cur_Buffer])
+ {if (chmod(Outfile,File_Protection[Cur_Buffer])!=0)
+	Plain_Message(No_Reset_Txt); else
+	Plain_Message(Reset_Txt);
+  File_Reserved[Cur_Buffer]=0;
+ }
+#endif
+ B_Reset(Current);
+ This_Line=My_Col=My_Pos=1;
+ Pos_Cursor();
+ P=Points;
+ {register int I;
+  for (I=0;I<=Maxpoints+2;I++)
+   P[I]=0;
+ }
+ P[Maxpoints+3]=P[Maxpoints+4]=1;
+ Buf_Lines=0;
+ Read_Only[Cur_Buffer]=Count==0;
+#if defined(UNIX)
+ File_Protection[Cur_Buffer]= -1;
+#endif
+ Cur_Attributes=0;
+ Clr_Changes();
+ Infile=Outfile=NULL;
+ Auto_Saved=0;
+ Fill_Screen(Rel_First,Rel_Last);
+ S_Header();
+#if (defined(ATARI) & defined(GEM)) | ((defined(DOS) | defined(NT)) & (defined(Windows) | defined(TV)))
+#if defined(ATARI) & defined(GEM)
+ GEM_Name(top_window,NULL);
+#endif
+#if (defined(DOS) | defined(NT)) & defined(Windows)
+ Win_Name(NULL);
+#endif
+#if defined(DOS) & defined(TV)
+ TV_Name(NULL);
+#endif
+ W_D_Border();
+#endif
+ if (Auto_Saved)
+  Rem_Autosave();
+}
+
+/*      Mark the current cursor position in mark number Count.
+*/
+void Fast Mark_Pos()
+{if (Count<1||Count>Maxpoints)
+ {Error(2,Illegal_Mark_Txt);
+  return;
+ }
+ if (Points[Count]!=0)
+ {Points[Count]=End_Points[Count]=(Cur_Direction=='-')?0L:My_Pos;
+  Fill_Screen(Rel_First,Rel_Last);
+ } else
+ {Points[Count]=End_Points[Count]=(Cur_Direction=='-')?0L:My_Pos;
+  Fill_Rest();
+ }
+}
+
+/*      Mark the current cursor position as the end of mark number Count.
+*/
+void Fast End_Mark()
+{if (Count<1||Count>Maxpoints)
+ {Error(2,Illegal_Mark_Txt);
+  return;
+ }
+ End_Points[Count]=(Cur_Direction=='-')?Points[Count]:My_Pos;
+ Fill_Screen(Rel_First,0);
+}
+
+/*      Get the arguments to the Subs command and then substritute
+        the next occurrence of the search string with the replace string.
+*/
+void Fast Subs()
+{Get_Arg();
+ if (!Skip)
+ {if (Com_Arg[0]!=0)
+   Ins_Del(Dl_Pointers[Search_String]);
+ }
+ B_Goto(&Com,Com.Pos-1);
+ if (!Get_Arg()||Skip)
+  return;
+ if (Com_Arg[0]!=0)
+  Ins_Del(Dl_Pointers[Subs_String]);
+ Subs_Next();
+}
+
+/*      Get the arguments to the Subs command and then substritute
+        the next occurrence of the search string with the replace string.
+*/
+void Fast Subs_Conf()
+{Get_Arg();
+ if (!Skip)
+ {if (Com_Arg[0]!=0)
+   Ins_Del(Dl_Pointers[Search_String]);
+ }
+ B_Goto(&Com,Com.Pos-1);
+ if (!Get_Arg()||Skip)
+  return;
+ if (Com_Arg[0]!=0)
+  Ins_Del(Dl_Pointers[Subs_String]);
+ Subs_Next_Conf();
+}
+
+/*      Insert the contents of the command argument into the Del buffer and make
+	the del pointer W point to it.
+*/
+void Fast Ins_Del(long *W)
+{Erase_Del(W);
+ B_Put_S(&Del,Com_Arg,Arg_Length);
+ W[1]=Arg_Length;
+}
+
+/*      Search in the current direction for the search string and replace it
+        with the replace string.
+*/
+void Fast Subs_Next()
+{int First;
+ register long Lines, Chars;
+ long *P;
+ First=1;
+ while (!Err_Flag&&Count--&&!Check_CC())
+ {Init_Entity();
+  Ent_Direction=Direction;
+  if (First)
+  {Find_This(Direction);
+   First=0;
+  } else
+   Find_This(0);
+  if (!Err_Flag)
+  {Move_Entity();
+   Init_Entity();
+   if (Reg_Search)
+    Ent_Count=Exp->endp[0]-Exp->startp[0]; else
+    Ent_Count=Dl_Pointers[Search_String][1];
+   A_Char();
+   Erase_Del(P=Dl_Pointers[Unknown_String]);
+   Chars=End_Pos-Beg_Pos;
+   Lines=End_Line-Beg_Line;
+   B_Goto(Current,Beg_Pos);
+   B_Copy(Current,&Del,Chars);
+   B_Goto(Current,Beg_Pos);
+   B_Rem(Current,Chars);
+   Adj_Points(-(P[1]=Chars),Beg_Pos);
+   if (Lines>0)
+   {Adj_Lines(-Lines);
+    if (Lines<Rel_Last&&(Max_Scroll?Max_Scroll>=Lines:1))
+    {Opt_Scroll((int)Lines,My_Col==1?0:1,Rel_Last);
+     Fill_Screen((int)(Rel_Last-Lines+1),Rel_Last);
+    } else
+     Fill_Screen(1,Rel_Last);
+   }
+   B_Goto(Current,My_Pos);
+   if ((P=Dl_Pointers[Subs_String])[0]==0)
+    Fill_Rest(); else
+   {B_Goto(&Del,P[0]);
+    if ((Chars=P[1])==0)
+     Fill_Rest(); else
+    {if (Reg_Search)
+     {B_Get_N(&Del,Rep_Str,(int)Chars);
+      Rep_Str[Chars]=0;
+      regsub(Exp,Rep_Str,Com_Arg);
+      Chars=strlen(Com_Arg);
+      B_Put_S(Current,Com_Arg,(int)Chars);
+     } else
+     {Adj_Points(Chars,My_Pos);
+      B_Copy(&Del,Current,Chars);
+     }
+     B_Goto(Current,My_Pos);
+     End_Pos=Beg_Pos+Chars;
+     Lines=0;
+     while (B_Search(Current,'\n',My_Pos+Chars))
+      Lines++;
+     B_Goto(Current,My_Pos);
+     if (Lines)
+     {Adj_Lines(Lines);
+      if (Lines<Rel_Last&&(Max_Scroll?Max_Scroll>=Lines:1))
+      {Opt_Scroll((int) (-Lines),0,Rel_Last);
+       Fill_Screen(0,(int)Lines);
+      } else
+       Fill_Screen(0,Rel_Last);
+     } else
+      Fill_Rest();
+     if (Direction)
+     {Init_Entity();
+      Ent_Count=Chars;
+      A_Char();
+      Move_Entity();
+     }
+    }
+   }
+  }
+ }
+ Set_Changes();
+}
+
+/*      Search in the current direction for the search string and replace it
+        with the replace string. Confirm every substitution
+*/
+void Fast Subs_Next_Conf()
+{int First;
+ register long Lines, Chars;
+ long *P;
+ First=1;
+ while (!Err_Flag&&Count--&&!Check_CC())
+ {Init_Entity();
+  Ent_Direction=Direction;
+  if (First)
+  {Find_This(Direction);
+   First=0;
+  } else
+   Find_This(0);
+  if (!Err_Flag)
+  {Move_Entity();
+   if (Yes_No(Replace_This_Txt))
+   {Init_Entity();
+    if (Reg_Search)
+     Ent_Count=Exp->endp[0]-Exp->startp[0]; else
+     Ent_Count=Dl_Pointers[Search_String][1];
+    A_Char();
+    Erase_Del(P=Dl_Pointers[Unknown_String]);
+    Chars=End_Pos-Beg_Pos;
+    Lines=End_Line-Beg_Line;
+    B_Goto(Current,Beg_Pos);
+    B_Copy(Current,&Del,Chars);
+    B_Goto(Current,Beg_Pos);
+    B_Rem(Current,Chars);
+    Adj_Points(-(P[1]=Chars),Beg_Pos);
+    if (Lines>0)
+    {Adj_Lines(-Lines);
+     if (Lines<Rel_Last&&(Max_Scroll?Max_Scroll>=Lines:1))
+     {Opt_Scroll((int)Lines,My_Col==1?0:1,Rel_Last);
+      Fill_Screen((int)(Rel_Last-Lines+1),Rel_Last);
+     } else
+      Fill_Screen(1,Rel_Last);
+    }
+    B_Goto(Current,My_Pos);
+    if ((P=Dl_Pointers[Subs_String])[0]==0)
+     Fill_Rest(); else
+    {B_Goto(&Del,P[0]);
+     if ((Chars=P[1])==0)
+      Fill_Rest(); else
+     {if (Reg_Search)
+      {B_Get_N(&Del,Rep_Str,(int)Chars);
+       Rep_Str[Chars]=0;
+       regsub(Exp,Rep_Str,Com_Arg);
+       Chars=strlen(Com_Arg);
+       B_Put_S(Current,Com_Arg,(int)Chars);
+      } else
+      {Adj_Points(Chars,My_Pos);
+       B_Copy(&Del,Current,Chars);
+      }
+      B_Goto(Current,My_Pos);
+      End_Pos=Beg_Pos+Chars;
+      Lines=0;
+      while (B_Search(Current,'\n',My_Pos+Chars))
+       Lines++;
+      B_Goto(Current,My_Pos);
+      if (Lines)
+      {Adj_Lines(Lines);
+       if (Lines<Rel_Last&&(Max_Scroll?Max_Scroll>=Lines:1))
+       {Opt_Scroll((int) (-Lines),0,Rel_Last);
+        Fill_Screen(0,(int)Lines);
+       } else
+        Fill_Screen(0,Rel_Last);
+      } else
+       Fill_Rest();
+      if (Direction)
+      {Init_Entity();
+       Ent_Count=Chars;
+       A_Char();
+       Move_Entity();
+      }
+     }
+    }
+   }
+  }
+ }
+ Set_Changes();
+}
+
+/*      Insert the representation of character C at the current cursor
+        position.
+*/
+void Fast Put_Rep(int C)
+{char S[Maxcol+1]; 
+ int Sav_Attributes;
+#ifdef VKS
+/*
+ * DIRTY PATCH: if characters come in negative ring a bell on ASCII 7
+ *              else ignore the bell character (as was before)
+ *
+ * APOLOGY: sorry for introducing hacker methods into your programming,
+ *          but it was a way of leaving most of you calls to Put_Rep 
+ *          unchanged.
+ */
+ int do_bell = 0;
+
+ if(C < 0)
+ {
+   do_bell = 1;
+   C = -C;
+ }
+ if ((C>=' '&&C<='~')||(C>160&&C<255)||(do_bell&&C==7))
+#else
+ if ((C>=' '&&C<='~')||(C>160&&C<255))
+#endif
+  Opt_Char((char)C); else
+ if (C>=' '||(C==9&&Expand_Tabs)||!Control_Display)
+ {Char_Rep(C,S);
+  Opt_String(S);
+ } else
+ {if ((Sav_Attributes=Cur_Attributes)&A_Reverse)
+  {Cur_Attributes&=!A_Reverse;
+   Cur_Attributes|=A_Bold;
+  } else
+   Cur_Attributes|=A_Reverse|A_Bold;
+  Opt_Char((char)(C+64));
+  Cur_Attributes=Sav_Attributes;
+ } 
+}
+
+/*      Insert the contents of the command argument at the current cursor 
+        position.
+*/
+void Fast Insert()
+{register long Lines, L;
+ register char *S;
+ B_Goto(Current,My_Pos);
+ if (!Get_Arg()||Skip)
+  return;
+ if (!Replace_Mode)
+ {L=Arg_Length;
+  B_Put_S(Current,Com_Arg,Arg_Length);
+  Adj_Points(L,My_Pos);
+  Init_Entity();
+  Ent_Count=L;
+  A_Char();
+  if ((Lines=End_Line-This_Line)!=0)
+  {Adj_Lines(Lines);
+   if (Lines<Rel_Last&&(Max_Scroll?Max_Scroll>=Lines:1))
+   {Opt_Scroll((int)-Lines,0,Rel_Last);
+    Fill_Screen(0,(int)Lines);
+   } else
+    Fill_Screen(0,Rel_Last);
+  } else
+   Fill_Rest();
+  Move_Entity();
+ } else
+ {L=strlen(S=Com_Arg);
+  while (L--)
+   Ins_Char(*(S++));
+ }
+ Set_Changes();
+}
+
+/*      Edit the file given in the command argument in the current buffer.
+*/
+void Fast File_Edit()
+{if (!Get_Arg()||Skip)
+  return;
+ Edit_File(Com_Arg);
+}
+
+void Fast Edit_File(char *S)
+{long *P;
+#if defined(UNIX) | defined(DOS)
+ struct stat File_Stat;
+#endif
+ if ((Any_Changes[Cur_Buffer]&1)&&!Read_Only[Cur_Buffer])
+ {if (Outfile==NULL)
+  {if (!Yes_No(Forget_Buffer_Txt))
+    return;
+  } else
+  if (Yes_No(Save_Changes_Txt))
+   Wr_Buffer(Outfile);
+ }
+ if (Err_Flag)
+  return;
+#if defined(UNIX) | defined(DOS)
+ if (Reservation&&File_Reserved[Cur_Buffer])
+ {if (chmod(Outfile,File_Protection[Cur_Buffer])!=0)
+	Plain_Message(No_Reset_Txt); else
+	Plain_Message(Reset_Txt);
+  File_Reserved[Cur_Buffer]=0;
+ }
+#endif
+ if (Auto_Saved)
+  Rem_Autosave();
+ Read_Only[Cur_Buffer]=Count==0;
+#if defined (UNIX)
+ File_Protection[Cur_Buffer]= -1;
+ if (stat(S,&File_Stat)!=0)
+ {Plain_Message(No_Stat_Txt);
+  File_Reserved[Cur_Buffer]=0;
+  File_Protection[Cur_Buffer]= -1;
+ } else
+ {File_Protection[Cur_Buffer]=File_Stat.st_mode;
+  if (Reservation&!Read_Only[Cur_Buffer])
+  {File_Reserved[Cur_Buffer]=0;
+	if ((File_Stat.st_mode&(S_IWUSR+S_IWGRP+S_IWOTH))==0)
+	{if (Yes_No(File_Reserved_Txt)==1)
+	 {Read_Only[Cur_Buffer]=1;
+	 } else
+	 {return;
+	 }
+	}
+	{if (File_Stat.st_uid==My_UID)
+	 {if (chmod(S,File_Stat.st_mode&~(S_IWUSR+S_IWGRP+S_IWOTH))!=0)
+	  {Plain_Message(No_Protection_Change_Txt);
+		Read_Only[Cur_Buffer]=1;
+	  } else
+	  {Plain_Message(Reserved_Txt);
+		File_Reserved[Cur_Buffer]=1;
+		File_Protection[Cur_Buffer]=File_Stat.st_mode;
+	  }
+	 } else
+	 if (File_Stat.st_gid==My_GID)
+	 {Plain_Message(Group_Txt);
+	  Read_Only[Cur_Buffer]=1;
+	 } else
+	 {Plain_Message(Other_Txt);
+	  Read_Only[Cur_Buffer]=1;
+	 }
+	}
+  }
+ }
+#endif
+#if defined (DOS)
+ File_Protection[Cur_Buffer]= -1;
+ if (stat(S,&File_Stat)!=0)
+ {Plain_Message(No_Stat_Txt);
+  File_Reserved[Cur_Buffer]=0;
+  File_Protection[Cur_Buffer]= -1;
+ } else
+ {File_Protection[Cur_Buffer]=File_Stat.st_mode;
+  if (Reservation&!Read_Only[Cur_Buffer])
+  {File_Reserved[Cur_Buffer]=0;
+	if ((File_Stat.st_mode&(S_IWRITE))==0)
+	{if (Yes_No(File_Reserved_Txt)==1)
+	 {Read_Only[Cur_Buffer]=1;
+	 } else
+	 {return;
+	 }
+	}
+	{if (chmod(S,File_Stat.st_mode&~(S_IWRITE))!=0)
+	 {Plain_Message(No_Protection_Change_Txt);
+	  Read_Only[Cur_Buffer]=1;
+	 } else
+	 {Plain_Message(Reserved_Txt);
+	  File_Reserved[Cur_Buffer]=1;
+	  File_Protection[Cur_Buffer]=File_Stat.st_mode;
+	 }
+	}
+  }
+ }
+#endif
+ {register int I;
+  I=0;
+  New_File[I]=S[I];
+  while (New_File[I])
+  {I++;
+   New_File[I]=S[I];
+  }
+ }
+ B_Reset(Current);
+ This_Line=My_Col=My_Pos=1;
+ Pos_Cursor();
+ P=Points;
+ {register int I;
+  for (I=0;I<=Maxpoints+2;I++)
+   P[I]=0;
+ }
+ P[Maxpoints+3]=P[Maxpoints+4]=1;
+ Buf_Lines=0;
+ Cur_Attributes=0;
+ Clr_Changes();
+ Read_File(Outfile=Infile=New_File);
+#if defined(ATARI) & defined(GEM)
+ GEM_Name(top_window,Outfile);
+#endif
+#if (defined(DOS) | defined(NT)) & defined(Windows)
+ Win_Name(Outfile);
+#endif
+#if defined(DOS) & defined(TV)
+ TV_Name(Outfile);
+#endif
+ W_D_Border();
+ Fill_Screen(Rel_First,Rel_Last);
+ S_Header();
+ if (!Err_Flag&&Save_Context)
+  Read_Context();
+}
+
+void Fast C_Read_L(struct File *F,long *D)
+{if (F_gets(Dsk_Rec,Blksize,F)==NULL)
+  return;
+ *D=atol(Dsk_Rec);
+}
+
+void Fast C_Read_I(struct File *F,int *D)
+{if (F_gets(Dsk_Rec,Blksize,F)==NULL)
+  return;
+ *D=atol(Dsk_Rec);
+}
+
+void Fast Read_Context()
+{struct File F;
+ long Save_Pos;
+ Filnam(Infile,Dsk_Rec);
+#if defined(UNIX)
+ strcat(Dsk_Rec,".ctx");
+#else
+ strcat(Dsk_Rec,".CTX");
+#endif
+ if (F_open(Dsk_Rec,"r",&F)==NULL)
+ {if (Save_Context==1)
+  Plain_Message(No_Context_Txt);
+ } else
+ {if (Err_Flag)
+   return;
+  if (F_gets(Dsk_Rec,132,&F)==NULL)
+  {Plain_Message(Read_Context_Txt);
+   F_close(&F);
+   return;
+  }
+  Filjnam(Infile,Com_Arg);
+  if (strcmp(Dsk_Rec,Com_Arg)!=0)
+  {Plain_Message(Context_Match_Txt);
+   F_close(&F);
+   return;
+  }
+  C_Read_L(&F,&Save_Pos);
+  {register int I;
+   for (I=0;I<=Maxpoints;I++)
+   {C_Read_L(&F,&Points[I]);
+    C_Read_L(&F,&End_Points[I]);
+   }
+  }
+  C_Read_L(&F,&Indent);
+  C_Read_L(&F,&Word_Wrap);
+  C_Read_L(&F,&Left_Margin);
+  C_Read_L(&F,&Right_Margin);
+  C_Read_I(&F,&Justify);
+  C_Read_I(&F,&Auto_Margin);
+  {register int I;
+   for (I=0;I<512;I++)
+    C_Read_I(&F,&Tabs[I]);
+  }
+  F_close(&F);
+  if (Save_Pos>0&&Save_Pos<=Current->Bufsize+1)
+  {Init_Entity();
+   Ent_Count=Save_Pos-1;
+   A_Char();
+   Move_Entity();
+  } else
+   Plain_Message(Bad_Context_Cursor_Txt);
+  Points[0]=0;
+ }
+}
+
+/*      Save the contents of the current buffer in the file given in the
+        command argument. If the command argument is empty the file is saved
+        in the output file of the buffer.
+*/
+void Fast File_Save()
+{char *P;
+ if (!Get_Arg()||Skip)
+  return;
+ if (Read_Only[Cur_Buffer]&&!Yes_No(Txt_Read_Only))
+  return;
+ if (Err_Flag)
+  return;
+ if (Com_Arg[0]==0)
+ {if ((P=Outfile)==NULL||P[0]==0)
+   Error(2,No_Output_File_Txt); else
+  {Wr_Buffer(P);
+  }
+ } else
+ {if (Auto_Saved)
+   Rem_Autosave();
+  strcpy(New_File,Com_Arg);
+  Wr_Buffer(Outfile=New_File);
+#if defined(ATARI) & defined(GEM)
+  GEM_Name(top_window,Outfile);
+#endif
+#if (defined(DOS) | defined(NT)) & defined(Windows)
+  Win_Name(Outfile);
+#endif
+#if defined(DOS) & defined(TV)
+  TV_Name(Outfile);
+#endif
+  W_D_Border();
+  S_Header();
+ }
+ if (!Err_Flag)
+  Clr_Changes();
+}
+
+/*      Write the contents of the current buffer to the file given in the
+        command argument. 
+*/
+void Fast File_Write()
+{if (!Get_Arg()||Skip)
+  return;
+ if (Com_Arg[0]==0)
+  Error(2,No_Output_File_Txt); else
+ {Wr_Buffer(Com_Arg);
+ }
+}
+
+/*      Check whether we have reached the end of the command buffer.
+*/
+int Fast End_Com()
+{return(Com.Pos>Com.Bufsize);
+}
+
+/*      Define the contents of the key given in the first command argument as
+        the string given as the second command argument.
+*/
+void Fast Def_Key_Function()
+{long Sav_Pos, St_Pos;
+ int Length;
+ Gold=Function=0;
+ Get_Key();
+ if (End_Com())
+ {Com_Error();
+  return;
+ }
+ St_Pos=Com.Pos+1;
+ if (!Get_Arg()||Skip)
+  return;
+ if ((Function=Map_Tab[Map_Index].F_Code)<=0||Function<=Top_Func)
+ {if (Next_Func==Maxfunc-1)
+  {Error(2,Max_Func_Txt);
+   return;
+  } else
+   Map_Tab[Map_Index].F_Code=Function= ++Next_Func;
+ }
+ Length=Arg_Length;
+ Sav_Pos=Com.Pos;
+ Move_Key(Key_Addr(Function),St_Pos,(long)Length);
+ B_Goto(&Com,Sav_Pos);
+}
+
+void Fast Def_Key_Alpha()
+{Gold=0;
+ Key_Number= -1;
+ Def_Key();
+}
+
+void Fast Def_Key_Key()
+{Gold=0;
+ Key_Number=0;
+ Def_Key();
+}
+
+void Fast Def_Key_G_Alpha()
+{Gold=1;
+ Key_Number= -1;
+ Def_Key();
+}
+
+void Fast Def_Key_G_Key()
+{Gold=1;
+ Key_Number=0;
+ Def_Key();
+}
+
+void Fast Def_Key()
+{long Sav_Pos, St_Pos;
+ int Length;
+ int C;
+ Function=Character=0;
+ {register int I;
+  for (I=1;I<=3;I++)
+  {if (Com.Pos>Com.Bufsize)
+   {Syntax_Error();
+    return;
+   }
+   if ((C=B_Get(&Com))<'0'||C>'9')
+   {Syntax_Error();
+    return;
+   }
+   Character=Character*10+C-'0';
+  }
+ }
+ St_Pos=Com.Pos+1;
+ if (!Get_Arg()||Skip)
+  return;
+ {register int I;
+  for (I=0;I<=Map_Defs;I++)
+  {if (I==Map_Defs)
+   {Map_Defs++;
+    Map_Tab[I].Scancode=0;
+    Map_Tab[I].Char=Character;
+    Map_Tab[I].Flags=0;
+    if (Gold)
+     Map_Tab[I].Flags|=Gold_Code;
+    if (Key_Number>=0)
+     Map_Tab[I].Flags|=Key_Code; else
+     Map_Tab[I].Flags|=Char_Code;
+    Map_Tab[I].F_Code= -1;
+    Map_Tab[I].Index=0;
+    break;
+   } else
+   {if (Map_Tab[I].Flags&Gold_Code?Gold:!Gold)
+    {if ((Key_Number==0&&(Map_Tab[I].Flags&Key_Code)&&
+       Map_Tab[I].Char==Character)||
+      (Key_Number==-1&&(Map_Tab[I].Flags&Char_Code)&&
+       Map_Tab[I].Char==Character))
+      break;
+    }
+   }
+  }
+  if ((Function=Map_Tab[I].F_Code)<=0||Function<=Top_Func)
+  {if (Next_Func==Maxfunc-1)
+   {Error(2,Max_Func_Txt);
+    return;
+   } else
+    Map_Tab[I].F_Code=Function= ++Next_Func;
+  }
+ }
+ Length=Arg_Length;
+ Sav_Pos=Com.Pos;
+ Move_Key(Key_Addr(Function),St_Pos,(long)Length);
+ B_Goto(&Com,Sav_Pos);
+}
+
+/*      Define the contents of the key given in the first command argument as
+        the string given as the second command argument.
+*/
+void Fast Def_Key_Number()
+{Gold=Function=0;
+ Get_Key();
+ if (Err_Flag||Skip)
+  return;
+ Map_Tab[Map_Index].F_Code=Count;
+}
+
+void Fast Def_Function()
+{long St_Pos, Sav_Pos, Length;
+ St_Pos=Com.Pos+1;
+ if (!Get_Arg()||Skip)
+  return;
+ Sav_Pos=Com.Pos;
+ Length=Arg_Length;
+ Move_Key(Key_Addr(Function=Count),St_Pos,(long)Length);
+ if (Function>Top_Func)
+  Top_Func=Function;
+ B_Goto(&Com,Sav_Pos);
+}
+
+/*      Reset the select point.
+*/
+void Fast Reset()
+{Init_Entity();
+ E_Type=E_Paste;
+ Sel_Range();
+ Clear_Region();
+}
+
+/*      Attempt to undo the effect of the last command executed.
+*/
+void Fast Undo()
+{if (Lst_Cmd==C_Movecursor)
+ {Init_Entity();
+  if (Lst_Char_Move>0)
+  {Ent_Direction=0;
+   Beg_Pos-=Lst_Char_Move;
+   Beg_Line-=Lst_Line_Move;
+  } else
+  {End_Pos-=Lst_Char_Move;
+   End_Line-=Lst_Line_Move;
+  }
+  Lst_Char_Move=(-Lst_Char_Move);
+  Lst_Line_Move=(-Lst_Line_Move);
+  Lst_Cmd=This_Cmd;
+  This_Cmd=C_Movecursor;
+  Move_Entity();
+ } else
+ if (Lst_Cmd==C_Subs)
+ {if (My_Pos!=Beg_Pos)
+  {Ent_Direction=0;
+   Move_Entity();
+  }
+  End_Pos=My_Pos+Dl_Pointers[Subs_String][1];
+  Beg_Line=This_Line;
+  Rem_It(-1);
+  Undelete(Unknown_String);
+ } else
+ if (Lst_Cmd==C_Delete)
+ {switch (E_Type)
+  {case E_Char:
+    {Und_Char();
+     break;
+    }
+   case E_Word:
+    {Und_Word();
+     break;
+    }
+   case E_Line:
+    {Und_Line();
+     break;
+    }
+   case E_Paste:
+   case E_NPaste:
+    {Paste();
+     break;
+    }
+   case E_Par:
+    {Und_Par();
+     break;
+    }
+   case E_Pag:
+    {Und_Pg();
+     break;
+    }
+   case E_Sen:
+    {Und_Sen();
+     break;
+    }
+   default:
+    Und_Unknown();
+  }
+ } else
+ {Error(2,Cannot_Undo_Txt);
+  return;
+ }
+}
+
+/*      Determine whether there are any characters waiting in the typeahead 
+        buffer.
+*/
+int Fast Input_Test()
+{
+#if defined(VMS)
+ return T$Typeahead()!=0;
+#endif
+#if defined(DOS) | defined(NT)
+#if !defined(Windows)
+#if defined(PC100)
+ return (bdos(11,0)&0x00FF)!=0;
+#else
+ if (Firmware&1)
+  return ANYEXT(); else
+  return ANYCHR();
+#endif
+#endif
+#endif
+#if defined(OS2)
+ struct _KBDKEYINFO Key_Data;
+ KbdPeek((PKBDKEYINFO)&Key_Data,0);
+ return Key_Data.fbStatus!=0;
+#endif
+#if defined(ATARI) & !defined(GEM)
+ return Cconis()||Key_Count;
+#endif
+#if ((defined(DOS) | defined(NT)) & defined(Windows)) | (defined(ATARI) & defined(GEM)) | defined(UNIX)
+ return 1;
+#endif
+}
+
+void Fast Test_Input()
+{Err_Flag=Input_Test();
+}
+
+/*      Move to the next tab position on the ruler.
+*/
+void Fast Tab()
+{register long New_Col;
+ while (Count--&&!Check_CC())
+ {if (Indent>My_Col)
+   New_Col=Indent; else
+  {New_Col=My_Col;
+   while (1)
+    if ((++New_Col)>512)
+    {if (New_Col%8==1)
+      break;
+    } else
+    if (Tabs[New_Col])
+     break;
+    if (Word_Wrap>My_Col&&Word_Wrap<New_Col)
+     New_Col=Word_Wrap;
+  }
+  Tab_To(New_Col);
+ }
+ Set_Changes();
+}
+
+/*      Toggle between insert and replace mode.
+*/
+void Fast Overstrike_Mode()
+{Replace_Mode=(Replace_Mode?0:1);
+ Hdr_Changes=1;
+}
+
+/*      Toggle between insertion and expansion of tab characters.
+*/
+void Fast Tab_Toggle()
+{Tab_Expand=(Tab_Expand?0:1);
+ Hdr_Changes=1;
+}
+
+/*      Display the current column on the bottom line of the display.
+*/
+void Fast Show_Column()
+{char Display[15];
+ sprintf(Display,(char *)Show_Column_Txt,My_Col);
+ Plain_Message(Display);
+}
+
+/*      Load the ruler from the saved ruler given in Count.
+*/
+void Fast Get_Ruler()
+{if (Count>9)
+ {Error(2,Illegal_Ruler_Txt);
+  return;
+ }
+ Readruler((char)(Count+'0'));
+ if (Show_Ruler)
+  S_Ruler();
+}
+
+/*      Toggle between automatic screen shifting and no screen shifting.
+*/
+void Fast Shift_Toggle()
+{Do_Shift=(Do_Shift?0:1);
+ Hdr_Changes=1;
+}
+
+void Fast Case_Toggle()
+{Case_Sensitive=(Case_Sensitive?0:1);
+ Hdr_Changes=1;
+}
+
+void Fast Ins_Defs_Toggle()
+{Ins_Defs=Ins_Defs?0:1;
+ Hdr_Changes=1;
+}
+
+void Fast Cursor_Free_Toggle()
+{Cursor_Free=Cursor_Free?0:1;
+ Hdr_Changes=1;
+}
+
+void Fast Change_Window()
+{
+  Other_Window();
+}
+
+/*      Set the error level that will ring the terminal bell.
+*/
+void Fast Err_Level()
+{Bell_Level=Count;
+}
+
+void Fast Tog_Marks()
+{Show_Marks=Show_Marks?0:1;
+ Fill_Screen(Rel_First,Rel_Last);
+}
+
+void Fast Tog_Block()
+{register int Sel_Pos;
+ Blk_Mode=Blk_Mode?0:1;
+ Hdr_Changes=1;
+ if ((Sel_Pos=Points[0])!=0)
+ {if (Sel_Pos<My_Pos)
+   Fill_Screen(Rel_First,0); else
+   Fill_Screen(0,Rel_Last);
+ }
+}
+
+void Fast Tog_Control()
+{Control_Display=Control_Display?0:1;
+ Fill_Screen(Rel_First,Rel_Last);
+ if (My_Col!=1)
+ {Init_Entity();
+  Backto_This(My_Pos);
+ }
+}
+
+void Fast Tog_Direction()
+{Com_Direction=Def_Direction=Def_Direction?0:1;
+ Hdr_Changes=1;
+}
+
+void Fast Show_Version()
+{Plain_Message(Version);
+}
+
+void Fast Tog_Cursor()
+{Float_Cursor=Float_Cursor?0:1;
+ Pos_Cursor();
+ Fill_Screen(Rel_First,Rel_Last);
+}
+
+void Fast Tog_Reg_Search()
+{Reg_Search=Reg_Search?0:1;
+ Hdr_Changes=1;
+}
+
+void Fast Tog_Ruler()
+{Show_Ruler=Show_Ruler?0:1;
+ if (Show_Ruler)
+ {Rel_First++;
+  S_Ruler();
+ } else
+ {Rel_First--;
+  Fill_Screen(Rel_First,Rel_First);
+ }
+ Pos_Cursor();
+ Fill_Screen(Rel_First,Rel_Last);
+}
+
+void Fast Curs_Top()
+{register int I;
+ if (Float_Cursor)
+ {if (Rel_First<-1)
+  {I=Rel_First+1;
+   if (Max_Scroll?Max_Scroll>=-I:1)
+   {Opt_Scroll(-I,Rel_First,Rel_Last);
+    Home=My_Line+=I;
+    Rel_First-=I;
+    Rel_Last-=I;
+    Fill_Screen(Rel_Last+I-1,Rel_Last);
+   } else
+   {Home=My_Line+=I;
+    Rel_First-=I;
+    Rel_Last-=I;
+    Fill_Screen(Rel_First,Rel_Last);
+   }
+  }
+ }
+}
+
+void Fast Curs_Bottom()
+{register int I;
+ if (Float_Cursor)
+ {if (Rel_Last>1)
+  {I=Rel_Last-1;
+   if (I>This_Line+Rel_First-1)
+    I=This_Line+Rel_First-1;
+   if (I>0)
+   {if (Max_Scroll?Max_Scroll>=I:1)
+    {Opt_Scroll(-I,Rel_First,Rel_Last);
+     Home=My_Line+=I;
+     Rel_First-=I;
+     Rel_Last-=I;
+     Fill_Screen(Rel_First,Rel_First+I-1);
+    } else
+    {Home=My_Line+=I;
+     Rel_First-=I;
+     Rel_Last-=I;
+     Fill_Screen(Rel_First,Rel_Last);
+    }
+   }
+  }
+ }
+}
+
+void Fast Curs_Middle()
+{register int I;
+ if (Float_Cursor)
+ {I=(Rel_First+Rel_Last+1)/2;
+  if (I)
+  {if (I>This_Line+Rel_First-1)
+    I=This_Line+Rel_First-1;
+   if (I>0)
+   {if (Max_Scroll?Max_Scroll>=I:1)
+    {Opt_Scroll(-I,Rel_First,Rel_Last);
+     Home=My_Line+=I;
+     Rel_First-=I;
+     Rel_Last-=I;
+     Fill_Screen(Rel_First,Rel_First+I-1);
+    } else
+    {Home=My_Line+=I;
+     Rel_First-=I;
+     Rel_Last-=I;
+     Fill_Screen(Rel_First,Rel_Last);
+    }
+   } else
+   if (I<0)
+   {if (Max_Scroll?Max_Scroll>=-I:1)
+    {Opt_Scroll(-I,Rel_First,Rel_Last);
+     Home=My_Line+=I;
+     Rel_First-=I;
+     Rel_Last-=I;
+     Fill_Screen(Rel_Last+I-1,Rel_Last);
+    } else
+    {Home=My_Line+=I;
+     Rel_First-=I;
+     Rel_Last-=I;
+     Fill_Screen(Rel_First,Rel_Last);
+    }
+   }
+  }
+ }
+}
+
+void Fast Shift_In()
+{
+#if defined(VMS) | defined(UNIX)
+ Out_Zap();
+ putchar(15);
+ Shifted_Out=0;
+ Repaint();
+#endif
+#if defined(DOS) & !(defined(Windows) | defined(TV)) & defined(PC100)
+ Out_Zap();
+ putchar(15);
+ Shifted_Out=0;
+ Repaint();
+#endif
+}
+
+void Fast Shift_Out()
+{
+#if defined(VMS) | defined(UNIX)
+ Out_Zap();
+ putchar(14);
+ Shifted_Out=1;
+ Repaint();
+#endif
+#if defined(DOS) & !(defined(Windows) | defined(TV)) & defined(PC100)
+ Out_Zap();
+ putchar(14);
+ Shifted_Out=1;
+ Repaint();
+#endif
+}
+
+void Fast Font_Larger()
+{
+#if defined(ATARI) & defined(GEM)
+ GEM_Larger();
+#endif
+#if (defined(DOS) | defined(NT)) & defined(Windows)
+ Win_Larger();
+#endif
+}
+
+void Fast Font_Smaller()
+{
+#if defined(ATARI) & defined(GEM)
+ GEM_Smaller();
+#endif
+#if (defined(DOS) | defined(NT)) & defined(Windows)
+ Win_Smaller();
+#endif
+}
+
+void Fast Update_Off()
+{Update_Flag=0;
+}
+
+void Fast Update_On()
+{if (!Update_Flag)
+ {Update_Flag=1;
+#if !((defined(ATARI) & defined(GEM)) | ((defined(DOS) | defined(NT)) & (defined(Windows) | defined(TV))))
+  if (Zoomed)
+  {S_Header();
+   Fill_Screen(Rel_First,Rel_Last);
+   if (Show_Ruler)
+    S_Ruler();
+  } else
+   Refresh_Window();
+#else
+  S_Header();
+  Fill_Screen(Rel_First,Rel_Last);
+  if (Show_Ruler)
+   S_Ruler();
+#endif
+ }
+}
+
+void Fast Remove_Char()
+{Erase_Del(Dl_Pointers[Char_String]);
+}
+
+void Fast Remove_Help()
+{Erase_Del(Dl_Pointers[Help_String]);
+}
+
+void Fast Remove_Line()
+{Erase_Del(Dl_Pointers[Line_String]);
+}
+
+void Fast Remove_Page()
+{Erase_Del(Dl_Pointers[Page_String]);
+}
+
+void Fast Remove_Par()
+{Erase_Del(Dl_Pointers[Paragraph_String]);
+}
+
+void Fast Remove_Paste()
+{Erase_Del(Dl_Pointers[Past_String]);
+}
+
+void Fast Remove_Search()
+{Erase_Del(Dl_Pointers[Search_String]);
+}
+
+void Fast Remove_Sent()
+{Erase_Del(Dl_Pointers[Sen_String]);
+}
+
+void Fast Remove_Subs()
+{Erase_Del(Dl_Pointers[Subs_String]);
+}
+
+void Fast Remove_Unknown()
+{Erase_Del(Dl_Pointers[Unknown_String]);
+}
+
+void Fast Remove_Word()
+{Erase_Del(Dl_Pointers[Word_String]);
+}
+
+void Fast Set_Block()
+{Blk_Mode=Count;
+ Hdr_Changes=1;
+}
+
+void Fast Set_Replace()
+{Replace_Mode=Count;
+ Hdr_Changes=1;
+}
+
+void Fast Set_Direction()
+{Com_Direction=Def_Direction=Count;
+ Hdr_Changes=1;
+}
+
+void Fast Set_Tab_Expand()
+{Tab_Expand=Count;
+ Hdr_Changes=1;
+}
+
+void Fast Set_Case_Sensitive()
+{Case_Sensitive=Count;
+ Hdr_Changes=1;
+}
+
+void Fast Set_Reg_Search()
+{Reg_Search=Count;
+ Hdr_Changes=1;
+}
+
+void Fast Set_Ins_Defs()
+{Ins_Defs=Count;
+ Hdr_Changes=1;
+}
+
+void Fast Set_Cursor_Free()
+{Cursor_Free=Count;
+ Hdr_Changes=1;
+}
+
+void Fast Counter_Set()
+{if (!Get_Counter_Index()||Skip)
+  return;
+ if (Direction)
+  Counter[Counter_Index]=Count; else
+  Counter[Counter_Index]= -Count;
+}
+
+void Fast Counter_Put()
+{char *P, C;
+ if (!Get_Counter_Index()||Skip)
+  return;
+#if defined(HPUX)
+ strcpy(Dsk_Rec,ltoa(Counter[Counter_Index]));
+#else
+ longtoascii(Counter[Counter_Index],Dsk_Rec,10);
+#endif
+ P=Dsk_Rec;
+ while ((C= *(P++))!=0)
+  Ins_Char(C);
+ Set_Changes();
+}
+
+void Fast Counter_Increment()
+{if (!Get_Counter_Index()||Skip)
+  return;
+ if (Direction)
+ Counter[Counter_Index]+=Count; else
+ Counter[Counter_Index]-=Count;
+}
+
+void Fast Counter_Absolute_Value()  /* 290a */
+{
+if (!Get_Counter_Index()||Skip)
+  return;
+ if (Counter[Counter_Index]<0)
+  Counter[Counter_Index]=Counter[Counter_Index]*(-1); 
+}
+
+void Fast End_Learn()
+{if (Learning)
+ {Learning=0;
+  Hdr_Changes=1;
+#if defined(VMS) | defined(UNIX)
+  if (Gotmouse)	/* 290a */
+   Enable_Mouse();
+#endif
+  Upd_Header();
+  Out_Zap();
+ }
+}
+
+void Fast Context_Save()
+{if (Outfile==NULL||(Outfile)[0]==0)
+  Error(2,No_File_Txt); else
+  Save_The_Context(Outfile,1);
+}
+
+void Fast Save_The_Context(char *N,int Option)
+{struct File F;
+ if (strlen(N)==0)
+  Error(2,No_Contxt_Name_Txt); else
+ {Filnam(N,Dsk_Rec);
+#if defined(UNIX)
+  strcat(Dsk_Rec,".ctx");
+#else
+  strcat(Dsk_Rec,".CTX");
+#endif
+  if (Option==2)
+  {if (F_open(Dsk_Rec,"r",&F)==NULL)
+    return;
+   if (Err_Flag)
+    return;
+   F_close(&F);
+  }
+  if (F_open(Dsk_Rec,"w",&F)==NULL)
+   Plain_Message(Cannot_Create_Context_Txt); else
+  {if (Err_Flag)
+    return;
+   Filjnam(N,Dsk_Rec);
+#if ! (defined(UNIX) | defined(MPE))
+   strcat(Dsk_Rec,"\r\n");
+#else
+   strcat(Dsk_Rec,"\n");
+#endif
+   F_write(Dsk_Rec,1,strlen(Dsk_Rec),&F);
+   C_Write(My_Pos,&F);
+   {register int I;
+    for (I=0;I<=Maxpoints;I++)
+    {C_Write(Points[I],&F);
+     C_Write(End_Points[I],&F);
+    }
+   }
+   C_Write(Indent,&F);
+   C_Write(Word_Wrap,&F);
+   C_Write(Left_Margin,&F);
+   C_Write(Right_Margin,&F);
+   C_Write((long)Justify,&F);
+   C_Write((long)Auto_Margin,&F);
+   {register int I;
+    for (I=0;I<512;I++)
+     C_Write((long)Tabs[I],&F);
+   }
+   F_close(&F);
+  }
+ }
+}
+
+void Fast Delete_The_Context(char *N)
+{Filnam(N,Dsk_Rec);
+#if defined(UNIX)
+ strcat(Dsk_Rec,".ctx");
+#else
+ strcat(Dsk_Rec,".CTX");
+#endif
+#if defined(VMS)
+ delete(Dsk_Rec);
+#else
+ unlink(Dsk_Rec);
+#endif
+}
+
+void Fast C_Write(long N,struct File *F)
+{
+#if defined(HPUX)
+ strcpy(Dsk_Rec,ltoa(N));
+#else
+ longtoascii(N,Dsk_Rec,10);
+#endif
+#if ! (defined(UNIX) | defined(MPE))
+ strcat(Dsk_Rec,"\r\n");
+#else
+ strcat(Dsk_Rec,"\n");
+#endif
+ F_write(Dsk_Rec,1,strlen(Dsk_Rec),F);
+}
+
+void Fast Check_Point()
+{if(!Executing&&Outfile!=0&&(Any_Changes[Cur_Buffer]&1)&&
+  !Read_Only[Cur_Buffer])
+ {Save_Auto(Outfile);
+  if (!Err_Flag)
+   Auto_Saved++;
+  Auto_Count=0;
+ }
+}
+
+void Fast Push_Changes()
+{Any_Changes[Cur_Buffer]<<=1;
+ Hdr_Changes=1;
+}
+
+void Fast Pop_Changes()
+{Any_Changes[Cur_Buffer]>>=1;
+ Hdr_Changes=1;
+}
+
+void Fast Show_Bcast()
+{
+#if defined(VMS)
+ if (Mbx_Count>0)
+ {Plain_Message(Mbx_Mess[0]);
+  Err_Display=0;
+  Mbx_Count--;
+#if defined(DOS) | defined(NT) | defined(OS2)
+  C_Move(Mbx_Mess[1],Mbx_Mess[0],99*1024);
+#else
+  C_Move(Mbx_Mess[1],Mbx_Mess[0],99*1024,1);
+#endif
+ } else
+  Error(3,No_Messages_Txt);
+#endif
+}
+
+void Fast Window_Used()
+{Sav_Window(Cur_Buffer);
+ if (Direction)
+ {register int I;
+  for (I=Cur_Buffer+1;I!=Cur_Buffer;I++)
+  {if (I==Maxbuffers)
+   {I=0;
+    if (I==Cur_Buffer)
+     break;
+   }
+   if (Dl_Pointers[Pointers+I][0]!=0)
+   {Ch_Window(I);
+    return;
+   }
+  }
+ } else
+ {register int I;
+  for (I=Cur_Buffer-1;I!=Cur_Buffer;I--)
+  {if (I==-1)
+   {I=Maxbuffers-1;
+    if (I==Cur_Buffer)
+     break;
+   }
+   if (Dl_Pointers[Pointers+I][0]!=0)
+   {Load_Window(I);
+    if (Main_Buffer.Bufsize!=0||Outfile!=NULL)
+    {Load_Window(Cur_Buffer);
+     Ch_Window(I);
+     return;
+    }
+   }
+  }
+ }
+ Load_Window(Cur_Buffer);
+ Error(3,No_Buffer_Txt);
+}
+
+void Fast Window_Changed()
+{Sav_Window(Cur_Buffer);
+ if (Direction)
+ {register int I;
+  for (I=Cur_Buffer+1;I!=Cur_Buffer;I++)
+  {if (I==Maxbuffers)
+   {I=0;
+    if (I==Cur_Buffer)
+     break;
+   }
+   if (Dl_Pointers[Pointers+I][0]!=0)
+   {/*Load_Window(I);*/
+    if (Any_Changes[I])	 	/* 290a */ 
+    {/*Load_Window(Cur_Buffer);*/
+     Ch_Window(I);
+     return;
+    }
+   }
+  }
+ } else
+ {register int I;
+  for (I=Cur_Buffer-1;I!=Cur_Buffer;I--)
+  {if (I==-1)
+   {I=Maxbuffers-1;
+    if (I==Cur_Buffer)
+     break;
+   }
+   if (Dl_Pointers[Pointers+I][0]!=0)
+   {/*Load_Window(I);*/
+    if (Any_Changes[I]) 	/* 290a */ 
+    {/*Load_Window(Cur_Buffer);*/
+     Ch_Window(I);
+     return;
+    }
+   }
+  }
+ }
+ Load_Window(Cur_Buffer);
+ Error(3,No_Buffer_Txt);
+}
+
+void Fast Window_Not_Used()
+{if (Direction)
+ {register int I;
+  for (I=Cur_Buffer+1;I!=Cur_Buffer;I++)
+  {if (I==Maxbuffers)
+   {I=0;
+    if (I==Cur_Buffer)
+     break;
+   }
+   if (Dl_Pointers[Pointers+I][0]==0)
+   {Ch_Window(I);
+    return;
+   }
+  }
+ } else
+ {register int I;
+  for (I=Cur_Buffer-1;I!=Cur_Buffer;I--)
+  {if (I==-1)
+   {I=Maxbuffers-1;
+    if (I==Cur_Buffer)
+     break;
+   }
+   if (Dl_Pointers[Pointers+I][0]==0)
+   {Ch_Window(I);
+    return;
+   }
+  }
+ }
+ Error(3,No_Buffer_Txt);
+}
+
+void Fast Window_Cycle()
+{int I;
+ if (Direction)
+ {I=Cur_Buffer+1;
+  if (I==Maxbuffers)
+   I=0;
+ } else
+ {I=Cur_Buffer-1;
+  if (I==-1)
+   I=Maxbuffers-1;
+ }
+ Ch_Window(I);
+ return;
+}
+
+/*      Define the contents of the key given in the first command argument as
+        the value of the command.
+*/
+void Fast Redefine_Key()
+{Gold=Function=0;
+ Get_Key();
+ if (End_Com())
+ {Com_Error();
+  return;
+ }
+ if (Skip)
+  return;
+ if ((Function=Map_Tab[Map_Index].F_Code)<=0||Function<=Top_Func)
+ {if (Next_Func==Maxfunc-1)
+  {Error(2,Max_Func_Txt);
+   return;
+  } else
+   Map_Tab[Map_Index].F_Code=Function= ++Next_Func;
+ }
+ Set_Key(Key_Addr(Function),(int)Count);
+}
+
+#if defined(VMS) | defined(UNIX)
+/*      Display the current column and the ASCII code 
+      	on the bottom line of the display.
+*/
+void Fast Show_Ascii()
+{Set_Region();
+ if (My_Pos>=End_Region)
+ {Message(Show_Column_Txt,My_Col);  	/* 290a */ 
+ }else
+ {B_Goto(Current,My_Pos);
+  Message(Col_Ascii_Value_Txt,My_Col,B_Get(Current));  	/* 290a */ 
+ }
+}
+#else
+/*      Display the ASCII code on the bottom line of the display.
+*/
+void Fast Show_Ascii()
+{Set_Region();
+ if (My_Pos>=End_Region)
+ {Error(2,End_Region_Txt);
+  return;
+ }
+ B_Goto(Current,My_Pos);
+ Message(Ascii_Value_Txt,B_Get(Current));
+}
+#endif
+
+void Fast W_D_Border()
+{int Save_Line, Save_Att;
+ long Save_Col, Save_Shift;
+ register int I;
+ if (Zoomed)
+  return;
+ Out_Zap();
+ Save_Line=My_Line;
+ Save_Col=My_Col;
+ Save_Att=Cur_Attributes;
+ Save_Shift=Scr_Shift;
+ Scr_Shift=0;
+ Top_Row--;
+ Left_Col--;
+ Scr_Length+=2;
+ Scr_Width+=2;
+ Cur_Attributes=A_Bold+A_Reverse;
+ if (Top_Row>=0)
+ {Opt_Cursor(1,(long)1);
+  if (Left_Col>=0)
+   Opt_Char((char)D_Border[0]); else
+   My_Col++;
+  for (I=2;I<=Scr_Width-1;I++)
+   Opt_Char((char)D_Border[1]);
+  if (Left_Col+Scr_Width<=Max_Width)
+   Opt_Char((char)D_Border[2]); else
+   My_Col++;
+ }
+ if (Left_Col+Scr_Width<=Max_Width)
+#if defined(GEM) | defined(Windows) | defined(TV)
+  for (I=2;I<=Scr_Length-2;I++)
+#else
+  for (I=2;I<=Scr_Length-1;I++) 	/* 290a */ 
+#endif
+  {Opt_Cursor(I,(long)Scr_Width);
+   Opt_Char((char)D_Border[3]);
+  }
+#if defined(GEM) | defined(Windows) | defined(TV)
+ if (Top_Row+Scr_Length<=Max_Length)
+ {Opt_Cursor(Scr_Length-1,(long)Scr_Width);
+  if (Left_Col+Scr_Width<=Max_Width)
+   Opt_Char((char)D_Border[4]);
+  Opt_Cursor(Scr_Length-1,(long)1);
+  if (Left_Col>=0)
+   Opt_Char((char)D_Border[6]);
+  Opt_Cursor(Scr_Length-1,(long)2);
+  for (I=2;I<=Scr_Width-1;I++)
+   Opt_Char((char)D_Border[5]);
+ }
+ if (Left_Col>=0)
+  for (I=Scr_Length-2;I>1;I--)
+#else
+ if (Top_Row+Scr_Length<Max_Length-1) 	/* 290a */ 
+ {Opt_Cursor(Scr_Length,(long)Scr_Width);
+  if (Left_Col+Scr_Width<=Max_Width)
+   Opt_Char((char)D_Border[4]);
+  Opt_Cursor(Scr_Length,(long)1);
+  if (Left_Col>=0)
+   Opt_Char((char)D_Border[6]);
+  Opt_Cursor(Scr_Length,(long)2);
+  for (I=2;I<=Scr_Width-1;I++)
+   Opt_Char((char)D_Border[5]);
+ }
+ if (Left_Col>=0)
+  for (I=Scr_Length-1;I>1;I--) 	/* 290a */ 
+#endif
+  {Opt_Cursor(I,(long)1);
+   Opt_Char((char)D_Border[7]);
+  }
+ if (Top_Row>=0)
+ {Opt_Cursor(1,(long)2);
+  Put_I((long)Cur_Buffer);
+  /*Opt_Char(':');
+  Opt_String(Outfile);*/ 	/* 290a */ 
+ }
+ Out_Zap();
+ Top_Row++;
+ Left_Col++;
+ Scr_Length-=2;
+ Scr_Width-=2;
+ Cur_Attributes=Save_Att;
+ Opt_Cursor(Save_Line,Save_Col);
+ Scr_Shift=Save_Shift;
+#if defined(VMS) | defined(UNIX) | defined(ATARI)
+ His_Line=His_Col= -1;
+#endif
+}
+
+void Fast W_S_Border()
+{int Save_Line, Save_Att;
+ long Save_Col, Save_Shift;
+ register int I;
+ if (Zoomed)
+  return;
+ Out_Zap();
+ Save_Line=My_Line;
+ Save_Col=My_Col;
+ Save_Att=Cur_Attributes;
+ Save_Shift=Scr_Shift;
+ Scr_Shift=0;
+ Top_Row--;
+ Left_Col--;
+ Scr_Length+=2;
+ Scr_Width+=2;
+ Cur_Attributes=0;
+ if (Top_Row>=0)
+ {Opt_Cursor(1,(long)1);
+  if (Left_Col>=0)
+   Opt_Char((char)S_Border[0]); else
+   My_Col++;
+  for (I=2;I<=Scr_Width-1;I++)
+   Opt_Char((char)S_Border[1]);
+  if (Left_Col+Scr_Width<=Max_Width)
+   Opt_Char((char)S_Border[2]); else
+   My_Col++;
+ }
+ if (Left_Col+Scr_Width<=Max_Width)
+#if defined(GEM) | defined(Windows) | defined(TV)
+  for (I=2;I<=Scr_Length-2;I++)
+#else
+  for (I=2;I<=Scr_Length-1;I++) 	/* 290a */ 
+#endif
+  {Opt_Cursor(I,(long)Scr_Width);
+   Opt_Char((char)S_Border[3]);
+  }
+#if defined(GEM) | defined(Windows) | defined(TV)
+ if (Top_Row+Scr_Length<=Max_Length)
+ {Opt_Cursor(Scr_Length-1,(long)Scr_Width);
+  if (Left_Col+Scr_Width<=Max_Width)
+   Opt_Char((char)D_Border[4]);
+  Opt_Cursor(Scr_Length-1,(long)1);
+  if (Left_Col>=0)
+   Opt_Char((char)D_Border[6]);
+  Opt_Cursor(Scr_Length-1,(long)2);
+  for (I=2;I<=Scr_Width-1;I++)
+   Opt_Char((char)D_Border[5]);
+ }
+ if (Left_Col>=0)
+  for (I=Scr_Length-2;I>1;I--)
+#else
+ if (Top_Row+Scr_Length<Max_Length-1) 	/* 290a */ 
+ {Opt_Cursor(Scr_Length,(long)Scr_Width);
+  if (Left_Col+Scr_Width<=Max_Width)
+   Opt_Char((char)S_Border[4]);
+  Opt_Cursor(Scr_Length,(long)2);
+  for (I=2;I<=Scr_Width-1;I++)
+   Opt_Char((char)S_Border[5]);
+  Opt_Cursor(Scr_Length,(long)1);
+  if (Left_Col>=0)
+   Opt_Char((char)S_Border[6]);
+ }
+ if (Left_Col>=0)
+  for (I=Scr_Length-1;I>1;I--) 	/* 290a */ 
+#endif
+  {Opt_Cursor(I,(long)1);
+   Opt_Char((char)S_Border[7]);
+  }
+ if (Top_Row>=0)
+ {Opt_Cursor(1,(long)2);
+  Put_I((long)Cur_Buffer);
+  if (Top_Row<Scr_Length/2) 	/* 290a */ 
+  {Opt_Char(':');
+   Opt_String(Outfile);
+  }
+ }
+ Out_Zap();
+ Top_Row++;
+ Left_Col++;
+ Scr_Length-=2;
+ Scr_Width-=2;
+ Cur_Attributes=Save_Att;
+ Opt_Cursor(Save_Line,Save_Col);
+ Scr_Shift=Save_Shift;
+#if defined(VMS) | defined(UNIX) | defined(ATARI)
+ His_Line=His_Col= -1;
+#endif
+}
+
+void Fast Open_Window()
+{Out_Zap();
+ W_D_Border();
+ Repaint();
+}
+
+void Fast Refresh_Window()
+{register int I;
+ Out_Zap();
+ Down_Type=0;
+ if (!Zoomed) 	/* 290a */
+ {
+  Sav_Window(Cur_Buffer);
+  Reset_Screen();
+  for (I=1;I<Buffers-1;I++)	/* 290a search next zoomed window in stack */
+  {Load_Window(Buffer_Stack[I]);
+   if (Zoomed) break;
+  }
+  for (;I>=0;I--)
+  {
+   Load_Window(Buffer_Stack[I]);
+   Cur_Buffer=Buffer_Stack[I];
+   if (I==0)
+    W_D_Border(); else
+    W_S_Border();
+   Repaint();
+   Mark_Cursor();
+   Out_Zap();
+  }
+  Unmark_Cursor();
+ } else
+ Repaint();
+}
+
+void Fast Window_Grow()
+{
+ int Done;
+ if (Zoomed)
+ {Error(2,Txt_Zoomed_Error);
+  return;
+ }
+#if defined(DOS) | defined(NT) | defined(OS2) | (defined(ATARI) & defined(GEM))
+ Mouse_OK=Done=0;
+#else
+ Done=0;
+#endif
+#if defined(VMS) | defined(UNIX)
+ if (Gotmouse)	/* 290a */
+  Disable_Mouse();
+#endif
+ while (!Done)
+ {Out_Zap();
+  Get16();
+  if (Gold)
+   Error(2,Illegal_Keystroke_Txt); else
+  switch (Key_Number)
+  {case 27: /*Up Arrow*/
+    if (Top_Row>0)
+    {Top_Row--;
+     Scr_Length++;
+     Open_Window();
+    }
+    break;
+   case 28: /*Left Arrow*/
+    if (Left_Col>0)
+    {Left_Col--;
+     Scr_Width++;
+     Open_Window();
+    }
+    break;
+   case 29: /*Down Arrow*/
+#if defined(GEM) | defined(Windows) | defined(TV)
+    if (Top_Row+Scr_Length<Max_Length)
+#else
+    if (Top_Row+Scr_Length<Max_Length-2) 	/* 290a */ 
+#endif
+    {Scr_Length++;
+     Open_Window();
+    }
+    break;
+   case 30: /*Right Arrow*/
+    if (Left_Col+Scr_Width<Max_Width)
+    {Scr_Width++;
+     Open_Window();
+    }
+    break;
+   case 48:
+   case 50: /*Return,Enter*/
+    Refresh_Window();
+    Done=1;
+    break;
+   default:
+    Error(2,Illegal_Keystroke_Txt);
+    break;
+  }
+ }
+#if defined(VMS) | defined(UNIX)
+ if (Gotmouse)	/* 290a */
+  Enable_Mouse();
+#endif
+#if defined(DOS) | defined(NT) | defined(OS2) | (defined(ATARI) & defined(GEM))
+ Mouse_OK=1;
+#endif
+}
+
+void Fast Window_Shrink()
+{
+ int Done;
+ if (Zoomed)
+ {Error(2,Txt_Zoomed_Error);
+  return;
+ }
+#if defined(DOS) | defined(NT) | defined(OS2) | (defined(ATARI) & defined(GEM))
+ Mouse_OK=Done=0;
+#else
+ Done=0;
+#endif
+#if defined(VMS) | defined(UNIX)
+ if (Gotmouse)	/* 290a */
+  Disable_Mouse();
+#endif
+ while (!Done)
+ {Out_Zap();
+  Get16();
+  if (Gold)
+   Error(2,Illegal_Keystroke_Txt); else
+  switch (Key_Number)
+  {case 27: /*Up Arrow*/
+    if (Scr_Length>4)
+    {Scr_Length--;
+     Open_Window();
+    }
+    break;
+   case 28: /*Left Arrow*/
+    if (Scr_Width>1)
+    {Scr_Width--;
+     Open_Window();
+    }
+    break;
+   case 29: /*Down Arrow*/
+    if (Scr_Length>4)
+    {Top_Row++;
+     Scr_Length--;
+     Open_Window();
+    }
+    break;
+   case 30: /*Right Arrow*/
+    if (Scr_Width>1)
+    {Left_Col++;
+     Scr_Width--;
+     Open_Window();
+    }
+    break;
+   case 48:
+   case 50: /*Return,Enter*/
+    Refresh_Window();
+    Done=1;
+    break;
+   default:
+    Error(2,Illegal_Keystroke_Txt);
+    break;
+  }
+ }
+#if defined(DOS) | defined(NT) | defined(OS2) | (defined(ATARI) & defined(GEM))
+ Mouse_OK=1;
+#endif
+#if defined(VMS) | defined(UNIX)
+ if (Gotmouse)	/* 290a */
+  Enable_Mouse();
+#endif
+}
+
+void Fast Window_Move()
+{
+ int Done;
+ if (Zoomed)
+ {Error(2,Txt_Zoomed_Error);
+  return;
+ }
+#if defined(DOS) | defined(NT) | defined(OS2) | (defined(ATARI) & defined(GEM))
+ Mouse_OK=Done=0;
+#else
+ Done=0;
+#endif
+#if defined(VMS) | defined(UNIX)
+ if (Gotmouse)	/* 290a */
+  Disable_Mouse();
+#endif
+ while (!Done)
+ {Out_Zap();
+  Get16();
+  if (Gold)
+   Error(2,Illegal_Keystroke_Txt); else
+  switch (Key_Number)
+  {case 27: /*Up Arrow*/
+    if (Top_Row>0)
+    {Top_Row--;
+     Open_Window();
+    }
+    break;
+   case 28: /*Left Arrow*/
+    if (Left_Col>0)
+    {Left_Col--;
+     Open_Window();
+    }
+    break;
+   case 29: /*Down Arrow*/
+#if defined(GEM) | defined(Windows) | defined(TV)
+    if (Top_Row+Scr_Length<Max_Length)
+#else
+    if (Top_Row+Scr_Length<Max_Length-2) 	/* 290a */ 
+#endif
+    {Top_Row++;
+     Open_Window();
+    }
+    break;
+   case 30: /*Right Arrow*/
+    if (Left_Col+Scr_Width<Max_Width)
+    {Left_Col++;
+     Open_Window();
+    }
+    break;
+   case 48:
+   case 50: /*Return,Enter*/
+    Refresh_Window();
+    Done=1;
+    break;
+   default:
+    Error(2,Illegal_Keystroke_Txt);
+    break;
+  }
+ }
+#if defined(DOS) | defined(NT) | defined(OS2) | (defined(ATARI) & defined(GEM))
+ Mouse_OK=1;
+#endif
+#if defined(VMS) | defined(UNIX)
+ if (Gotmouse)	/* 290a */
+  Enable_Mouse();
+#endif
+}
+
+void Fast Window_Zoom()
+{
+#if !(((defined(DOS) | defined(NT)) & ((defined(Windows) | defined(TV)) | defined(TV))) | (defined(ATARI) & defined(GEM)))
+ if ((Count==2&&Zoomed)||(Count==3&&!Zoomed))
+  ; else
+ if (Zoomed)
+ {Zoomed=0;
+  Top_Row=Save_Top;
+  Left_Col=Save_Left;
+  Scr_Length=Save_Length;
+  Scr_Width=Save_Width;
+  Refresh_Window();
+ } else
+ {Zoomed=1;
+  Save_Top=Top_Row;
+  Save_Left=Left_Col;
+  Save_Length=Scr_Length;
+  Save_Width=Scr_Width;
+  Top_Row=0;
+  Left_Col=0;
+#if defined(GEM) | defined(Windows) | defined(TV)
+  Scr_Length=Max_Length;
+#else
+  Scr_Length=Max_Length-2;
+#endif
+  Scr_Width=Max_Width;
+  Open_Window();
+ }
+ Set_Cursor(My_Line,My_Col);
+#endif
+#if defined(DOS) & defined(TV)
+ TV_Zoom();
+#endif
+}
+
+void Fast Window_Tile()
+{
+#if !(((defined(DOS) | defined(NT)) & ((defined(Windows) | defined(TV)) | defined(TV))) | (defined(ATARI) & defined(GEM)))
+ int Across, Down, W, I;
+ if (Buffers==1)
+  Across=Down=W=1; else
+ if (Buffers==2)
+ {Across=1;
+  Down=2;
+  W=2;
+ } else
+ if (Buffers<=4)
+ {Across=2;
+  Down=2;
+  W=4;
+ } else
+ if (Buffers<=6)
+ {Across=2;
+  Down=3;
+  W=6;
+ } else
+ if (Buffers<=9)
+ {Across=3;
+  Down=3;
+  W=9;
+ } else
+ if (Buffers<=12)
+ {Across=3;
+  Down=4;
+  W=12;
+ } else
+ {Across=4;
+  Down=4;
+  W=16;
+ }
+ if (W>Buffers)
+  W=Buffers;
+ /*Diag("Window_Tile:Across=%d,Down=%d,Buffers=%d,W=%d",
+  Across,Down,Buffers,W);*/
+ Sav_Window(Cur_Buffer);
+ for (I=W-1;I>=0;I--)
+ {Load_Window(Buffer_Stack[I]);
+  Top_Row=((Max_Length-2)/Down)*(I/Across)+1;
+  Left_Col=(Max_Width/Across)*(I%Across)+1;
+  Scr_Length=((Max_Length-3)/Down)-1;
+  Scr_Width=(Max_Width/Across)-2;
+  Zoomed=0;
+  Sav_Window(Buffer_Stack[I]);
+ }
+ Load_Window(Cur_Buffer);
+ Refresh_Window();
+#endif
+#if defined(DOS) & defined(TV)
+ TV_Tile();
+#endif
+}
+
+void Fast Window_Cascade()
+{
+#if defined(DOS) & defined(TV)
+ TV_Cascade();
+#endif
+}
+
+void Fast Window_Fix_Bottom()
+{int Smaller;
+ if (Direction==0)
+#if defined(GEM) | defined(Windows) | defined(TV)
+  Count=Max_Length/2;
+ if (Count<Top_Row+4||Count>Max_Length+1)
+  Error(2,Bad_Window_Pos_Txt); else
+ {Zoomed=0;
+  Smaller=Count<Top_Row+Scr_Length+1;
+#else
+  Count=Max_Length/2-2;	/* 290a */
+ if (Count<Top_Row+4||Count>=Max_Length-1)	/* 290a */
+  Error(2,Bad_Window_Pos_Txt); else
+ {Zoomed=0;
+  Smaller=Count<=Top_Row+Scr_Length;	/* 290a */
+#endif
+  Scr_Length=Count-Top_Row;
+  if (Smaller)
+   Refresh_Window(); else
+   Repaint();
+ }
+}
+
+void Fast Window_Fix_Left()
+{int Smaller;
+ if (Direction==0)
+  Count=Max_Width/2;
+ if (Count<0||Count>Left_Col+Scr_Width)
+  Error(2,Bad_Window_Pos_Txt); else
+ {Zoomed=0;
+  Smaller=Count>Left_Col;
+  Scr_Width-=Count-Left_Col;
+  Left_Col=Count;
+  if (Smaller)
+   Refresh_Window(); else
+   Repaint();
+ }
+}
+
+void Fast Window_Fix_Right()
+{int Smaller;
+ if (Direction==0)
+  Count=Max_Width/2;
+ if (Count<Left_Col+4||Count>Max_Width+1)
+  Error(2,Bad_Window_Pos_Txt); else
+ {Zoomed=0;
+  Smaller=Count<Left_Col+Scr_Width+1;
+  Scr_Width=Count-Left_Col-1;
+  if (Smaller)
+   Refresh_Window(); else
+   Repaint();
+ }
+}
+
+void Fast Window_Fix_Top()
+{int Smaller;
+ if (Direction==0)
+#if defined(GEM) | defined(Windows) | defined(TV)
+  Count=Max_Length/2;
+#else
+  Count=Max_Length/2-1;	/* 290a */
+#endif
+ if (Count<0||Count>Top_Row+Scr_Length)
+  Error(2,Bad_Window_Pos_Txt); else
+ {Zoomed=0;
+  Smaller=Count>Top_Row;
+  Scr_Length-=Count-Top_Row;
+  Top_Row=Count;
+  if (Smaller)
+   Refresh_Window(); else
+   Repaint();
+ }
+}