home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3879 < prev    next >
Encoding:
Text File  |  1991-08-22  |  57.3 KB  |  2,522 lines
  1. Path: wupost!decwrl!amdcad!pyramid!oliveb!olivea!samsung!crackers!m2c!wpi.WPI.EDU!rcarter
  2. From: rcarter@wpi.WPI.EDU (Randolph Carter (nee. Joseph H. Allen))
  3. Newsgroups: alt.sources
  4. Subject: J (Joe's Editor) - Part 3 of 3
  5. Message-ID: <1991Aug22.043527.30804@wpi.WPI.EDU>
  6. Date: 22 Aug 91 04:35:27 GMT
  7. Sender: rcarter@wpi.WPI.EDU (Randolph Carter (nee. Joseph H. Allen))
  8. Organization: Kadath Tours, Inc.
  9. Lines: 2511
  10.  
  11.  
  12. -- Cut here; take text between this line and the last 'cut' line
  13.  fclose(handle);
  14.  }
  15. else
  16.  {
  17.  ldbuf(bt);
  18.  sprintf(sting,"\033[7mError opening file %s\033[m",gfnam1);
  19.  msg(sting);
  20.  }
  21. }
  22.  
  23. delblk()
  24. {
  25. struct buffer *bt=curbuf;
  26. TXTSIZ x=fmnote();
  27. TXTSIZ sz;
  28. if(markbuf)
  29.  {
  30.  stbuf(curbuf);
  31.  ldbuf(markbuf);
  32.  }
  33. if(marke<=markb || marke>fmsize() || !markbuf)
  34.  {
  35.  msg("\033[7mThe block is not marked properly\033[m  Mark it with ^KB & ^KK");
  36.  if(markbuf)
  37.   ldbuf(bt);
  38.  return;
  39.  }
  40. if(bt==markbuf) if(x>=markb && x<marke) x=markb;
  41. sz=marke-markb;
  42. fmpoint(markb);
  43. fmdel(sz);
  44. if(bt==markbuf) if(x>markb) x-=sz;
  45. stbuf(markbuf);
  46. ldbuf(bt);
  47. fmpoint(x);
  48. updall=1;
  49. newy=1;
  50. }
  51.  
  52. moveblk()
  53. {
  54. unsigned char *t;
  55. TXTSIZ sz, x=fmnote();
  56. struct buffer *bt=curbuf;
  57. if(markbuf)
  58.  {
  59.  stbuf(curbuf);
  60.  ldbuf(markbuf);
  61.  }
  62. if(marke<=markb || marke>fmsize() || !markbuf)
  63.  {
  64.  msg("\033[7mThe block is not marked properly\033[m  Mark it with ^KB & ^KK");
  65.  if(markbuf)
  66.   ldbuf(bt);
  67.  return;
  68.  }
  69. if(x>=markb && x<=marke && bt==markbuf)
  70.  {
  71.  x=markb;
  72.  ldbuf(bt);
  73.  return;
  74.  }
  75. sz=marke-markb;
  76. t=(unsigned char *)malloc(sz);
  77. fmpoint(markb);
  78. fmcpy(t,sz);
  79. fmdel(sz);
  80. if(bt==markbuf) if(x>markb) x-=sz, newy=1;
  81. stbuf(markbuf); 
  82. ldbuf(bt);
  83. fmpoint(x);
  84. fminss(t,sz);
  85. free(t);
  86. markb=x;
  87. marke=x+sz;
  88. markbuf=bt;
  89. updall=1;
  90. }
  91.  
  92. cpyblk()
  93. {
  94. unsigned char *t;
  95. TXTSIZ x=fmnote();
  96. struct buffer *bt=curbuf;
  97. TXTSIZ sz;
  98. if(markbuf)
  99.  {
  100.  stbuf(curbuf);
  101.  ldbuf(markbuf);
  102.  }
  103. if(marke<=markb || marke>fmsize() || !markbuf)
  104.  {
  105.  msg("\033[7mThe block is not marked properly\033[m  Mark it with ^KB & ^KK");
  106.  if(markbuf)
  107.   ldbuf(bt);
  108.  return;
  109.  }
  110. sz=marke-markb;
  111. t=(unsigned char *)malloc(sz);
  112. fmpoint(markb);
  113. fmcpy(t,sz);
  114. stbuf(markbuf);
  115. ldbuf(bt); 
  116. fmpoint(x);
  117. fminss(t,sz);
  118. free(t);
  119. marke=x+sz;
  120. markb=x;
  121. markbuf=bt;
  122. updall=1;
  123. }
  124.  
  125. insfil()
  126. {
  127. unsigned char gfnam1[PATHSIZE];
  128. unsigned char sting[PATHSIZE];
  129. gfnam1[0]=0;
  130. if(!getl("File to insert",gfnam1)) return;
  131. fixpath(gfnam1);
  132. handle=fopen(gfnam1,"r");
  133. if(handle)
  134.  {
  135.  if(!fminsfil(handle))
  136.   {
  137.   sprintf(sting,"\033[7mError inserting file %s\033[m",gfnam1);
  138.   msg(sting);
  139.   }
  140.  newy=1;
  141.  fclose(handle);
  142.  }
  143. else
  144.  {
  145.  sprintf(sting,"\033[7mError opening file %s\033[m",gfnam1);
  146.  msg(sting);
  147.  return;
  148.  }
  149. }
  150.  
  151. push()
  152. {
  153. unsigned char *ssh=(unsigned char *)getenv("SHELL");
  154. if(!ssh)
  155.  {
  156.  msg("Couldn't find shell");
  157.  return;
  158.  }
  159. dclose("You are at the command shell.  Type 'exit' to continue editing");
  160. shell(ssh);
  161. rewrite();
  162. }
  163.  
  164. mode()
  165. {
  166. unsigned char s[PATHSIZE];
  167. s[0]=0;
  168. strcat(s,"(R)ght Mrgn ");
  169. if(overwrite) strcat(s,"(I) Overtype ");
  170. else strcat(s,"(I)nsert ");
  171. if(tabmagic) strcat(s,"(T)ab Magic on ");
  172. else strcat(s,"(T)ab Magic off ");
  173. if(wrap) strcat(s,"(W)rap on ");
  174. else strcat(s,"(W)rap off ");
  175. if(autoind) strcat(s,"(A) Indent on ");
  176. else strcat(s,"(A) Indent off ");
  177. if(pic) strcat(s,"(P)ic on: ");
  178. else strcat(s,"(P)ic off: ");
  179. switch(query(s))
  180.  {
  181.  case 'i':
  182.  case 'I':
  183.  case 'o':
  184.  case 'O':
  185.   overwrite= !overwrite;
  186.   break;
  187.  case 'W':
  188.  case 'w':
  189.   wrap= !wrap;
  190.   break;
  191.  case 'a':
  192.  case 'A':
  193.   autoind= !autoind;
  194.   break;
  195.  case 't':
  196.  case 'T':
  197.   tabmagic= !tabmagic;
  198.   break;
  199.  case 'p':
  200.  case 'P':
  201.   pic= !pic;
  202.   break;
  203.  case 'r':
  204.  case 'R':
  205.   {
  206.   char sting[80];
  207.   sprintf(sting,"%d",rmargin);
  208.   if(!getl("Right margin",sting)) return;
  209.   rmargin=atol(sting);
  210.   if(rmargin<2) rmargin=2;
  211.   }
  212.  }
  213. }
  214.  
  215. /* Center the current line */
  216.  
  217. ctrlin()
  218. {
  219. TXTSIZ x;
  220. int tmp=pic;
  221. int y;
  222. unfill();
  223. bol();
  224. while(y=fmrc(), y==' ' || y=='\t') fmdel(1);
  225. eol();
  226. x=fmnote();
  227. bol();
  228. if(x-fmnote()>rmargin) return;
  229. y=(rmargin/2)-(x-fmnote())/2;
  230. while(y--) fminsc(' ');
  231. pic=1;
  232. udnarw();
  233. pic=tmp;
  234. }
  235.  
  236. /* Reformat a paragraph */
  237.  
  238. reformat()
  239. {
  240. TXTSIZ tmp,idt,idt1,b,e;
  241. unsigned char ch;
  242.  
  243. /* First, determine indentation on current or first non-blank line */
  244.  
  245. up:
  246. idt=calcs();
  247. if(fmeof()) return;     /* Not if at end of file */
  248. if(fmrc()==NL)  /* Ignore any blank lines */
  249.  {
  250.  dnarw();
  251.  goto up;
  252.  }
  253. bol();
  254.  
  255. /* Now find beginning of paragraph */
  256. /* It will be indicated by a change of indentation or a blank line or bof */
  257.  
  258. while(fmnote())         /* Beginning is at bof */
  259.  {
  260.  uparw();
  261.  idt1=calcs();
  262.  if(fmrc()==NL) /* Beginning is blank line */
  263.   {
  264.   bol();
  265.   dnarw();
  266.   break;
  267.   }
  268.  bol();
  269.  if(idt1>idt) break;
  270.  if(idt1<idt)
  271.   {
  272.   dnarw();
  273.   break;
  274.   }
  275.  }
  276.  
  277. /* Point is now at beginning of paragraph (hopefully) */
  278. /* Set the mark */
  279.  
  280. b=fmnote();
  281.  
  282. idt=calcs(); bol();    /* Save indentation level of first line of paragraph */
  283.  
  284. /* Now move to after end of paragraph */
  285. while(1)
  286.  {
  287.  tmp=fmnote();
  288.  dnarw();
  289.  if(fmnote()==tmp)      /* Paragraph ends on end of file */
  290.   {
  291.   eol();
  292.   fminsc(NL);        /* Stick in a NL */
  293.   fmgetc();
  294.   extend=0;        /* I don't think I have to do this but... */
  295.   break;
  296.   }
  297.  idt1=calcs();
  298.  if(fmrc()==NL)        /* Paragraph ends on blank line */
  299.   {
  300.   bol();
  301.   break;
  302.   }
  303.  bol();
  304.  if(idt1>idt) break;    /* Paragraph ends when indentation increases */
  305.  }
  306.  
  307. /* Point now after end of paragraph, cut paragraph */
  308. e=fmnote();
  309.  
  310. /* Now reinsert paragraph in a nice way */
  311.  
  312. if(e>b)
  313.  {
  314.  unsigned oldwrap=wrap;
  315.  unsigned oldoverwrite=overwrite;
  316.  unsigned oldauto=autoind;
  317.  unsigned flag=0;
  318.  unsigned char ccc=0;
  319.  TXTSIZ ppp=b; 
  320.  overwrite=0;
  321.  wrap=1;
  322.  while(ppp!=e)
  323.   {
  324.   tmp=fmnote();
  325.   fmpoint(ppp);
  326.   ppp++;
  327.   ch=fmrc();
  328.   fmpoint(tmp);
  329.   if(ch==NL) ch=' ';
  330.   if(ch==' ' || ch==TAB)
  331.    {
  332.    if(flag==0) itype(ch);
  333.    else if(flag==1)
  334.      {
  335.      itype(' ');
  336.      if(!(ccc=='.' || ccc==':' || ccc=='?' || ccc=='!' || ccc=='\"' ||
  337.           ccc==';')) flag=2;
  338.      }
  339.    }
  340.   else
  341.    {
  342.    flag=1;
  343.    itype(ch);
  344.    }
  345.   ccc=ch;
  346.   }
  347.  autoind=0;
  348.  if(flag) itype(NL);
  349.  wrap=oldwrap;
  350.  overwrite=oldoverwrite;
  351.  autoind=oldauto;
  352.  tmp=fmnote();
  353.  fmpoint(b);
  354.  fmdel(e-b);
  355.  fmpoint(tmp-(e-b));
  356.  newy=1;
  357.  }
  358. }
  359.  
  360. killword()
  361. {
  362. unsigned char ch;
  363. ch=fmrc();
  364. if(((ch>='a' && ch<='z') || (ch>='A' && ch <='Z')) && !fmeof())
  365.  do
  366.   {
  367.   delch();
  368.   ch=fmrc();
  369.   } while (((ch>='a' && ch<='z') || (ch>='A' && ch <='Z')) && !fmeof());
  370. else
  371.  if((ch==' ' || ch==TAB || ch==NL) && !fmeof())
  372.   do
  373.    {
  374.    delch();
  375.    ch=fmrc();
  376.    } while (!fmeof() && (ch==' ' || ch==NL || ch==TAB));
  377. else
  378.  if(ch>='0' && ch<='9' && !fmeof())
  379.   do
  380.    {
  381.    delch();
  382.    ch=fmrc();
  383.    } while (!fmeof() && ch>='0' && ch<='9');
  384. else delch();
  385. }
  386.  
  387. backword()
  388. {
  389. unsigned char ch;
  390. if(fmnote())
  391.  {
  392.  fmpoint(fmnote()-1);
  393.  ch=fmgetc();
  394.  if((ch>='a' && ch<='z') || (ch>='A' && ch <='Z'))
  395.   {
  396. up:
  397.   backs();
  398.   if(fmnote())
  399.    {
  400.    fmpoint(fmnote()-1);
  401.    ch=fmrc();
  402.    fmgetc();
  403.    if((ch>='a' && ch<='z') || (ch>='A' && ch <='Z')) goto up;
  404.    }
  405.   }
  406.  else if(ch==' ' || ch==TAB || ch==NL)
  407.    {
  408. up1:
  409.    backs();
  410.    if(fmnote())
  411.     {
  412.     fmpoint(fmnote()-1);
  413.     ch=fmrc();
  414.     fmgetc();
  415.     if(ch==' ' || ch==TAB || ch==NL) goto up1;
  416.     }
  417.    }
  418.  else if(ch>='0' && ch<='9')
  419.    {
  420. up2:
  421.    backs();
  422.    if(fmnote())
  423.     {
  424.     fmpoint(fmnote()-1);
  425.     ch=fmrc();
  426.     fmgetc();
  427.     if(ch>='0' && ch<='9') goto up2;
  428.     }
  429.    }
  430.  else backs();
  431.  }
  432. }
  433.  
  434. word()
  435. {
  436. int c;
  437. if(fmnote()==fmsize()) return 0;
  438. c=fmrc();
  439. if(c>='a' && c<='z') return 1;
  440. if(c>='A' && c<='Z') return 1;
  441. if(c>='0' && c<='9') return 1;
  442. return 0;
  443. }
  444.  
  445. wrdl()
  446. {
  447. extend=0;
  448. newy=1;
  449. if(!fmnote()) return;
  450. fmrgetc();
  451. while(!word())
  452.  {
  453.  if(!fmnote()) return;
  454.  fmrgetc();
  455.  }
  456. while(word())
  457.  {
  458.  if(!fmnote()) return;
  459.  fmrgetc();
  460.  }
  461. fmgetc();
  462. }
  463.  
  464. wrdr()
  465. {
  466. extend=0;
  467. newy=1;
  468. while(!word())
  469.  {
  470.  if(fmnote()==fmsize()) return;
  471.  fmgetc();
  472.  }
  473. while(word())
  474.  {
  475.  if(fmnote()==fmsize()) return;
  476.  fmgetc();
  477.  }
  478. }
  479.  
  480. unsigned char lft[]="{[(<`";
  481. unsigned char rht[]="}])>'";
  482.  
  483. gotomatching()
  484. {
  485. TXTSIZ cur=fmnote(),cnt;
  486. unsigned char c;
  487. int x;
  488. extend=0;
  489. if(fmeof()) return;
  490. c=fmrc();
  491. for(x=0;x!=strlen(lft);++x)
  492.  if(lft[x]==c)
  493.   {
  494.   cnt=0;
  495.   while(!fmeof())
  496.    {
  497.    c=fmgetc();
  498.    if(lft[x]==c) ++cnt;
  499.    if(rht[x]==c)
  500.     if(!--cnt)
  501.      {
  502.      newy=1;
  503.      fmrgetc();
  504.      return;
  505.      }
  506.    }
  507.   fmpoint(cur);
  508.   return;
  509.   }
  510.  else if(rht[x]==c)
  511.   {
  512.   cnt=1;
  513.   while(fmnote())
  514.    {
  515.    c=fmrgetc();
  516.    if(rht[x]==c) ++cnt;
  517.    if(lft[x]==c)
  518.     if(!--cnt)
  519.      {
  520.      newy=1;
  521.      return;
  522.      }
  523.    }
  524.   fmpoint(cur);
  525.   return;
  526.   }
  527. }
  528.  
  529. int setindent()
  530. {
  531. TXTSIZ idt,idt1,cur=fmnote(),tmp;
  532. if(curbuf==markbuf && cur>=markb && cur<marke) return 1;
  533. markbuf=curbuf; markb=0; marke=0;
  534. /* Find beginning */
  535. idt=calcs();
  536. if(fmeof()) goto done;
  537. if(fmrc()==NL) goto done;
  538. while(fmnrnl())
  539.  {
  540.  idt1=calcs();
  541. /* if(fmrc()!=NL) if(idt1<idt) Use this line instead of one below for
  542.    setindent to ignore blank lines */
  543.  if(fmrc()==NL || idt1<idt)
  544.   {
  545.   if(fmfnl()) fmgetc();
  546.   break;
  547.   }
  548.  }
  549. /* Point is now at beginning of block (hopefully) */
  550. /* Set the mark */
  551. markb=fmnote();
  552.  
  553. while(fmfnl())
  554.  {
  555.  fmgetc();
  556.  idt1=calcs();
  557. /* if(fmrc()!=NL) if(idt1<idt) Use this line instead of one below for
  558.    setindent to ignore blank lines */
  559.  if(fmrc()==NL || idt1<idt)
  560.   {
  561.   bol();
  562.   break;
  563.   }
  564.  }
  565. marke=fmnote();
  566. done: fmpoint(cur);
  567. return 0;
  568. } 
  569.  
  570. indentr()
  571. {
  572. TXTSIZ cur=fmnote(),tmp;
  573. if(!setindent()) return;
  574. fmpoint(markb);
  575. while(fmnote()<marke)
  576.  {
  577.  calcs();
  578.  if(fmeof()) break;
  579.  if(fmrc()!=NL)
  580.   {
  581.   if(fmnote()<=cur) ++cur;
  582.   fminsc(' ');
  583.   }
  584.  if(fmfnl()) fmgetc();
  585.  else break;
  586.  }
  587. done: fmpoint(cur);
  588. return;
  589. }
  590.  
  591. indentl()
  592. {
  593. TXTSIZ cur=fmnote(),idt,tmp;
  594. if(!setindent()) return;
  595. fmpoint(markb);
  596. while(fmnote()<marke)
  597.  {
  598.  idt=calcs();
  599.  if(fmeof()) break;
  600.  if(fmrc()!=NL) if(!idt) goto done;
  601.  if(fmfnl()) fmgetc();
  602.  else break;
  603.  }
  604. fmpoint(markb);
  605. while(fmnote()<marke)
  606.  {
  607.  calcs();
  608.  if(fmeof()) break;
  609.  if(fmrc()!=NL)
  610.   {
  611.   if(fmnote()<=cur) --cur;
  612.   fmrgetc();
  613.   fmdel(1);
  614.   }
  615.  if(fmfnl()) fmgetc();
  616.  else break;
  617.  }
  618. done: fmpoint(cur);
  619. return;
  620. }
  621.  
  622. struct window *curwin;
  623. struct buffer *curbuf;
  624. struct window *topwin;
  625.  
  626. ldbuf(zuffer)
  627. struct buffer *zuffer;
  628. {
  629. if(zuffer==curbuf) return;
  630. curbuf=zuffer;
  631. backup=zuffer->backup;
  632. strcpy(gfnam,zuffer->gfnam);
  633. bufsiz=zuffer->bufsiz;
  634. buffer=zuffer->buf;
  635. filend=zuffer->filend;
  636. hole=zuffer->hole;
  637. ehole=zuffer->ehole;
  638. changed=zuffer->changed;
  639. }
  640.  
  641. ldbuf1(zuffer)
  642. struct buffer *zuffer;
  643. {
  644. curbuf=zuffer;
  645. backup=zuffer->backup;
  646. strcpy(gfnam,zuffer->gfnam);
  647. bufsiz=zuffer->bufsiz;
  648. buffer=zuffer->buf;
  649. filend=zuffer->filend;
  650. hole=zuffer->hole;
  651. ehole=zuffer->ehole;
  652. changed=zuffer->changed;
  653. }
  654.  
  655. stbuf(zuffer)
  656. struct buffer *zuffer;
  657. {
  658. zuffer->backup=backup;
  659. strcpy(zuffer->gfnam,gfnam);
  660. zuffer->bufsiz=bufsiz;
  661. zuffer->buf=buffer;
  662. zuffer->filend=filend;
  663. zuffer->hole=hole;
  664. zuffer->ehole=ehole;
  665. zuffer->changed=changed;
  666. }
  667.  
  668. ldwin(window)
  669. struct window *window;
  670. {
  671. saddr=window->saddr;
  672. xoffset=window->xoffset;
  673. pic=window->pic;
  674. autoind=window->autoind;
  675. overwrite=window->overwrite;
  676. wrap=window->wrap;
  677. tabmagic=window->tabmagic;
  678. rmargin=window->rmargin;
  679. extend=window->extend;
  680. ldbuf1(window->buffer);
  681. fmpoint(window->cursor);
  682. }
  683.                                    
  684. stwin(window)
  685. struct window *window;
  686. { 
  687. window->saddr=saddr;
  688. window->xoffset=xoffset;
  689. window->pic=pic;
  690. window->autoind=autoind;
  691. window->overwrite=overwrite;
  692. window->wrap=wrap;
  693. window->tabmagic=tabmagic;
  694. window->rmargin=rmargin;
  695. window->extend=extend;
  696. window->cursor=fmnote();
  697. stbuf(window->buffer);
  698. }
  699.  
  700. wfit()
  701. {
  702. struct window *x;
  703. int total;
  704. updall=1;
  705. newy=1;
  706. up:
  707. total=height-wind;
  708. for(x=topwin;1;x=x->next)
  709.  {
  710.  if(x->height<2) x->height=2;
  711.  if(curwin==x && total>=2) break;
  712.  if(total<2) goto in;
  713.  total-=x->height;
  714.  if(total<0)
  715.   {
  716.   in:
  717.   topwin=topwin->next;
  718.   goto up;
  719.   }
  720.  }
  721. for(x=topwin,total=wind;1;x=x->next)
  722.  {
  723.  x->wind=total;
  724.  if(x->height<2) x->height=2;
  725.  total+=x->height;
  726.  if(total>=height || x->next==topwin)
  727.   {
  728.   total-=x->height;
  729.   x->height=height-total;
  730.   return;
  731.   }
  732.  }
  733. }
  734.  
  735. wnext()
  736. {
  737. stwin(curwin);
  738. curwin=curwin->next;
  739. ldwin(curwin);
  740. wfit();
  741. }
  742.  
  743. wprev()
  744. {
  745. stwin(curwin);
  746. curwin=curwin->prev;
  747. ldwin(curwin);
  748. wfit();
  749. }
  750.  
  751. wexplode()
  752. {
  753. struct window *x;
  754. int y;
  755. if(curwin->height!=height-wind)
  756.  { /* Make curwin only */
  757.  topwin=curwin;
  758.  x=topwin;
  759.  do
  760.   {
  761.   x->height=height-wind;
  762.   x->wind=wind;
  763.   x=x->next;
  764.   }
  765.   while(x!=topwin);
  766.  newy=1;
  767.  }
  768. else
  769.  { /* Show all windows */
  770.  x=topwin; y=0;
  771.  do y++, x=x->next; while(x!=topwin);
  772.  if((height-wind)/y<2) y=2;
  773.  else y=(height-wind)/y;
  774.  x=topwin;
  775.  do x->height=y, x=x->next; while(x!=topwin);
  776.  wfit();
  777.  }
  778. }
  779.  
  780. wgrow()
  781. {
  782. if(curwin->wind+curwin->height==height)
  783.  {
  784.  if(curwin->wind!=wind) if(curwin->prev->height>2)
  785.   curwin->prev->height--, curwin->height++, curwin->wind--, updall=1;
  786.  }
  787. else
  788.  {
  789.  if(curwin->next->height>2)
  790.   curwin->height++, curwin->next->wind++, curwin->next->height--, updall=1;
  791.  }
  792. newy=1;
  793. }
  794.  
  795. wshrink()
  796. {
  797. if(curwin->wind+curwin->height==height)
  798.  {
  799.  if(curwin->wind!=wind) if(curwin->height>2)
  800.  curwin->height--, curwin->prev->height++, curwin->wind++, updall=1;
  801.  }
  802. else
  803.  {
  804.  if(curwin->height>2)
  805.  curwin->height--, curwin->next->wind--, curwin->next->height++, updall=1;
  806.  }
  807. newy=1;
  808. }
  809.  
  810. wsplit()
  811. {
  812. struct window *new;
  813. if(curwin->height<4) return;
  814. new=(struct window *)malloc(sizeof(struct window));
  815. new->buffer=curbuf;
  816. stwin(new);
  817. new->next=curwin->next;
  818. new->prev=curwin;
  819. curwin->next->prev=new;
  820. curwin->next=new;
  821. if(curwin->height&1)
  822.  {
  823.  curwin->height/=2;
  824.  new->height=curwin->height+1;
  825.  }
  826. else
  827.  {
  828.  curwin->height/=2;
  829.  new->height=curwin->height;
  830.  }
  831. if(curwin->hheight&1)
  832.  {
  833.  curwin->hheight/=2;
  834.  new->hheight=curwin->hheight+1;
  835.  }
  836. else
  837.  {
  838.  curwin->hheight/=2;
  839.  new->hheight=curwin->hheight;
  840.  }
  841. new->wind=curwin->wind+curwin->height;
  842. curwin=new;
  843. curbuf->count++;
  844. updall=1;
  845. newy=1;
  846. }
  847.  
  848. wedit()
  849. {
  850. unsigned char gfnam1[PATHSIZE];
  851. unsigned char sting[PATHSIZE];
  852. int c;
  853. struct window *x;
  854. stwin(curwin);
  855. if(curbuf->count==1 && curbuf->changed)
  856.  {
  857.  c=askyn("Do you really want to throw away this file?"); 
  858.  if(c=='N') return;
  859.  if(c== -1) return;
  860.  }
  861. gfnam1[0]=0;
  862. if(!getl("File to edit",gfnam1)) return;
  863. fixpath(gfnam1);
  864. x=topwin;
  865. do
  866.  {
  867.  if(!strcmp(gfnam1,x->buffer->gfnam))
  868.   {
  869.   if(curbuf->count==1)
  870.    {
  871.    free(curbuf->buf), free(curbuf);
  872.    if(curbuf==markbuf) markbuf=0;
  873.    }                           
  874.   else 
  875.    curbuf->count--;
  876.   curwin->buffer=x->buffer;
  877.   curwin->buffer->count++;
  878.   ldbuf(x->buffer);
  879.   bof();
  880.   return;
  881.   }
  882.  x=x->next;
  883.  }
  884.  while(x!=topwin);
  885. handle=fopen(gfnam1,"r");
  886. strcpy(gfnam,gfnam1);
  887. stmode(gfnam);
  888. if(curbuf->count==1) free(curbuf->buf),
  889.                              free(curbuf);
  890. else curbuf->count--;
  891. curwin->buffer=(struct buffer *)malloc(sizeof(struct buffer));
  892. curbuf=curwin->buffer;
  893. curbuf->count=1;
  894. fmopen();
  895. bof();
  896. if(handle)
  897.  {
  898.  if(!fminsfil(handle))
  899.   {
  900.   sprintf(sting,"\033[7mError inserting file %s\033[m",gfnam1);
  901.   msg(sting);
  902.   }
  903.  changed=0;
  904.  newy=1;
  905.  fclose(handle);
  906.  }
  907. else
  908.  {
  909.  newy=1;
  910.  upd=1;
  911.  dupdate();
  912.  if(errno==ENOENT)
  913.   {
  914.   eputs("New File\r");
  915.   backup=1;
  916.   }
  917.  else
  918.   eputs("\033[7mError opening file\033[m\r");
  919.  invalidate(curwin->wind+1);
  920.  dokey(anext());
  921.  return;
  922.  }
  923. }
  924.  
  925. rtn()
  926. {
  927. type(NL);
  928. }
  929.  
  930. stquote()
  931. {
  932. quoteflg=1;
  933. }
  934.  
  935. stquote8th()
  936. {
  937. quote8th=1;
  938. }
  939.  
  940. CMD kkm[54]=
  941. {
  942.  {"uparw",0,uuparw},
  943.  {"rtarw",0,urtarw},
  944.  {"ltarw",0,ultarw},
  945.  {"dnarw",0,udnarw},
  946.  {"eol",0,eol},
  947.  {"pgdn",0,pgdn},
  948.  {"bol",0,bol},
  949.  {"pgup",0,pgup},
  950.  {"ctrlin",0,ctrlin},
  951.  {"setbeg",0,setbeg},
  952.  {"cpyblk",0,cpyblk},
  953.  {"saveit",0,saveit},
  954.  {"wedit",0,wedit},
  955.  {"findfirst",0,findfirst},
  956.  {"findnext",0,findnext},
  957.  {"wgrow",0,wgrow},
  958.  {"thelp",0,thelp},
  959.  {"wexplode",0,wexplode},
  960.  {"reformat",0,reformat},
  961.  {"setend",0,setend},
  962.  {"findline",0,findline},
  963.  {"moveblk",0,moveblk},
  964.  {"wnext",0,wnext},
  965.  {"wprev",0,wprev},
  966.  {"wsplit",0,wsplit},
  967.  {"insfil",0,insfil},
  968.  {"wshrink",0,wshrink},
  969.  {"bof",0,bof},
  970.  {"eof",0,eof},
  971.  {"writeblk",0,writeblk},
  972.  {"exsave",0,exsave},
  973.  {"delblk",0,delblk},
  974.  {"push",0,push},
  975.  {"eexit",0,eexit},
  976.  {"delch",0,delch},
  977.  {"inss",0,inss},
  978.  {"backs",0,backs},
  979.  {"type",0,type},
  980.  {"deleol",0,deleol},
  981.  {"rtn",0,rtn},
  982.  {"backword",0,backword},
  983.  {"rewrite",0,rewrite},
  984.  {"mode",0,mode},
  985.  {"killword",0,killword},
  986.  {"wrdr",0,wrdr},
  987.  {"dellin",0,dellin},
  988.  {"wrdl",0,wrdl},
  989.  {"stquote8th",0,stquote8th},
  990.  {"stquote",0,stquote},
  991.  {"gotomatching",0,gotomatching},
  992.  {"indentl",0,indentl},
  993.  {"indentr",0,indentr},
  994.  {"undo",0,undo},
  995.  {"redo",0,redo}
  996.  };
  997.  
  998. CONTEXT km={0, "main", 0, 54, kkm};
  999.  
  1000. /** Key sequence processing functions **/
  1001.  
  1002. struct kmap *curmap;
  1003. int quoteflg=0;
  1004. int quote8th=0;
  1005.  
  1006. int dokey(k)
  1007. unsigned char k;
  1008. {
  1009. int above=curmap->len;
  1010. int below=0;
  1011. int new;
  1012. struct kmap *r;
  1013. if(quoteflg)
  1014.  {
  1015.  quoteflg=0;
  1016.  if(k>='@' && k<='_') k-='@';
  1017.  if(k>='a' && k<='z') k-='`';
  1018.  if(k=='?') k=127;
  1019.  type(k);
  1020.  goto abcd;
  1021.  }
  1022. goto in;
  1023. do
  1024.  {
  1025.  new=(above+below)/2;
  1026.  if((curmap->keys[new].k&KEYMASK)==k)
  1027.   if(curmap->keys[new].k&KEYSUB)
  1028.    {
  1029.    curmap=(KMAP *)(curmap->keys[new].n);
  1030.    return Kaccept;
  1031.    }
  1032.   else
  1033.    {
  1034.    r=curmap;
  1035.    curmap=km.kmap;
  1036.    if(km.cmd[r->keys[new].n].func!=redo &&
  1037.       km.cmd[r->keys[new].n].func!=undo) undoptr=0;
  1038.    km.cmd[r->keys[new].n].func(k);
  1039.    abcd:
  1040.    if(!leave)
  1041.     {
  1042.     if(!uuu) upd=1;
  1043.     else uuu=0;
  1044.     dupdate();
  1045.     }
  1046.    return 0;
  1047.    }
  1048.  else if((curmap->keys[new].k&KEYMASK)>k)
  1049.   {
  1050.   above=new;
  1051.   in:
  1052.   if(above==below) break;
  1053.   }
  1054.  else if(below==new) break;
  1055.  else below=new;
  1056.  } while(1);
  1057. curmap=km.kmap;
  1058. return Kbad;
  1059. }
  1060.  
  1061. edit()
  1062. {
  1063. newy=1;
  1064. dupdate();
  1065. imsg();
  1066. dokey(anext());
  1067. if(leave) return;
  1068. upd=1;
  1069. newy=1;
  1070. do
  1071.  dokey(anext());
  1072.  while(!leave);
  1073. }
  1074.  
  1075. struct mpair
  1076.  {
  1077.  struct mpair *next;
  1078.  unsigned char *s;
  1079.  int wrap;
  1080.  int autoind;
  1081.  int pic;
  1082.  int overwrite;
  1083.  int tabmagic;
  1084.  TXTSIZ rmargin;
  1085.  };
  1086.  
  1087. struct mpair *mpairs=0;
  1088.  
  1089. stmode(name)
  1090. unsigned char *name;
  1091. {
  1092. int x=strlen(name);
  1093. struct mpair *mp=mpairs;
  1094. while(mp)
  1095.  if(!strcmp(mp->s,name+x-strlen(mp->s)))
  1096.   {
  1097.   autoind=mp->autoind;
  1098.   wrap=mp->wrap;
  1099.   overwrite=mp->overwrite;
  1100.   pic=mp->pic;
  1101.   tabmagic=mp->tabmagic;
  1102.   break;
  1103.   }
  1104.  else mp=mp->next;
  1105. }
  1106.  
  1107. int process(name,cmds)
  1108. unsigned char *name;
  1109. CONTEXT *cmds;
  1110. {
  1111. CONTEXT *context=0;
  1112. unsigned char buf[PATHSIZE];
  1113. KMAP *kmap;
  1114. FILE *fd=fopen(name,"r");
  1115. int x,y,n,z;
  1116. if(!fd) return -1;
  1117. printf("Processing keymap file %s ...",name);
  1118. fflush(stdout);
  1119. while(fgets(buf,256,fd))
  1120.  {
  1121.  if(buf[0]=='*')
  1122.   {
  1123.   struct mpair *mp=(struct mpair *)calloc(sizeof(struct mpair),1);
  1124.   int c=0;
  1125.   mp->next=mpairs;
  1126.   mpairs=mp;
  1127.   for(x=0;buf[x];x++)
  1128.    if(buf[x]==' ' || buf[x]=='\t' || buf[x]=='\n')
  1129.     {
  1130.     c=buf[x];
  1131.     buf[x]=0;
  1132.     break;
  1133.     }
  1134.   mp->s=strdupp(buf+1);
  1135.   buf[x]=c;
  1136.   while(buf[x])
  1137.    if(buf[x]!=' ' && buf[x]!='\t' && buf[x]!='\n') break;
  1138.    else x++;
  1139.   while(buf[x] && buf[x]!=' ' && buf[x]!='\t' && buf[x]!='\n')
  1140.    {
  1141.    switch(buf[x])
  1142.     {
  1143.    case 'O':
  1144.    case 'o': mp->overwrite=1;
  1145.    break;
  1146.    case 'W':
  1147.    case 'w': mp->wrap=1;
  1148.    break;
  1149.    case 'a':
  1150.    case 'A': mp->autoind=1;
  1151.    break;
  1152.    case 'p':
  1153.    case 'P': mp->pic=1;
  1154.    break;
  1155.    case 't':
  1156.    case 'T': mp->tabmagic=1;
  1157.     }
  1158.    x++;
  1159.    }
  1160.   continue;
  1161.   }
  1162.  if(buf[0]==':' && buf[1]!=' ' && buf[1]!='\t')
  1163.   {
  1164.   for(x=0;buf[x];x++)
  1165.    if(buf[x]==' ' || buf[x]=='\t' || buf[x]=='\n')
  1166.     {
  1167.     buf[x]=0;
  1168.     break;
  1169.     }
  1170.   context=cmds;
  1171.   while(strcmp(buf+1,context->name))
  1172.    {
  1173.    context=context->next;
  1174.    if(!context)
  1175.     {
  1176.     printf("Unknown context name in keyboard file\n");
  1177.     return -1;
  1178.     }
  1179.    }
  1180.   continue;
  1181.   }
  1182.  for(x=0;buf[x];x++) if(buf[x]==' ' || buf[x]=='\t' || buf[x]=='\n') break;
  1183.  if(buf[0]==' ' || buf[0]=='\t' || buf[0]=='\n' || !buf[x]) continue;
  1184.  if(!context)
  1185.   {
  1186.   printf("No context selected for key\n");
  1187.   return -1;
  1188.   }
  1189.  buf[x]=0;
  1190.  for(y=0;y!=context->size;y++)
  1191.    if(!strcmp(context->cmd[y].name,buf)) goto foundit;
  1192.  printf("Key function not found %s\n",buf);
  1193.  continue;
  1194.  foundit:
  1195.  kmap=0;
  1196.  n= -1;
  1197.  for(++x;buf[x];x++) if(buf[x]!=' ' && buf[x]!='\t') break;
  1198.  while(1)
  1199.   {
  1200.   int c;
  1201.   if(buf[x]==' ') x++;
  1202.   if(!buf[x]) break;
  1203.   if(buf[x]=='\n' || buf[x]==' ' || buf[x]=='\t') break;
  1204.   /* Got Next key */
  1205.   x++;
  1206.   if(buf[x-1]=='^')
  1207.    if(buf[x]==' ' || buf[x]=='\t' || buf[x]=='\n' || !buf[x]) c='^';
  1208.    else if(buf[x]=='?') c=127, x++;
  1209.    else c=(buf[x]&0x1f), x++;
  1210.   else if((buf[x-1]&0x5f)=='S' && (buf[x]&0x5f)=='P') c=' ', x++;
  1211.   else c=buf[x-1];
  1212.   /* Add it as if it were a submap */
  1213.   if(!kmap)
  1214.    {
  1215.    if(!(kmap=context->kmap))
  1216.     {
  1217.     kmap=(KMAP *)malloc(sizeof(KMAP));
  1218.     kmap->keys=(KEY *)malloc(4*sizeof(KEY));
  1219.     kmap->size=4;
  1220.     kmap->len=0;
  1221.     context->kmap=kmap;
  1222.     }
  1223.    }
  1224.   else
  1225.    if(kmap->keys[n].k&KEYSUB) kmap=(KMAP *)(kmap->keys[n].n);
  1226.    else
  1227.     {
  1228.     kmap->keys[n].n=(unsigned)malloc(sizeof(KMAP));
  1229.     kmap->keys[n].k|=KEYSUB;
  1230.     kmap=(KMAP *)(kmap->keys[n].n);
  1231.     kmap->keys=(KEY *)malloc(4*sizeof(KEY));
  1232.     kmap->len=0;
  1233.     kmap->size=4;
  1234.     }
  1235.   for(n=0;n!=kmap->len;n++)
  1236.    if((kmap->keys[n].k&KEYMASK)==c) goto sub;
  1237.    else if((kmap->keys[n].k&KEYMASK)>c) break;
  1238.   if(kmap->len==kmap->size)
  1239.    kmap->keys=(KEY *)realloc(kmap->keys,sizeof(KEY)*(kmap->size+=8));
  1240.   for(z=kmap->len;z!=n;z--) kmap->keys[z]=kmap->keys[z-1];
  1241.   kmap->len++;
  1242.   kmap->keys[n].k=c;
  1243.   kmap->keys[n].n=y;
  1244.   sub:;
  1245.   }
  1246.  }
  1247. fclose(fd);
  1248. printf("done\n");
  1249. return 0;
  1250. }
  1251.  
  1252. int main(argc,argv)
  1253. unsigned char *argv[];
  1254. {
  1255. if(process(KEYMAP,&km))
  1256.  {
  1257.  unsigned char *hh=(unsigned char *)getenv("HOME");
  1258.  if(!hh) goto in;
  1259.  strcpy(gfnam,hh);
  1260.  strcat(gfnam,"/");
  1261.  strcat(gfnam,KEYMAP);
  1262.  if(process(gfnam,&km))
  1263.   {
  1264.   in:
  1265.   if(process(KEYDEF,&km))
  1266.    {
  1267.    printf("Couldn't open keymap\n");
  1268.    return 1;
  1269.    }
  1270.   }
  1271.  }
  1272. curmap=km.kmap;
  1273. if(argc>2)
  1274.  {
  1275.  fputs("\nIllegal number of command line arguments",stderr);
  1276.  fputs("\nEditor Command Format:  e [filename]\n",stderr);
  1277.  return 0;
  1278.  }
  1279. termtype();
  1280. curwin=(struct window *)malloc(sizeof(struct window));
  1281. topwin=curwin;
  1282. curwin->next=curwin;
  1283. curwin->prev=curwin;
  1284. markbuf=0;
  1285. curwin->height=height;
  1286. curwin->wind=0;
  1287. curwin->buffer=(struct buffer *)malloc(sizeof(struct buffer));
  1288. curbuf=curwin->buffer;
  1289. curbuf->count=1;
  1290. aopen();
  1291. dopen();
  1292. fmopen();
  1293. bof();
  1294. options=0;
  1295. sstring[0]=0;
  1296. rstring[0]=0;
  1297. leave=0;
  1298.  
  1299. rmargin=width-2;
  1300. tabmagic=0;
  1301. wrap=1;
  1302. autoind=0;
  1303. overwrite=0;
  1304. pic=0;
  1305. stmode("");
  1306.  
  1307. gfnam[0]=0;
  1308.  
  1309. if(argc==2)
  1310.  {
  1311.  strcpy(gfnam,argv[1]);
  1312.  stmode(gfnam);
  1313.  handle=fopen(argv[1],"r");
  1314.  if(handle)
  1315.   {
  1316.   if(!fminsfil(handle))
  1317.    omsg=(unsigned char *)"\033[7mError reading file\033[m";
  1318.   else
  1319.    changed=0;
  1320.   fclose(handle);
  1321.   }
  1322.  else
  1323.   {
  1324.   if(errno==ENOENT)
  1325.    {
  1326.    omsg=(unsigned char *)"New File";
  1327.    backup=1;
  1328.    }
  1329.   else
  1330.    omsg=(unsigned char *)"\033[7mError opening file\033[m";
  1331.   }
  1332.  }
  1333. else omsg=(unsigned char *)"New File";
  1334. edit();
  1335. aclose();
  1336. return 0;
  1337. }
  1338.  
  1339. tsignal(sig)
  1340. {
  1341. handle=fopen(ABORT,"w+");
  1342. fmpoint(0);
  1343. fmsave(handle,fmsize());
  1344. fclose(handle);
  1345. /*
  1346. aclose();
  1347. printf("\rE aborted by signal %d\r\n",sig);
  1348. printf("Last edit file stored in file called aborted.e\r\n");
  1349. */
  1350. _exit(1);
  1351. }
  1352. @EOF
  1353.  
  1354. chmod 600 j.c
  1355.  
  1356. echo x - j.h
  1357. cat >j.h <<'@EOF'
  1358. /* J editor header file
  1359.    Copyright (C) 1991 Joseph H. Allen
  1360.  
  1361. This file is part of J (Joe's Editor)
  1362.  
  1363. J is free software; you can redistribute it and/or modify it under the terms
  1364. of the GNU General Public License as published by the Free Software
  1365. Foundation; either version 1, or (at your option) any later version. 
  1366.  
  1367. J is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  1368. without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  1369. PARTICULAR PURPOSE.  See the GNU General Public License for more details. 
  1370.  
  1371. You should have received a copy of the GNU General Public License
  1372. along with GNU Emacs; see the file COPYING.  If not, write to
  1373. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  1374.  
  1375. /* File characteristics */
  1376.  
  1377. #define NL '\n'            /* End of line character */
  1378. #define TAB '\t'        /* Tab character */
  1379. #define TABWIDTH 8        /* Tab width */
  1380.  
  1381. /* Types used in the file buffer */
  1382.  
  1383. typedef unsigned char * TXTPTR;    /* Pointer to text in the buffer */
  1384. typedef unsigned TXTSIZ;    /* Integer to hold size of file */
  1385. #define TXTFREE(a) free(a)    /* Free a buffer */
  1386. #define TXTMALLOC(a) malloc(a)    /* Allocate a buffer */
  1387. #define TXTREALLOC(a,b) realloc((a),(b))    /* Reallocate a buffer */
  1388.  
  1389. /* File names and characteristics */
  1390.  
  1391. #define PATHSIZE 256        /* Maximum path length */
  1392. #define KEYMAP "keymap.j"    /* Keymap file */
  1393. /* #define KEYDEF "/usr/bin/keymap.j"    Default keymap file */
  1394. #define ABORT "aborted.j"    /* Aborted file */
  1395.  
  1396. /* The current file buffer */
  1397. /* When you change windows, these variables get stored in the 'struct buffer'
  1398.    associated with the old window and are load with the values in the
  1399.    'struct buffer' for the new window */
  1400.  
  1401. extern TXTSIZ bufsiz;        /* Size of malloc block buffer is in */
  1402. extern TXTPTR point;        /* The point (cursor) */
  1403. extern TXTPTR buffer;        /* The buffer */
  1404. extern TXTPTR filend;        /* First char not in buffer */
  1405. extern TXTPTR hole;        /* Address of hole */
  1406. extern TXTPTR ehole;        /* First char not in hole */
  1407. extern int changed;        /* Set if buffer changed */
  1408. extern int backup;        /* Set if backup file has been made */
  1409. extern unsigned char gfnam[PATHSIZE];
  1410.                 /* Current edit file name.  "" for unnamed */
  1411.  
  1412. #define HOLESIZE 1024        /* Amount file buffer grows by */
  1413.  
  1414. /*******************************************************/
  1415. /* Basic file buffer manipulation functions and macros */
  1416. /*******************************************************/
  1417.  
  1418. fminsu();        /* fminsu(size) Adjust pointers by amnt inserted */
  1419. fmdelu();        /* fmdelu(size) Adjust pointers by amount deleted */ 
  1420. /* The pointers the above two functions currently update include:
  1421.     The pointer to start of each window which references the current
  1422.     buffer.
  1423.  
  1424.     The pointer to cursor in each window which reference the current
  1425.     buffer but not the one for the current window.
  1426.  
  1427.     The begin & end pointers to the marked block if they are in the
  1428.     current buffer.
  1429. */
  1430.  
  1431. /* Return size of hole */
  1432.  
  1433. #define fmholesize() (ehole-hole)
  1434.  
  1435. /* Read character at the point */
  1436.  
  1437. #define fmrc() (point==hole?*(point=ehole):*point)
  1438.  
  1439. /* Overtype character at the point */
  1440.  
  1441. #define fmwc(c) (((point==hole)?point=ehole:0),((point==filend)?(fmexpand(1),\
  1442. filend++):0),*point=(c),changed=1)
  1443.  
  1444. /* Read character at point and advance point */
  1445.  
  1446. #define fmgetc() ((point==hole)?(point=ehole+1,*ehole):*(point++))
  1447.  
  1448. /* Overtype character at point and advance point */
  1449.  
  1450. #define fmputc(c) (((point==hole)?point=ehole:0),((point==filend)?(fmexpand(1),\
  1451. filend++):0),*(point++)=(c),changed=1)
  1452.  
  1453. /* Insert character at point */
  1454.  
  1455. #define fminsc(c) ( fminsu(1), \
  1456. (point!=hole?fmhole():0), (hole==ehole?fmbig(1):0),\
  1457. *(hole++)=(c), changed=1)
  1458.  
  1459. /* Return the byte offset from the beginning of the buffer to the point */
  1460.  
  1461. #define fmnote() ((point>=ehole)?(point-buffer)-(ehole-hole):point-buffer)
  1462.  
  1463. /* Return the size of the file in the buffer */
  1464.  
  1465. #define fmsize() ((filend-buffer)-(ehole-hole))
  1466.  
  1467. /* Return true if the point is at the end of the file */
  1468.  
  1469. #define fmeof() ((point==hole)?(ehole==filend):(point==filend))
  1470.  
  1471. /* Position the point to a byte offset from the beginning of the file */
  1472.  
  1473. #define fmpoint(x) (point=buffer+(x), (point>hole)?(point+=ehole-hole):0)
  1474.  
  1475. /* Retreat the point and then read the character that's there */
  1476.  
  1477. #define fmrgetc() (point==ehole?*(point=hole-1):*(--point))
  1478.  
  1479. /* Position the point to the next NL or the end of the file.  If the point
  1480.    is already at a NL, it is set to the next NL. Return 0 if not found, 1
  1481.    if found */
  1482.  
  1483. #define fmnnl() (fmeof()?0:(fmgetc(),fmfnl()))
  1484.  
  1485. /* Set the point to the beginning of the file or the previous NL.  If the
  1486.    point is already at a NL, it is set to the one before it.  Return 0 if
  1487.    not found, 0 if found */
  1488.  
  1489. #define fmnrnl() (fmnote()?(fmrgetc(),fmrnl()):0)
  1490.  
  1491. fmopen();            /* fmopen() Initialize current edit buffer */
  1492. fmexpand();            /* fmexpand(amount) Make buffer bigger */
  1493. fmhole();            /* fmhole() Move hole to point */
  1494. fmbig();            /* fmbig(size) Make hole at least size */
  1495. int fmfnl();            /* Find first NL.  Returns 0 if not found */
  1496.                 /* If at an NL already, point is not moved */
  1497. int fmrnl();            /* Find NL in reverse.  Rtns 0 if not found */
  1498.                 /* If at an NL already, point is not moved */
  1499. fminss();            /* fminss(blk,size) Insert a block at point */
  1500. int fmcmp();            /* fmcmp(blk,size) return 0 if matching */
  1501. int tupp();            /* tupp(c) Convert char to uppercase */
  1502. int fmicmp();            /* Same as fmcmp but ignore case */
  1503. int fmsave();            /* fmsave(FILE,size) Save at point in file */
  1504. int fminsfil();            /* fminsfil(FILE) Insert file at point */
  1505.  
  1506. /******************/
  1507. /* Terminal stuff */
  1508. /******************/
  1509.  
  1510. /* Terminal characteristics (terminal must be vt100ish) */
  1511.  
  1512. extern int width;        /* Screen width */
  1513. extern int height;        /* Screen height */
  1514. extern int scroll;        /* Set if terminal has scrolling regions */
  1515. termtype();            /* termtype() determine above variables */
  1516.  
  1517. /* Terminal state */
  1518.  
  1519. extern int smode;        /* Current character attributes */
  1520. extern int tops;        /* Scroll region top (-1 for unknown) */
  1521. extern int bots;        /* Scroll region bottem */
  1522. extern int oxpos;        /* Cursor position */
  1523. extern int oypos;
  1524. extern int *scrn;        /* Screen buffer
  1525.                     -1 means unknown character
  1526.                     0 - 255 means known character
  1527.                 */
  1528.  
  1529. extern unsigned char *omsg;    /* Opening message */
  1530. dopen();                        /* Open display (clear it, allocate scrn,
  1531.                    etc.) */
  1532. dclose();                       /* dclose(s) Show final message and close
  1533.                    display */
  1534.  
  1535. cposs();            /* cpos(row,col) Set cursor position */
  1536. cpos();                /* cpos(row,col) Set cursor position and
  1537.                    update ox/oypos */
  1538. setregn();            /* setregn(top,bot) Set scroll region */
  1539.  
  1540. attrib();            /* attrib(mask) Set attributes */
  1541. #define INVERSE 1
  1542. #define BLINK 2
  1543. #define UNDERLINE 4
  1544. #define BOLD 8
  1545.  
  1546. int tattrib();            /* tattrib(c) Set attribute depending on char:
  1547.                     0 - 31        Underlined
  1548.                     32 - 126    Normal
  1549.                     127        Underlined
  1550.                     128 - 255     As above but also
  1551.                             inverse
  1552.                 Returns char to show (ctrl chars converted
  1553.                 to normal)
  1554.                 */
  1555.  
  1556. tputcc();            /* tputcc(c) Set attribute and output char */
  1557. tputss();            /* tputss(s) Use tputcc to output a string */
  1558.  
  1559. /*****************/
  1560. /* Screen update */
  1561. /*****************/
  1562.  
  1563. /* Flags which high-level edit functions set to control the screen
  1564.    update.  All three are initialized to 0 before an edit function
  1565.    is executed */
  1566.  
  1567. extern int uuu;            /* Set is no screen update needed */
  1568. extern int cntr;        /* Set to center cursor to middle of
  1569.                    screen if the screen will scroll
  1570.                    (for search/replace) */
  1571. extern int newy;        /* Set if row changed */
  1572. extern int updall;        /* Set to update all windows, not just
  1573.                    the ones with same buffer */
  1574.  
  1575. /* Flags which indicate the current progress of a screen update (I.E., so
  1576.    we can continue if user interrupts screen update) */
  1577.  
  1578. extern int upd;            /* Set if a screen update should be done */
  1579. extern int hupd;        /* Set if a help update should be done */
  1580.  
  1581. extern int helpon;        /* Set if help screen is on */
  1582. extern int wind;        /* Number of help lines */
  1583.  
  1584. extern int xpos;        /* Requested x & y positions (as determined */
  1585. extern int ypos;        /* by scroll calculator: dupdate1 */
  1586.  
  1587. extern TXTSIZ saddr;        /* Byte offset to first char of first screen
  1588.                    line (of current window) */
  1589. extern TXTSIZ xoffset;        /* Cols current window is scrolled to right */
  1590. extern TXTSIZ extend;        /* Column number if past end of line or in
  1591.                    tab stop */
  1592.  
  1593. /* Help text */
  1594.  
  1595. extern unsigned char help[];    /* Help text */
  1596. #define helplines 9
  1597. #define helpwidth 79
  1598.  
  1599. /* Functions for doing screen update */
  1600.  
  1601. clreolchk();        /* clreolchk(lin,col) Clear to end of line if needed */
  1602. int udline();        /* udline(lin) Update a single line.  Return true
  1603.                EOF reached */
  1604. int udscrn();        /* Update screen (returns true if it finished) */
  1605. dupdate1();        /* dupdate1(flg) Recalculate cursor, scroll & update
  1606.                screen (sets cursor position if flg is set) */
  1607. dupdatehelp();        /* Update help */
  1608. dupdate();        /* Update help and screen */
  1609. invalidate();        /* invalidate(lin) Invalidate a line so it gets upd. */
  1610.  
  1611. /****************/
  1612. /* Window Stuff */
  1613. /****************/
  1614.  
  1615. /* Each file that's edited has a 'struct buffer' associated with it.
  1616.    This stores the buffer variables when the buffer is not the current
  1617.    buffer (I.E., when the cursor is in a window for another file).
  1618. */
  1619.  
  1620. struct buffer
  1621.  {
  1622.  int count;        /* Reference count (No. windows into this buffer) */
  1623.  TXTSIZ bufsiz;        /* Size of malloc block buffer is in */
  1624.  TXTPTR buf;        /* The buffer */
  1625.  TXTPTR filend;        /* First char not in buffer */
  1626.  TXTPTR hole;        /* Address of hole */
  1627.  TXTPTR ehole;        /* First char not in hole */
  1628.  int changed;        /* Set if buffer changed */
  1629.  int backup;        /* Set if backup file has been made */
  1630.  unsigned char gfnam[PATHSIZE];    /* Current edit file name.  "" for unnamed */
  1631.  };
  1632.  
  1633. /* Each window has a 'struct window' associated with it */
  1634.  
  1635. struct window
  1636.  {
  1637.  struct window *next;    /* Doubly linked list of windows */
  1638.  struct window *prev;
  1639.  
  1640.  struct buffer *buffer;    /* The buffer this window looks at */
  1641.  
  1642.  /* Screen variables for each window */
  1643.  
  1644.  TXTSIZ saddr;        /* Byte offset to first character of first line in
  1645.                 window */
  1646.  TXTSIZ xoffset;    /* No. columns the screen is scrolled to the right */
  1647.  
  1648.  /* Window size */
  1649.  
  1650.  int wind;         /* Starting screen line */
  1651.             /* wind is not the same as 'wind' the number of
  1652.                help lines */
  1653.  int height;       /* Height of window */
  1654.  int hheight;      /* Height before help turned on */
  1655.  
  1656.  /* Edit modes */
  1657.  
  1658.  int pic;
  1659.  int autoind;
  1660.  int overwrite;
  1661.  int wrap;
  1662.  int tabmagic;
  1663.  TXTSIZ rmargin;
  1664.  
  1665.  /* Cursor position */
  1666.  
  1667.  TXTSIZ extend;        /* Column number if cursor is past end of line or
  1668.                 if it's in a tab stop */
  1669.  TXTSIZ cursor;        /* Byte offset (in buffer) to the cursor */
  1670.  
  1671.  };
  1672.  
  1673. extern struct window *wfirst;    /* Doubly linked list of windows */
  1674. extern struct window *wlast;
  1675.  
  1676. extern struct window *curwin;    /* Current window */
  1677. extern struct buffer *curbuf;    /* Current buffer */
  1678. extern struct window *topwin;    /* First window on the screen */
  1679.  
  1680. /* Keyboard and command table handler */
  1681.  
  1682. typedef struct key KEY;
  1683. struct key
  1684.  {
  1685.  int k;                 /* Key value */
  1686.  int n;                 /* Command number or submap address */
  1687.             /* sizeof(int) had better = sizeof(KMAP *) */
  1688.  };
  1689.  
  1690. typedef struct kmap KMAP;
  1691. struct kmap
  1692.  {
  1693.  int len;          /* Number of KEY entries */
  1694.  int size;         /* Size of malloc block */
  1695.  KEY *keys;             /* KEYs.  Sorted. */
  1696.  };
  1697.  
  1698. /* Masks & bits for k */
  1699.  
  1700. #define KEYMASK 0x7fff
  1701. #define KEYSUB 0x8000    /* Set for submap */
  1702.  
  1703. /* A command entry */
  1704.  
  1705. typedef struct cmd CMD;
  1706. struct cmd
  1707.  {
  1708.  char *name;
  1709.  int flag;
  1710.  int (*func)();
  1711.  };
  1712.  
  1713. /* A context (group of related commands) */
  1714.  
  1715. typedef struct context CONTEXT;
  1716. struct context
  1717.  {
  1718.  CONTEXT *next;        /* List of all contexts */
  1719.  char *name;            /* Name of this context */
  1720.  KMAP *kmap;        /* Top level keymap for this context */
  1721.  int size;        /* Number of entries in this context */
  1722.  CMD *cmd;        /* The entries themselves (sorted) */
  1723.  };
  1724.  
  1725. int dokey();        /* dokey(c) Execute next key */
  1726. extern int quoteflg;    /* Set if next key is quoted */
  1727. extern int quote8th;    /* Set if next key is quoted */
  1728.  
  1729. /* dokey() Return values */
  1730.  
  1731. #define Kaccept -1    /* Key accepted but not executed */
  1732. #define Kbad -2        /* Bad key */
  1733. /* dokey() used to return a function number; now it executes the function
  1734.    itself so the return values are meaningless */
  1735.  
  1736. /* Messages and queries */
  1737.  
  1738. /* These are all hacks because they return/check for exact key values
  1739.    and don't know about the key table.  Someday a key 'context' should
  1740.    be added for these
  1741. */
  1742.  
  1743. int getl();        /* getl(prompt,line) Get a line of input */
  1744.             /* Returns: -1 if user hits ^L
  1745.                      1 if user hits \n or \r
  1746.                      0 if user hits ^C
  1747.                 (yes this is a stupid hack)
  1748.             */
  1749.  
  1750. msg();            /* msg(s) Show a message until user hits a key */
  1751.  
  1752. int askyn();        /* askyn(s) Yes/No question 
  1753.             Returns: 'Y', 'N' or -1 for ^C */
  1754.  
  1755. int query();        /* query(s) Show message, wait for user to hit a key,
  1756.                then return key. */
  1757.  
  1758. int nquery();        /* nquery(s) Same as query but leave cursor on
  1759.                edit screen */
  1760. imsg();                 /* imsg() Show opening message */
  1761.  
  1762. /*******************************************/
  1763. /* High-level edit functions and variables */
  1764. /*******************************************/
  1765.  
  1766. /* Edit modes */
  1767.  
  1768. extern int pic;            /* Set for picture mode */
  1769. extern int autoind;        /* Set for autoindent */
  1770. extern int overwrite;        /* Set for overwrite */
  1771. extern int wrap;        /* Set for autowrap */
  1772. extern int tabmagic;        /* Set for magical tabs */
  1773. extern TXTSIZ rmargin;        /* Current right margin */
  1774.  
  1775. /****************************/
  1776. /* Search and replace stuff */
  1777. /****************************/
  1778.  
  1779. /* Search & replace options */
  1780.  
  1781. #define s_ignore 1        /* Ignore case */
  1782. #define s_backwards 2        /* Search backwards */
  1783. #define s_replace 4        /* Replace */
  1784. #define s_regex 8        /* Regular expression search */
  1785.  
  1786. extern int options;        /* Search options */
  1787. extern unsigned char sstring[PATHSIZE];    /* Search string */
  1788. extern unsigned char rstring[PATHSIZE];    /* Replace string */
  1789. extern int len;            /* Length of search string */
  1790.  
  1791. /**********/
  1792. /* Blocks */
  1793. /**********/
  1794.  
  1795. extern TXTSIZ markb;        /* Begining of block */
  1796. extern TXTSIZ marke;        /* End of block */
  1797. extern struct buffer *markbuf;    /* Buffer block is in or 0 for no block */
  1798.  
  1799. /**************************************/
  1800. /* High level edit function utilities */
  1801. /**************************************/
  1802.  
  1803. extern int leave;        /* Edit function sets this to leave the editor
  1804.                    after the function returns */
  1805.  
  1806. dnarw();            /* Move cursor to next line */
  1807.                 /* Column number is preserved */
  1808. TXTSIZ calcs();            /* Calculate number of whitespace columns
  1809.                    at beginning of line.  Cursor is left
  1810.                    at first non-whitespace character */
  1811. int saveit1();            /* saveit1(s) Save buffer in file & clear
  1812.                    changed */
  1813. itype();
  1814. ltarw();            /* Move cursor left (goes to end of previous
  1815.                    line if at beginning of line) */
  1816. uparw();            /* Move cursor up (preserves column) */
  1817. rtarw();                        /* Move cursor right (goes to beginning of
  1818.                    next line if at end of line) */
  1819.  
  1820. /* Return current column number of cursor */
  1821.  
  1822. #define getcol() (extend?extend:getrcol())
  1823.  
  1824. TXTSIZ getrcol();        /* Get column number of point */
  1825. gocol();            /* gocol(col) Set cursor (point/extend) to
  1826.                    column number */
  1827. unfill();            /* Remove trailing spaces from line */
  1828. fillup();                       /* Fill to extend position (use this only
  1829.                    if extend if past end of line, not for
  1830.                    if extend is in tab stop) */
  1831.  
  1832. int search();            /* Execute a search.  Returns 1 if found,
  1833.                    0 if not */
  1834.  
  1835. /* Window functions */
  1836.  
  1837. ldwin();            /* ldwin(window) load window */
  1838. stwin();            /* stwin(window) save window */
  1839. ldbuf();            /* ldbuf(buf) load buf if it's not already */
  1840. ldbuf1();            /* ldbuf1(buf) load buf always */
  1841. stbuf();            /* stbuf(buf) store buffer */
  1842. wfit();                /* make sure the current window is on screen */
  1843.  
  1844. /* High Level (user) edit functions */
  1845.  
  1846. wnext();            /* goto next window */
  1847. wprev();            /* goto previous window */
  1848. wexplode();            /* show 1 or all windows */
  1849. wgrow();            /* make window bigger */
  1850. wshrink();            /* make window smaller */
  1851. wedit();            /* edit a new file */
  1852. wsplit();            /* Split window into 2 */
  1853.  
  1854. rewrite();            /* Rewrite screen */
  1855. thelp();            /* Toggle help screen */
  1856. bof();                /* Goto beginning of file */
  1857. eof();                /* Goto end of file */
  1858. bol();                /* Goto beginning of line */
  1859. eol();                /* Goto end of line */
  1860. urtarw();            /* Move cursor right (scroll if need to) */
  1861. ultarw();
  1862. uuparw();
  1863. udnarw();
  1864. delch();            /* Delete character */
  1865. type();                /* type(c) type a character */
  1866. inss();                /* insert a space */
  1867. backs();            /* backspace */
  1868. eexit();            /* Exit & abort */
  1869. pgup();                /* 1/2 Page up */
  1870. pgdn();                /* 1/2 Page down */
  1871. deleol();            /* Erase end of line */
  1872. dellin();            /* Erase entire line */
  1873. exsave();            /* Save and exit */
  1874. saveit();            /* Save current file */
  1875. findline();            /* Goto line No. */
  1876. findfirst();            /* Find some text */
  1877. findnext();            /* Find next occurance */
  1878. setbeg();            /* Set beginning of block */
  1879. setend();            /* Set end of block */
  1880. writeblk();            /* Write block to file */
  1881. moveblk();            /* Move block to point */
  1882. cpyblk();            /* Copy block to point */
  1883. delblk();            /* Delete block */
  1884. insfil();            /* Insert a file */
  1885. push();                /* Execute a shell */
  1886. mode();                /* Change edit mode */
  1887. ctrlin();            /* Center current line */
  1888. reformat();            /* Reformat current paragraph */
  1889. killword();            /* Delete word */
  1890. backword();            /* Delete word to the left */
  1891. wrdl();                /* goto previous word */
  1892. wrdr();                /* goto next word */
  1893. edit();                /* Main edit loop */
  1894.  
  1895. extern FILE *handle;        /* File handle used for many various things */
  1896. extern TXTSIZ added;        /* Number of chars autoindent added
  1897.                 (obsolete?) */
  1898.  
  1899. /* Portable strdup() */
  1900.  
  1901. #define strdupp(x) ((unsigned char *)strcpy((unsigned char *)malloc(strlen(x)+1),(x)))
  1902. @EOF
  1903.  
  1904. chmod 600 j.h
  1905.  
  1906. echo x - keymapbsd
  1907. cat >keymapbsd <<'@EOF'
  1908.  
  1909.                               Key map for e editor
  1910.  
  1911.  E looks for this file in:
  1912.         1 - Current directory
  1913.         2 - User's home directory
  1914.         3 - /usr/bin
  1915.  
  1916.  ******************************************************************************
  1917.  * Notes about keymap syntax:                                                 *
  1918.  *                                                                            *
  1919.  * Any line beginning with whitespace is a comment line.  At least 2          *
  1920.  * characters of whitespace past the end of definition line also begin a      *
  1921.  * comment.                                                                   *
  1922.  *                                                                            *
  1923.  * There are two types of lines as follows:                                   *
  1924.  *                                                                            *
  1925.  * :<context>                   This gives the name of a context.  Bindings   *
  1926.  *                              following this line are added into this       *
  1927.  *                              context.                                      *
  1928.  *                                                                            *
  1929.  * <function> <key> <key> ...   This binds a key sequence to a function       *
  1930.  *                                                                            *
  1931.  * <key> is any single character or                                           *
  1932.  * sp    for space or                                                         *
  1933.  * ^     followed by characters in the range @ - _ for control characters or  *
  1934.  * ^?    for del                                                              *
  1935.  *                                                                            *
  1936.  * Any number of whitespace characters may appear between <function> and the  *
  1937.  * first <key>, but there must be single spaces between <key>s.               *
  1938.  *                                                                            *
  1939.  ******************************************************************************
  1940.  
  1941.  File name dependant mode settings
  1942.  
  1943.    a   autoindent (indent)
  1944.    o   overwrite  (insert)
  1945.    p   picture mode (no picture mode)
  1946.    w   word wrap (no word wrap)
  1947.    t   tab magic (no tab magic)
  1948.  
  1949.  Note that when there ambiguities (extensions which begin the same), the last
  1950.  one is chosen.
  1951.  
  1952. *       wt              Default for unknown extensions.  This must be first
  1953. *.c     at              C programs
  1954. *.h     at              C header files
  1955. *.p     at              Pascal programs
  1956. *.f     at              Fortran programs
  1957. *.e     at              This file
  1958.  
  1959.  For the E editor there is currently only one context:
  1960.  
  1961. :main
  1962.  
  1963. backs           ^H              Backspace
  1964. backs        ^?
  1965. backword        ^O              Backspace word
  1966. bof             ^K U            Move cursor to beginning of file
  1967. bof             ^K ^U
  1968. bof             ^K u
  1969. bol             ^A              Move cursor to beginning of line
  1970. bol             ^[ [ H
  1971. bol        ^K ^[ [ H
  1972. bol        ^[ O P
  1973. bol        ^K ^[ O P
  1974. cpyblk          ^K C            Copy previously marked block
  1975. cpyblk          ^K ^C
  1976. cpyblk          ^K c
  1977. ctrlin          ^K A            Center line
  1978. ctrlin          ^K ^A
  1979. ctrlin          ^K a
  1980. delblk          ^K Y            Delete previously marked block
  1981. delblk          ^K ^Y
  1982. delblk          ^K y
  1983. delch           ^D        Delete character
  1984. deleol          ^J              Delete to end of line
  1985. dellin          ^Y              Delete entire line
  1986. dnarw           ^N              Move cursor down
  1987. dnarw           ^[ [ B
  1988. dnarw        ^[ O B
  1989. dnarw        ^K ^[ [ B
  1990. dnarw        ^K ^[ O B
  1991. eexit           ^C              Exit (window/file)
  1992. eexit           ^K Q
  1993. eexit           ^K q
  1994. eof             ^K V            Move cursor to end of file
  1995. eof             ^K ^V
  1996. eof             ^K v
  1997. eol             ^E              Move cursor to end of line
  1998. eol             ^[ [ F
  1999. eol        ^K ^[ [ F
  2000. eol        ^[ O S
  2001. eol        ^K ^[ O S
  2002. exsave          ^K X            Save & exit
  2003. exsave          ^K ^X
  2004. exsave          ^K x
  2005. findfirst       ^K F            Find text
  2006. findfirst       ^K ^F
  2007. findfirst       ^K f
  2008. findnext        ^L              Find next
  2009. findline        ^K L            Goto line number
  2010. findline        ^K ^L
  2011. findline        ^K l
  2012. gotomatching    ^G
  2013. indentl        ^K ,        Indent left
  2014. indentr        ^K .        Indent right
  2015. insfil          ^K R            Insert a file
  2016. insfil          ^K ^R
  2017. insfil          ^K r
  2018.  inss            ^G              Insert a space
  2019. inss            ^[ [ L
  2020. inss        ^K ^[ [ L
  2021. killword        ^W              Delete word under cursor
  2022. ltarw           ^B              Move cursor left
  2023. ltarw           ^[ [ D
  2024. ltarw        ^K ^[ [ D
  2025. ltarw        ^[ O D
  2026. ltarw        ^K ^[ O D
  2027. mode            ^T              Change mode
  2028. moveblk         ^K M            Move previously marked block
  2029. moveblk         ^K ^M
  2030. moveblk         ^K m
  2031. pgdn            ^V              Move cursor 1/2 page down
  2032. pgdn            ^[ [ G
  2033. pgdn        ^K ^[ [ G
  2034. pgdn            ^[ [ 6 ~
  2035. pgdn        ^K ^[ [ 6 ~
  2036. pgup            ^U              Move curosr 1/2 page up
  2037. pgup            ^[ [ I
  2038. pgup        ^K ^[ [ I
  2039. pgup        ^[ [ 5 ~
  2040. pgup        ^K ^[ [ 5 ~
  2041. push            ^K Z            Push to a shell
  2042. push            ^K ^Z
  2043. push            ^K z
  2044. redo        ^K +        Redo
  2045. reformat        ^K J            Reformat paragraph
  2046. reformat        ^K ^J
  2047. reformat        ^K j
  2048. rewrite         ^R              Retype screen
  2049. rtarw           ^F              Move cursor right
  2050. rtarw           ^[ [ C
  2051. rtarw        ^K ^[ [ C
  2052. rtarw        ^[ O C
  2053. rtarw        ^K ^[ O C
  2054. rtn             ^M              The return key
  2055. saveit          ^K D            Save file
  2056. saveit          ^K ^D
  2057. saveit          ^K d
  2058. saveit          ^K S
  2059. saveit          ^K s
  2060. setbeg          ^K B            Set beginning of block
  2061. setbeg          ^K ^B
  2062. setbeg          ^K b
  2063. setend          ^K K            Set end of block
  2064. setend          ^K ^K
  2065. setend          ^K k
  2066. stquote         `               Next character is a control character
  2067. stquote8th      ^\              Next character has 7th bit set
  2068. thelp           ^K H            Toggle help screen on/off
  2069. thelp           ^K ^H
  2070. thelp           ^K h
  2071. thelp           ^[ [ 2 8 ~
  2072. thelp        ^K ^[ [ 2 8 ~
  2073. undo        ^K -        Undelete
  2074. uparw           ^P              Move cursor up
  2075. uparw           ^[ [ A
  2076. uparw        ^K ^[ [ A
  2077. uparw        ^[ O A
  2078. uparw        ^K ^[ O A
  2079. wedit           ^K E            Edit another file
  2080. wedit           ^K ^E
  2081. wedit           ^K e
  2082. wexplode        ^K I            Zoom window
  2083. wexplode        ^K ^I
  2084. wexplode        ^K i
  2085. wgrow           ^K G            Grow window
  2086. wgrow           ^K ^G
  2087. wgrow           ^K g
  2088. wnext           ^K N            Goto next window
  2089. wnext           ^K ^N
  2090. wnext           ^K n
  2091. wprev           ^K P            Goto previous window
  2092. wprev           ^K ^P
  2093. wprev           ^K p
  2094. wrdl            ^Z              Move to previous word
  2095. wrdl        ^[ O Q
  2096. wrdl        ^K ^[ O Q
  2097. wrdr            ^X              Move to next word
  2098. wrdr        ^[ O R
  2099. wrdr        ^K ^[ O R
  2100. writeblk        ^K W            Write previously marked block to a file
  2101. writeblk        ^K ^W
  2102. writeblk        ^K w
  2103. wshrink         ^K T            Shrink window
  2104. wshrink         ^K ^T
  2105. wshrink         ^K t
  2106. wsplit          ^K O            Split window
  2107. wsplit          ^K ^O
  2108. wsplit          ^K o
  2109.  
  2110. type            ^I              Tab
  2111.  
  2112. type            sp              Typable characters
  2113. type            !
  2114. type            "
  2115. type            #       
  2116. type            $
  2117. type            %
  2118. type            &
  2119. type            '
  2120. type            (
  2121. type            )
  2122. type            *
  2123. type            +
  2124. type            ,
  2125. type            -
  2126. type            .
  2127. type            /
  2128. type            0
  2129. type            1
  2130. type            2
  2131. type            3
  2132. type            4
  2133. type            5
  2134. type            6
  2135. type            7
  2136. type            8
  2137. type            9
  2138. type            :
  2139. type            ;
  2140. type            <
  2141. type            =
  2142. type            >
  2143. type            ?
  2144. type            @
  2145. type            A
  2146. type            B
  2147. type            C
  2148. type            D
  2149. type            E
  2150. type            F
  2151. type            G
  2152. type            H
  2153. type            I
  2154. type            J
  2155. type            K
  2156. type            L
  2157. type            M
  2158. type            N
  2159. type            O
  2160. type            P
  2161. type            Q
  2162. type            R
  2163. type            S
  2164. type            T
  2165. type            U
  2166. type            V
  2167. type            W
  2168. type            X
  2169. type            Y
  2170. type            Z
  2171. type            [
  2172. type            \
  2173. type            ]
  2174. type            ^
  2175. type            _
  2176. type            a
  2177. type            b
  2178. type            c
  2179. type            d
  2180. type            e
  2181. type            f
  2182. type            g
  2183. type            h
  2184. type            i
  2185. type            j
  2186. type            k
  2187. type            l
  2188. type            m
  2189. type            n
  2190. type            o
  2191. type            p
  2192. type            q
  2193. type            r
  2194. type            s
  2195. type            t
  2196. type            u
  2197. type            v
  2198. type            w
  2199. type            x
  2200. type            y
  2201. type            z
  2202. type            {
  2203. type            |
  2204. type            }
  2205. type            ~
  2206. @EOF
  2207.  
  2208. chmod 600 keymapbsd
  2209.  
  2210. echo x - keymapxenix
  2211. cat >keymapxenix <<'@EOF'
  2212.  
  2213.                               Key map for e editor
  2214.  
  2215.  E looks for this file in:
  2216.         1 - Current directory
  2217.         2 - User's home directory
  2218.         3 - /usr/bin
  2219.  
  2220.  ******************************************************************************
  2221.  * Notes about keymap syntax:                                                 *
  2222.  *                                                                            *
  2223.  * Any line beginning with whitespace is a comment line.  At least 2          *
  2224.  * characters of whitespace past the end of definition line also begin a      *
  2225.  * comment.                                                                   *
  2226.  *                                                                            *
  2227.  * There are two types of lines as follows:                                   *
  2228.  *                                                                            *
  2229.  * :<context>                   This gives the name of a context.  Bindings   *
  2230.  *                              following this line are added into this       *
  2231.  *                              context.                                      *
  2232.  *                                                                            *
  2233.  * <function> <key> <key> ...   This binds a key sequence to a function       *
  2234.  *                                                                            *
  2235.  * <key> is any single character or                                           *
  2236.  * sp    for space or                                                         *
  2237.  * ^     followed by characters in the range @ - _ for control characters or  *
  2238.  * ^?    for del                                                              *
  2239.  *                                                                            *
  2240.  * Any number of whitespace characters may appear between <function> and the  *
  2241.  * first <key>, but there must be single spaces between <key>s.               *
  2242.  *                                                                            *
  2243.  ******************************************************************************
  2244.  
  2245.  File name dependant mode settings
  2246.  
  2247.    a   autoindent (indent)
  2248.    o   overwrite  (insert)
  2249.    p   picture mode (no picture mode)
  2250.    w   word wrap (no word wrap)
  2251.    t   tab magic (no tab magic)
  2252.  
  2253.  Note that when there ambiguities (extensions which begin the same), the last
  2254.  one is chosen.
  2255.  
  2256. *       wt              Default for unknown extensions.  This must be first
  2257. *.c     at              C programs
  2258. *.h     at              C header files
  2259. *.p     at              Pascal programs
  2260. *.f     at              Fortran programs
  2261. *.e     at              This file
  2262.  
  2263.  For the E editor there is currently only one context:
  2264.  
  2265. :main
  2266.  
  2267. backs           ^H              Backspace
  2268.  backs        ^?        Not on xenix console
  2269. backword        ^O              Backspace word
  2270. bof             ^K U            Move cursor to beginning of file
  2271. bof             ^K ^U
  2272. bof             ^K u
  2273. bol             ^A              Move cursor to beginning of line
  2274. bol             ^[ [ H
  2275. bol        ^K ^[ [ H
  2276. bol        ^[ O P
  2277. bol        ^K ^[ O P
  2278. cpyblk          ^K C            Copy previously marked block
  2279. cpyblk          ^K ^C
  2280. cpyblk          ^K c
  2281. ctrlin          ^K A            Center line
  2282. ctrlin          ^K ^A
  2283. ctrlin          ^K a
  2284. delblk          ^K Y            Delete previously marked block
  2285. delblk          ^K ^Y
  2286. delblk          ^K y
  2287. delch           ^D        Delete character
  2288. delch        ^?        On xenix consol
  2289. deleol          ^J              Delete to end of line
  2290. dellin          ^Y              Delete entire line
  2291. dnarw           ^N              Move cursor down
  2292. dnarw           ^[ [ B
  2293. dnarw        ^[ O B
  2294. dnarw        ^K ^[ [ B
  2295. dnarw        ^K ^[ O B
  2296. eexit           ^C              Exit (window/file)
  2297. eexit           ^K Q
  2298. eexit           ^K q
  2299. eof             ^K V            Move cursor to end of file
  2300. eof             ^K ^V
  2301. eof             ^K v
  2302. eol             ^E              Move cursor to end of line
  2303. eol             ^[ [ F
  2304. eol        ^K ^[ [ F
  2305. eol        ^[ O S
  2306. eol        ^K ^[ O S
  2307. exsave          ^K X            Save & exit
  2308. exsave          ^K ^X
  2309. exsave          ^K x
  2310. findfirst       ^K F            Find text
  2311. findfirst       ^K ^F
  2312. findfirst       ^K f
  2313. findnext        ^L              Find next
  2314. findline        ^K L            Goto line number
  2315. findline        ^K ^L
  2316. findline        ^K l
  2317. gotomatching    ^G
  2318. indentl        ^K ,        Indent left
  2319. indentr        ^K .        Indent right
  2320. insfil          ^K R            Insert a file
  2321. insfil          ^K ^R
  2322. insfil          ^K r
  2323.  inss            ^G              Insert a space
  2324. inss            ^[ [ L
  2325. inss        ^K ^[ [ L
  2326. killword        ^W              Delete word under cursor
  2327. ltarw           ^B              Move cursor left
  2328. ltarw           ^[ [ D
  2329. ltarw        ^K ^[ [ D
  2330. ltarw        ^[ O D
  2331. ltarw        ^K ^[ O D
  2332. mode            ^T              Change mode
  2333. moveblk         ^K M            Move previously marked block
  2334. moveblk         ^K ^M
  2335. moveblk         ^K m
  2336. pgdn            ^V              Move cursor 1/2 page down
  2337. pgdn            ^[ [ G
  2338. pgdn        ^K ^[ [ G
  2339. pgdn            ^[ [ 6 ~
  2340. pgdn        ^K ^[ [ 6 ~
  2341. pgup            ^U              Move curosr 1/2 page up
  2342. pgup            ^[ [ I
  2343. pgup        ^K ^[ [ I
  2344. pgup        ^[ [ 5 ~
  2345. pgup        ^K ^[ [ 5 ~
  2346. push            ^K Z            Push to a shell
  2347. push            ^K ^Z
  2348. push            ^K z
  2349. redo        ^K +        Redo
  2350. reformat        ^K J            Reformat paragraph
  2351. reformat        ^K ^J
  2352. reformat        ^K j
  2353. rewrite         ^R              Retype screen
  2354. rtarw           ^F              Move cursor right
  2355. rtarw           ^[ [ C
  2356. rtarw        ^K ^[ [ C
  2357. rtarw        ^[ O C
  2358. rtarw        ^K ^[ O C
  2359. rtn             ^M              The return key
  2360. saveit          ^K D            Save file
  2361. saveit          ^K ^D
  2362. saveit          ^K d
  2363. saveit          ^K S
  2364. saveit          ^K s
  2365. setbeg          ^K B            Set beginning of block
  2366. setbeg          ^K ^B
  2367. setbeg          ^K b
  2368. setend          ^K K            Set end of block
  2369. setend          ^K ^K
  2370. setend          ^K k
  2371. stquote         `               Next character is a control character
  2372. stquote8th      ^\              Next character has 7th bit set
  2373. thelp           ^K H            Toggle help screen on/off
  2374. thelp           ^K ^H
  2375. thelp           ^K h
  2376. thelp           ^[ [ 2 8 ~
  2377. thelp        ^K ^[ [ 2 8 ~
  2378. undo        ^K -        Undelete
  2379. uparw           ^P              Move cursor up
  2380. uparw           ^[ [ A
  2381. uparw        ^K ^[ [ A
  2382. uparw        ^[ O A
  2383. uparw        ^K ^[ O A
  2384. wedit           ^K E            Edit another file
  2385. wedit           ^K ^E
  2386. wedit           ^K e
  2387. wexplode        ^K I            Zoom window
  2388. wexplode        ^K ^I
  2389. wexplode        ^K i
  2390. wgrow           ^K G            Grow window
  2391. wgrow           ^K ^G
  2392. wgrow           ^K g
  2393. wnext           ^K N            Goto next window
  2394. wnext           ^K ^N
  2395. wnext           ^K n
  2396. wprev           ^K P            Goto previous window
  2397. wprev           ^K ^P
  2398. wprev           ^K p
  2399. wrdl            ^Z              Move to previous word
  2400. wrdl        ^[ O Q
  2401. wrdl        ^K ^[ O Q
  2402. wrdr            ^X              Move to next word
  2403. wrdr        ^[ O R
  2404. wrdr        ^K ^[ O R
  2405. writeblk        ^K W            Write previously marked block to a file
  2406. writeblk        ^K ^W
  2407. writeblk        ^K w
  2408. wshrink         ^K T            Shrink window
  2409. wshrink         ^K ^T
  2410. wshrink         ^K t
  2411. wsplit          ^K O            Split window
  2412. wsplit          ^K ^O
  2413. wsplit          ^K o
  2414.  
  2415. type            ^I              Tab
  2416.  
  2417. type            sp              Typable characters
  2418. type            !
  2419. type            "
  2420. type            #       
  2421. type            $
  2422. type            %
  2423. type            &
  2424. type            '
  2425. type            (
  2426. type            )
  2427. type            *
  2428. type            +
  2429. type            ,
  2430. type            -
  2431. type            .
  2432. type            /
  2433. type            0
  2434. type            1
  2435. type            2
  2436. type            3
  2437. type            4
  2438. type            5
  2439. type            6
  2440. type            7
  2441. type            8
  2442. type            9
  2443. type            :
  2444. type            ;
  2445. type            <
  2446. type            =
  2447. type            >
  2448. type            ?
  2449. type            @
  2450. type            A
  2451. type            B
  2452. type            C
  2453. type            D
  2454. type            E
  2455. type            F
  2456. type            G
  2457. type            H
  2458. type            I
  2459. type            J
  2460. type            K
  2461. type            L
  2462. type            M
  2463. type            N
  2464. type            O
  2465. type            P
  2466. type            Q
  2467. type            R
  2468. type            S
  2469. type            T
  2470. type            U
  2471. type            V
  2472. type            W
  2473. type            X
  2474. type            Y
  2475. type            Z
  2476. type            [
  2477. type            \
  2478. type            ]
  2479. type            ^
  2480. type            _
  2481. type            a
  2482. type            b
  2483. type            c
  2484. type            d
  2485. type            e
  2486. type            f
  2487. type            g
  2488. type            h
  2489. type            i
  2490. type            j
  2491. type            k
  2492. type            l
  2493. type            m
  2494. type            n
  2495. type            o
  2496. type            p
  2497. type            q
  2498. type            r
  2499. type            s
  2500. type            t
  2501. type            u
  2502. type            v
  2503. type            w
  2504. type            x
  2505. type            y
  2506. type            z
  2507. type            {
  2508. type            |
  2509. type            }
  2510. type            ~
  2511. @EOF
  2512.  
  2513. chmod 600 keymapxenix
  2514.  
  2515. exit 0
  2516. -- Cut here
  2517. -- 
  2518. /*  rcarter@wpi.wpi.edu */      /* Amazing */             /* Joseph H. Allen */
  2519. int a[1817];main(z,p,q,r){for(p=80;q+p-80;p-=2*a[p])for(z=9;z--;)q=3&(r=time(0)
  2520. +r*57)/7,q=q?q-1?q-2?1-p%79?-1:0:p%79-77?1:0:p<1659?79:0:p>158?-79:0,q?!a[p+q*2
  2521. ]?a[p+=a[p+=q]=q]=q:0:0;for(;q++-1817;)printf(q%79?"%c":"%c\n"," #"[!a[q-1]]);}
  2522.