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