home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 0 / 0979 / browse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-28  |  20.0 KB  |  1,184 lines
  1. /*             -- Just what the hell am I ??? ---                            */
  2. /* (If this is made from MAKEFILE, BSD or USG should be set.) */
  3.  
  4. #include <stdio.h>
  5.  
  6. #include "system.h"
  7.  
  8. /*         -- Miscellaneous include files --                     */
  9.  
  10. #include <sys/param.h>            /* NCARGS, and others */
  11. #ifndef M_XENIX
  12. # include <sys/types.h>                       /* data types for various files */
  13. #endif
  14. #include <sys/stat.h>         /* stat data structure for getdir(), statout() */
  15. #include <sys/dir.h>                      /* dir data structure for getdir() */
  16. #include <pwd.h>                       /* passwd data structure for u_name() */
  17. #include <grp.h>                        /* group data structure for g_name() */
  18. #ifdef BSD
  19. # include <sys/time.h>                  /* time data structure for printime() */
  20. #else
  21. # include <time.h>                       /* time data structure for printime() */
  22. #endif
  23. #include <signal.h>
  24.  
  25. #ifndef MAXNAMLEN
  26. # ifdef BSD
  27. #  define MAXNAMLEN 256
  28. # else
  29. #  define MAXNAMLEN DIRSIZ
  30. # endif
  31. #endif
  32.  
  33. /*        -- make information --
  34. BUILD
  35. browse: browse.c
  36.     cc browse.c -O -o browse -ltermlib
  37. END
  38. */
  39.  
  40. /*        -- Miscellaneous defines --                     */
  41. #define FALSE 0
  42. #define TRUE 1
  43.  
  44. #define MAXENTS 1024
  45. #define MAXID 16
  46. #define MAXLINE 81
  47. #define NCOL 64
  48. #define MAXNAME 14
  49. #define FILENAME 256
  50.  
  51. /*        -- Extended directory entry format --                 */
  52. struct entry {
  53.     char *e_name;
  54.     int e_flags;
  55. #define FTAGGED (1<<0)
  56. #define FPERMANENT (1<<1)
  57.     struct stat e_stat;                             /* file status field */
  58.     char e_uname[9];                                        /* user name */
  59.     char e_gname[9];                                /* user's group name */
  60. } 
  61. *xentries[MAXENTS], **entries=xentries;
  62. int nentries;
  63.  
  64. /*        -- Look-up cache for user names --                 */
  65. struct idtab {
  66.     int  id_id;                                    /* user (or group) id */
  67.     char id_name[9];                                 /* name[8] + filler */
  68. } 
  69. u_list[MAXID],                                       /* Matched user id's. */
  70. g_list[MAXID];                                              /* ditto group */
  71. int u_ptr=0, g_ptr=0;                                     /* current entries */
  72.  
  73. /*        -- Global variables --                         */
  74. int ccol=NCOL;                /* Width of used display, current column */
  75. int quickmode;              /* short display mode (files only) */
  76.  
  77. int    top, curr;               /* Positions of screen in directory */
  78. #define bottom ((top+nlines>nentries)?nentries:(top+nlines))
  79. char    *dot;                                   /* name of current directory */
  80. int    nlines;                         /* number of lines displayed on page */
  81. char    display_up;                               /* Does the display exist? */
  82. int    todump=1;                 /* Do we want to dump data? */
  83. int    ended;                                    /* Have we quite finished? */
  84. int    intrup;                    /* Have we been interrupted? */
  85. char    *HOME;                      /* Where did I start from? */
  86. char    *SHELL;                       /* How do I run programs? */
  87.  
  88. /*        -- types of functions !!!                     */
  89. char *getenv();
  90. char *malloc();
  91.  
  92. #define NEW(t) (t *)malloc(sizeof (t))
  93. #define NIL(t) ((t) 0)
  94.  
  95. /*        -- Code starts here: dummy main --                    */
  96. main(ac, av)
  97. int ac;
  98. char **av;
  99. {
  100.     if(ac>1) chdir(av[1]);
  101.  
  102.     HOME=getenv("HOME");
  103.     SHELL=getenv("SHELL");
  104.  
  105.     intrup=0;
  106.     if(tcl_init()) {
  107.         tinit(getenv("TERM"));
  108.         clear_all();
  109.         browse();
  110.         tend();
  111.         tcl_end();
  112.     }
  113.     exit(0);
  114. }
  115.  
  116. clear_all()
  117. {
  118.     int i;
  119.  
  120.     for(i = 0; i < MAXENTS; i++)
  121.         entries[i] = 0;
  122. }
  123.  
  124. char *clone(name)
  125. char *name;
  126. {
  127.     char *hold;
  128.     
  129.     hold = (char *)malloc(strlen(name)+1);
  130.  
  131.     if(hold==0)
  132.         return 0;
  133.     strcpy(hold, name);
  134.     return hold;
  135. }
  136.  
  137. newname(e, name)
  138. struct entry *e;
  139. char *name;
  140. {
  141.     if(e->e_name)
  142.         free(e->e_name);
  143.     e->e_name = clone(name);
  144. }
  145.  
  146. #if BSD
  147. readent(dp, buffer)
  148. DIR *dp;
  149. char *buffer;
  150. {
  151.     struct direct *ptr;
  152.  
  153.     do {
  154.         ptr = readdir(dp);
  155.         if(!ptr) return 0;
  156.     } while(ptr->d_ino == 0);
  157.  
  158.     strcpy(buffer, ptr->d_name);
  159.     return 1;
  160. }
  161. #else
  162. #define opendir(n) fopen(n, "r")
  163. #define DIR FILE
  164. readent(dp, buffer)
  165. DIR *dp;
  166. char *buffer;
  167. {
  168.     struct direct db;
  169.     while(fread(&db, sizeof(struct direct), 1, dp)) {
  170.         if(db.d_ino) {
  171.             strncpy(buffer, db.d_name, MAXNAMLEN);
  172.             buffer[MAXNAMLEN] = 0;
  173.             return 1;
  174.         }
  175.     }
  176.     return 0;
  177. }
  178. #define closedir fclose
  179. #endif
  180.  
  181. getdir()
  182. {
  183.     char *u_name(), *g_name();
  184.     DIR *dp;
  185.     static char buffer[MAXNAMLEN+1];
  186.     int i, p;
  187.  
  188.     if(!(dp = opendir("."))) {
  189.         save_errno(".");
  190.         return FALSE;
  191.     }
  192.  
  193.     p = 0;
  194.     for(i = 0; i < nentries; i++) {
  195.         if(entries[i]->e_flags & FPERMANENT) {
  196.             if(p != i) {
  197.                 struct entry *hold;
  198.                 hold = entries[p];
  199.                 entries[p] = entries[i];
  200.                 entries[i] = hold;
  201.             }
  202.             p++;
  203.         }
  204.     }
  205.  
  206.     for(nentries = p; !intrup && nentries < MAXENTS; nentries++) {
  207.         if(!entries[nentries]) {
  208.             entries[nentries] = NEW(struct entry);
  209.             if(!entries[nentries])
  210.                 break;
  211.             entries[nentries]->e_name = NIL(char *);
  212.         }
  213.  
  214.         if(!readent(dp, buffer))
  215.             break;
  216.  
  217.         if(stat(buffer, &entries[nentries]->e_stat)==-1) {
  218.             closedir(dp);
  219.             save_errno(buffer);
  220.             return FALSE;
  221.         }
  222.  
  223.         newname(entries[nentries], buffer);
  224.  
  225.         entries[nentries]->e_flags = 0;
  226.  
  227.         strcpy(entries[nentries]->e_uname,
  228.             u_name(entries[nentries]->e_stat.st_uid));
  229.  
  230.         strcpy(entries[nentries]->e_gname,
  231.             g_name(entries[nentries]->e_stat.st_gid));
  232.     }
  233.  
  234.     closedir(dp);
  235.  
  236.     if(intrup)
  237.         return FALSE;
  238.  
  239.     if(nentries>=MAXENTS || entries[nentries]==NIL(struct entry *)) {
  240.         save_errmsg(".: Directory too large");
  241.         return FALSE;
  242.     }
  243.  
  244.     sortdir();
  245.  
  246.     if(intrup) {
  247.         save_errmsg("Interrupted");
  248.         return FALSE;
  249.     }
  250.     return TRUE;
  251. }
  252.  
  253. at_current()
  254. {
  255.     at_file(curr);
  256. }
  257.  
  258. at_file(file)
  259. int file;
  260. {
  261.     if(display_up) {
  262.         if(file < top || file >= top+nlines)
  263.             return 0;
  264.         at(0, curr-top+2);
  265.     } else {
  266.         if(file != curr)
  267.             return 0;
  268.         cmdline();
  269.     }
  270.     return 1;
  271. }
  272.  
  273. disp_flags(flags)
  274. {
  275.     outc((flags&FTAGGED)?'+':((flags&FPERMANENT)?'!':' '));
  276. }
  277.  
  278. show_flags(ent)
  279. {
  280.     if(!display_up) return;
  281.     if(ent < top || ent >= top+nlines) return;
  282.     at(quickmode?0:(ccol-1), ent-top+2);
  283.     disp_flags(entries[ent]->e_flags);
  284. }
  285.  
  286. tag(ent, mode, bit)
  287. {
  288.     switch(bit) {
  289.         case 'P': bit = FPERMANENT; break;
  290.         case 'T': bit = FTAGGED; break;
  291.     }
  292.     switch(mode) {
  293.         case -1: entries[ent]->e_flags &= ~bit; break;
  294.         case 0: entries[ent]->e_flags ^= bit; break;
  295.         case 1: entries[ent]->e_flags |= bit; break;
  296.     }
  297.     show_flags(ent);
  298. }
  299.  
  300. tagged(ent)
  301. {
  302.     return (entries[ent]->e_flags & FTAGGED) ? 1 : 0;
  303. }
  304.  
  305. delete_from_display(file)
  306. int file;
  307. {
  308.     if(!display_up) return;
  309.  
  310.     if(file>=top+nlines) return;
  311.  
  312.     if(file < top) file = top;
  313.  
  314.     scroll(2+file-top, 2+nlines, 1);
  315.     at(0, 2+nlines-1);
  316.     if(top+nlines >= nentries)
  317.         outc('~');
  318.     else
  319.         dump(bottom, bottom+1);
  320. }
  321.         
  322. delete_entry(file)
  323. int file;
  324. {
  325.     struct entry *hold;
  326.     int    i;
  327.  
  328.     delete_from_display(file);
  329.  
  330.     hold = entries[file];
  331.     for(i=file; i<nentries-1; i++)
  332.         entries[i]=entries[i+1];
  333.     entries[nentries-1]=hold;
  334.     nentries--;
  335.  
  336.     if(file < curr || curr >= nentries) {
  337.         curr--;
  338.         if(top >= nentries) {
  339.             top--;
  340.             display_up = 0;
  341.             todump = 1;
  342.         }
  343.     }
  344. } 
  345.  
  346. ins_at(ent, i)
  347. struct entry *ent;
  348. int i;
  349. {
  350.     struct entry *hold;
  351.     int j;
  352.  
  353.     /* Allocate slot at end */
  354.     if(!entries[nentries]) {
  355.         entries[nentries] = NEW(struct entry);
  356.         if(!entries[nentries]) {
  357.             save_errno(ent->e_name);
  358.             return 0;
  359.         }
  360.         entries[nentries]->e_name = NIL(char *);
  361.     } else if(entries[nentries]->e_name) {
  362.         free(entries[nentries]->e_name);
  363.         entries[nentries]->e_name = NIL(char *);
  364.     }
  365.  
  366.     /* Copy data into slot */
  367.     *entries[nentries] = *ent;
  368.     entries[nentries]->e_name = clone(ent->e_name);
  369.     if(!entries[nentries]->e_name) {
  370.         save_errno(ent->e_name);
  371.         return 0;
  372.     }
  373.  
  374.     if(i != nentries) {
  375.         /* Rotate slot to middle */
  376.         hold = entries[nentries];
  377.         for(j = nentries; j > i; j--)
  378.             entries[j] = entries[j-1];
  379.         entries[i] = hold;
  380.     }
  381.     nentries++;
  382.  
  383.     if(display_up) {
  384.         if(i < top)
  385.             i = top;
  386.         if(i >= bottom)
  387.             return 1;
  388.         scroll(2+i-top, 2+nlines, -1);
  389.         at(0, 2+i-top);
  390.         dump(i, i+1);
  391.     }
  392.     return 1;
  393. }
  394.  
  395. ins_entry(ent)
  396. struct entry *ent;
  397. {
  398.     int i;
  399.  
  400.     if(nentries >= MAXENTS) {
  401.         save_errmsg("Too many files");
  402.         return 0;
  403.     }
  404.  
  405.     for(i = 0; i < nentries; i++)
  406.         if(entcmp(&ent, &entries[i]) < 0)
  407.             break;
  408.  
  409.     return ins_at(ent, i);
  410. }
  411.  
  412. domove(ent, new_name)
  413. int ent;
  414. char *new_name;
  415. {
  416.     struct entry hold;
  417.     hold = *entries[ent];
  418.  
  419.     if(link(entries[ent]->e_name, new_name)!=0) {
  420.         save_errno(entries[ent]->e_name);
  421.         return 0;
  422.     }
  423.     if(unlink(entries[ent]->e_name)!=0) {
  424.         save_errno(entries[ent]->e_name);
  425.         return 0;
  426.     }
  427.  
  428.     hold.e_name = new_name;
  429.     hold.e_flags &= ~FTAGGED;
  430.  
  431.     delete_entry(ent);
  432.     return ins_entry(&hold);
  433. }
  434.  
  435. addfile(name)
  436. char *name;
  437. {
  438.     struct entry hold;
  439.  
  440.     if(stat(name, &hold.e_stat)==-1) {
  441.         save_errno(name);
  442.         return FALSE;
  443.     }
  444.  
  445.     hold.e_name = name;
  446.  
  447.     hold.e_flags = 0;
  448.  
  449.     strcpy(hold.e_uname, u_name(hold.e_stat.st_uid));
  450.  
  451.     strcpy(hold.e_gname, g_name(hold.e_stat.st_gid));
  452.  
  453.     return ins_entry(&hold);
  454. }
  455.  
  456. pname(name, mode)
  457. char *name;
  458. int mode;
  459. {
  460.     int i;
  461.     char *slash, *rindex();
  462.     int max=quickmode?MAXLINE:(MAXNAME+1);
  463.  
  464.     if((mode&S_IFMT)==S_IFDIR)
  465.         max--;
  466.     else if((mode&S_IFMT)==S_IFREG && (mode&0111))
  467.         max--;
  468.     else if((mode&S_IFMT)!=S_IFREG)
  469.         max--;
  470.  
  471.     if(!quickmode && (slash=rindex(name, '/'))) {
  472.         name=slash;
  473.         outc('<');
  474.         max--;
  475.     }
  476.     for(i=0; i<max && *name; name++)
  477.         i += ctlout(*name);
  478.     standend();
  479.     if(i==max && *name) {
  480.         outc('\b');
  481.         outc('>');
  482.     }
  483.     if((mode&S_IFMT)==S_IFDIR) {
  484.         outc('/');
  485.     }
  486.     else if((mode&S_IFMT)==S_IFREG && (mode&0111)) {
  487.         outc('*');
  488.     }
  489.     else if((mode&S_IFMT)!=S_IFREG) {
  490.         outc('?');
  491.     }
  492. }
  493.  
  494. sortdir()
  495. {
  496.     int   entcmp();
  497.     qsort(entries, nentries, sizeof(struct entry *), entcmp);
  498. }
  499.  
  500. entcmp(e1, e2)
  501. struct entry **e1, **e2;
  502. {
  503.     if((*e1)->e_name[0] == '/') {
  504.         if((*e2)->e_name[0] != '/')
  505.             return 1;
  506.     } else if((*e2)->e_name[0] == '/')
  507.         return -1;
  508.  
  509.     return strcmp((*e1)->e_name, (*e2)->e_name);
  510. }
  511.  
  512. dump(start, end)
  513. int start;
  514. int end;
  515. {
  516.     int  i;
  517.     int  lo = (start<nentries)?start:nentries;
  518.     int  hi = (end<nentries)?end:nentries;
  519.  
  520.     for(i=lo; i<hi; i++) {
  521.         statout(entries[i]->e_name,
  522.         &entries[i]->e_stat,
  523.         entries[i]->e_uname,
  524.         entries[i]->e_gname,
  525.         entries[i]->e_flags);
  526.         nl();
  527.     }
  528.     return TRUE;
  529. }
  530.  
  531. statout(name, sbuf, user, group, flags)
  532. char *name;
  533. struct stat *sbuf;
  534. char *user, *group;
  535. int flags;
  536. {
  537.     int mode = sbuf->st_mode;
  538.  
  539.     if(!quickmode) {
  540.         printf("%5u ", sbuf->st_ino);
  541.  
  542.         if((mode&S_IFMT)==S_IFCHR) outc('c');
  543.         else if((mode&S_IFMT)==S_IFBLK) outc('b');
  544.         else if((mode&S_IFMT)==S_IFDIR) outc('d');
  545.         else if((mode&S_IFMT)==S_IFREG) outc('-');
  546.         else outc('?');
  547.         triad((mode>>6)&7, mode&S_ISUID, 's');
  548.         triad((mode>>3)&7, mode&S_ISGID, 's');
  549.         triad(mode&7, mode&S_ISVTX, 't');
  550.         outc(' ');
  551.  
  552.         printf("%3u ", sbuf->st_nlink);
  553.         printf("%-8s ", user);
  554.         printf("%-8s ", group);
  555.  
  556.         if((mode&S_IFMT)==S_IFREG || (mode&S_IFMT)==S_IFDIR)
  557.             printf("%7ld ", sbuf->st_size);
  558.         else
  559.             printf("%3d,%3d ",
  560.             major(sbuf->st_rdev),
  561.             minor(sbuf->st_rdev));
  562.  
  563.         outc(' ');
  564.         printime(&sbuf->st_mtime);
  565.     }
  566.  
  567.     disp_flags(flags);
  568.     pname(name, sbuf->st_mode);
  569. }
  570.  
  571. char *
  572. u_name(uid)
  573. int uid;
  574. {
  575.     int  i;
  576.     struct passwd *pwptr, *getpwuid();
  577.  
  578.     for(i=0; i<u_ptr; i++)
  579.         if(u_list[i].id_id==uid)
  580.             return u_list[i].id_name;
  581.  
  582.     if(u_ptr>=MAXID)                                       /* cache full */
  583.         u_ptr = 0;        /* simplistic algorithm, wrap to beginning */
  584.     /* with MAXID >> # common id's it's good enough */
  585.  
  586.     u_list[u_ptr].id_id=uid;
  587.  
  588.     if(pwptr=getpwuid(uid)) { /* Copy name */
  589.         for(i=0; pwptr->pw_name[i]>' '; i++)
  590.             u_list[u_ptr].id_name[i]=pwptr->pw_name[i];
  591.         u_list[u_ptr].id_name[i]=0;
  592.     } 
  593.     else /* Default to UID */
  594.         sprintf(u_list[u_ptr].id_name, "%d", uid);
  595.  
  596.     return u_list[u_ptr++].id_name;
  597. }
  598.  
  599. char *
  600. g_name(gid)
  601. int gid;
  602. {
  603.     int  i;
  604.     struct group *grptr, *getgrgid();
  605.  
  606.     for(i=0; i<g_ptr; i++)
  607.         if(g_list[i].id_id==gid)
  608.             return g_list[i].id_name;
  609.  
  610.     if(g_ptr>=MAXID)                                       /* cache full */
  611.         g_ptr = 0;        /* simplistic algorithm, wrap to beginning */
  612.     /* with MAXID >> # common id's it's good enough */
  613.  
  614.     g_list[g_ptr].id_id=gid;
  615.  
  616.     if(grptr=getgrgid(gid)) { /* Copy name */
  617.         for(i=0; grptr->gr_name[i]>' '; i++)
  618.             g_list[g_ptr].id_name[i]=grptr->gr_name[i];
  619.         g_list[g_ptr].id_name[i]=0;
  620.     } 
  621.     else /* Default to UID */
  622.         sprintf(g_list[g_ptr].id_name, "%d", gid);
  623.  
  624.     return g_list[g_ptr++].id_name;
  625. }
  626.  
  627. printime(clock)
  628. long *clock;
  629. {
  630.     struct tm *tmbuf, *localtime();
  631.     static char *months[12]= {
  632.         "Jan","Feb","Mar","Apr","May","Jun",
  633.         "Jul","Aug","Sep","Oct","Nov","Dec"
  634.     };
  635.  
  636.     tmbuf=localtime(clock);
  637.     printf("%2d %3s %02d %2d:%02d",
  638.     tmbuf->tm_mday,
  639.     months[tmbuf->tm_mon],
  640.     tmbuf->tm_year,
  641.     tmbuf->tm_hour,
  642.     tmbuf->tm_min);
  643. }
  644.  
  645. header()
  646. {
  647.     if(quickmode)
  648.         printf(" File Name");
  649.     else
  650.         printf(
  651. "Inode Long mode  LNX User     Group   Size/Dev  Modify Time     File name"
  652.             );
  653.     nl();
  654. }
  655.  
  656. triad(bits, special, code)
  657. int bits, special;
  658. char code;
  659. {
  660.     if(bits&4) outc('r');
  661.     else outc('-');
  662.  
  663.     if(bits&2) outc('w');
  664.     else outc('-');
  665.  
  666.     if(special) outc(code);
  667.     else if(bits&1) outc('x');
  668.     else outc('-');
  669. }
  670.  
  671. char *
  672. pwd()
  673. #ifdef GETCWD
  674. {
  675.     static char mydir[FILENAME+1] = "";
  676.     char *getcwd();
  677.  
  678.     return getcwd(mydir, FILENAME);
  679. }
  680. #else
  681. {
  682.     static char buffer[FILENAME+1];
  683.  
  684.     strcpy(buffer, "exec pwd");
  685.     if(tcl_call(buffer, sizeof buffer)) {
  686.         int len = strlen(buffer);
  687.         while(len > 0 && buffer[len-1] <= ' ')
  688.             len--;
  689.         buffer[len] = 0;
  690.         return buffer;
  691.     }
  692.     save_errmsg(buffer);
  693.     return 0;
  694. }
  695. #endif
  696.  
  697. browse()
  698. {
  699.     int  c;
  700.  
  701.     newdir();
  702.     redraw();
  703.     ended=0;
  704.  
  705.     do {
  706.         intrup=0;    /* clear interrupt */
  707.         here_i_am();
  708.         fflush(stdout);
  709.         c = getch();
  710.         cmd(c);
  711.     } 
  712.     while(!ended);
  713. }
  714.  
  715. clearin()
  716. {
  717.     fseek(stdin, 0L, 1); /* stay here messily */
  718. }
  719.  
  720. char *name_of(c)
  721. int c;
  722. {
  723.     static char *p, b[80];
  724.     int ctrl = 0;
  725.  
  726.     p = b;
  727.     if(c & 0x80) {
  728.         c &= 0x7F;
  729.         strcpy(b, "meta_");
  730.         p += 5;
  731.     }
  732.  
  733.     switch(c) {
  734.         case '\033':
  735.             strcpy(p, "escape");
  736.             return b;
  737.         case '\034':
  738.             strcpy(p, "ctrl_backslash");
  739.             return b;
  740.         case '\035':
  741.             strcpy(p, "ctrl_close_bracket");
  742.             return b;
  743.     }
  744.  
  745.     if(c < ' ') {
  746.         c += '@';
  747.         ctrl = 1;
  748.     }
  749.  
  750.     switch(c) {
  751.         case ' ': strcpy(p, "space"); break;
  752.         case '$': strcpy(p, "dollar_sign"); break;
  753.         case '\'': strcpy(p, "quote"); break;
  754.         case '"': strcpy(p, "double_quote"); break;
  755.         case ';': strcpy(p, "semicolon"); break;
  756.         case '{': strcpy(p, "open_brace"); break;
  757.         case '}': strcpy(p, "close_brace"); break;
  758.         case '\177': strcpy(p, "delete"); break;
  759.         case '\\': strcpy(p, "backslash"); break;
  760.         case '[': strcpy(p, "open_bracket"); break;
  761.         case ']': strcpy(p, "close_bracket"); break;
  762.         default: 
  763.             if(ctrl)
  764.                 sprintf(p, "'^%c'", c);
  765.             else
  766.                 sprintf(p, "'%c'", c);
  767.             break;
  768.     }
  769.     return b;
  770. }
  771.  
  772. cmd(c)
  773. int c;
  774. {
  775.     char buffer[80];
  776.  
  777.     if(intrup) {
  778.         cmdline();
  779.         outs("Interrupt");
  780.         return;
  781.     }
  782.  
  783.     sprintf(buffer, "key_%s\n", name_of(c));
  784.     if(!tcl_call(buffer, 80)) {
  785.         cmdline();
  786.         ctlouts(buffer);
  787.         if(!display_up) outc('\n');
  788.         bell();
  789.     }
  790. }
  791.  
  792. char *macro(c)
  793. int c;
  794. {
  795.     static char buffer[80];
  796.  
  797.     sprintf(buffer, "macro_%s\n", name_of(c));
  798.     if(tcl_call(buffer, 80))
  799.         return buffer;
  800.     else
  801.         return 0;
  802. }
  803.  
  804. newdir()
  805. {
  806.     int result = 1;
  807.  
  808.     if(display_up)
  809.         at(0,0);
  810.     fflush(stdout);
  811.     dot=pwd();
  812.  
  813.     if(!getdir())
  814.         result = 0;
  815.  
  816.     curr=0;
  817.     top=0;
  818.     topline();
  819.     if(display_up)
  820.         todump=TRUE;
  821.  
  822.     return result;
  823. }
  824.  
  825. reload()
  826. {
  827.     if(getdir()) {
  828.         curr=(curr>=bottom)?bottom-1:curr;
  829.         if(display_up) {
  830.             topline();
  831.             todump=TRUE;
  832.         }
  833.         return 1;
  834.     }
  835.     return 0;
  836. }
  837.  
  838. topline()
  839. {
  840.     if(display_up)
  841.         at(0,0);
  842.     printf("%s: %d files", dot, nentries);
  843.     nl();
  844. }
  845.  
  846. set_quickmode(mode)
  847. int mode;
  848. {
  849.     if(quickmode != mode) {
  850.         quickmode = mode;
  851.         if(display_up) {
  852.             at(0,1);
  853.             header();
  854.             todump = 1;
  855.         }
  856.     }
  857. }
  858.  
  859. redraw()
  860. {
  861.     clear_screen();
  862.     display_up=0;
  863.     topline();
  864.     at(0,1);
  865.     header();
  866.     todump=1;
  867.     display_up=1;
  868. }
  869.  
  870. dumpdata()
  871. {
  872.     at(0,2);
  873.     dump(top,bottom);
  874.     if(top+nlines>nentries) {
  875.         int i;
  876.         at(0, bottom-top+2);
  877.         for(i=bottom-top; i<nlines; i++) {
  878.             outc('~');
  879.             nl();
  880.         }
  881.     }
  882. }
  883.  
  884. here_i_am()
  885. {
  886.     if(todump)
  887.         display_up = 1;
  888.     if(!display_up) {
  889.         cmdline();
  890.         statout(entries[curr]->e_name,
  891.             &entries[curr]->e_stat,
  892.             entries[curr]->e_uname,
  893.             entries[curr]->e_gname,
  894.             entries[curr]->e_flags);
  895.         at(quickmode?1:ccol, nlines+2);
  896.         fflush(stdout);
  897.      } else if(todump) {
  898.          if(!(curr-top > 0 && curr-top < nlines)) {
  899.              top = curr-nlines/2;
  900.              if(top<0) top=0;
  901.          }
  902.          dumpdata();
  903.          at(quickmode?1:ccol, curr-top+2);
  904.          todump=0;
  905.      } else {
  906.          int lines_to_scroll = curr-top;
  907.          if(lines_to_scroll > 0)
  908.              if((lines_to_scroll -= nlines-1) < 0)
  909.                  lines_to_scroll = 0;
  910.          if(lines_to_scroll < 1-nlines) {
  911.              top=curr;
  912.              at(0,2);
  913.              dump(top, bottom);
  914.          } else if(lines_to_scroll > nlines-1) {
  915.              top=curr-nlines+1;
  916.              at(0,2);
  917.              dump(top, bottom);
  918.          } else if(lines_to_scroll) {
  919.              scroll(2, nlines+2, lines_to_scroll);
  920.              top += lines_to_scroll;
  921.              if(lines_to_scroll < 0) {
  922.                  at(0, 2);
  923.                  dump(top, top-lines_to_scroll);
  924.              } else {
  925.                  at(0, 2+nlines-lines_to_scroll);
  926.                  dump(bottom-lines_to_scroll, bottom);
  927.              }
  928.          }
  929.          at(quickmode?1:ccol, curr-top+2);
  930.      }
  931. }
  932.  
  933. bell()
  934. {
  935.     outc(7);
  936. }
  937.  
  938. system(command)
  939. char *command;
  940. {
  941.     int status;
  942.     int pid;
  943.     SIGNAL (*sigint)(), (*sigquit)();
  944. #ifdef BSD
  945.     SIGNAL  (*sigtstp)();
  946. #endif
  947.  
  948.     sigint=signal(SIGINT, SIG_IGN);
  949.     sigquit=signal(SIGQUIT, SIG_IGN);
  950. #ifdef BSD
  951.     sigtstp = signal(SIGTSTP, SIG_IGN);
  952. #endif
  953.     end_screenmode();
  954.     cooktty();
  955.     fflush(stdout);
  956.     pid = fork();
  957.     if(pid == 0) {
  958.         signal(SIGINT, SIG_DFL);
  959.         signal(SIGQUIT, SIG_DFL);
  960. #ifdef BSD
  961.         signal(SIGTSTP, SIG_DFL);
  962. #endif
  963.         fflush(stdout);
  964.         execl(SHELL, SHELL, "-c", command, (char *)0);
  965.         execl("/bin/sh", "sh", "-c", command, (char *)0);
  966.         perror("/bin/sh");
  967.         exit(-77);
  968.     }
  969.     if(pid==-1) {
  970.         save_errno("browse");
  971.         status = -1;
  972.     } else
  973.         wait(&status);
  974.     signal(SIGINT, sigint);
  975.     signal(SIGQUIT, sigquit);
  976. #ifdef BSD
  977.     signal(SIGTSTP, sigtstp);
  978. #endif
  979.     rawtty();
  980.  
  981.     if(status & 0xFF)
  982.         return -(status&0xFF);
  983.     else
  984.         return (status&0xFF00)>>8;
  985. }
  986.  
  987. addstring(ptr, buf, ip)
  988. char *ptr, *buf;
  989. int *ip;
  990. {
  991.     while(*ptr)
  992.         ctlout(buf[(*ip)++] = *ptr++);
  993.     standend();
  994. }
  995.  
  996. char
  997. inps(buf, text, termin)
  998. char *buf;
  999. char *text;
  1000. char termin;
  1001. {
  1002.     int i = 0;
  1003.     char c, *txp;
  1004.     char *s;
  1005.  
  1006.     txp=text?text:"!";
  1007.  
  1008.     while(!intrup &&
  1009.         (fflush(stdout), c=getch()) != '\033' &&
  1010.         c != '\n' &&
  1011.         c != termin)
  1012.         switch(c) {
  1013.         case '\b': 
  1014.         case '\177':
  1015.             if(i>0) {
  1016.                 printf("\b \b");
  1017.                 i--;
  1018.             } 
  1019.             else
  1020.                 bell();
  1021.             break;
  1022.         case 'U'-'@':
  1023.             txp=text?text:"!";
  1024.         case 'X'-'@':
  1025.             if(i>0)
  1026.                 while(i>0) {
  1027.                     printf("\b \b");
  1028.                     i--;
  1029.                 }
  1030.             else
  1031.                 bell();
  1032.             break;
  1033.         case 'K'-'@':
  1034.             if(*txp)
  1035.                 ctloutc(buf[i++] = *txp++);
  1036.             break;
  1037.         case '\\':
  1038.             outc(c);
  1039.             fflush(stdout);
  1040.             c=getch();
  1041.             if( c=='\\' || c=='\b' || c=='\177' ||
  1042.                 c=='K'-'@' || c=='U'-'@' || c=='X'-'@' ||
  1043.                 c==termin || c=='\033' || c=='\n') {
  1044.                 outc('\b');
  1045.                 ctloutc(buf[i++]=c);
  1046.                 break;
  1047.             } 
  1048.             else if(c>='0' && c<='7') {
  1049.                 int n, val=0;
  1050.                 for(n=0; n<3 && c>='0' && c<='7'; n++) {
  1051.                     val = val*8 + c-'0';
  1052.                     outc('\b');
  1053.                     ctloutc(val);
  1054.                     c=getch();
  1055.                 }
  1056.                 ungetch(c);
  1057.                 c=buf[i++]=val;
  1058.                 break;
  1059.             } 
  1060.             else if(c=='^') {
  1061.                 outc('\b');
  1062.                 outc('^');
  1063.                 fflush(stdout);
  1064.                 c=getch();
  1065.                 if(c>='?'&&c<='_') {
  1066.                     outc('\b');
  1067.                     ctloutc(buf[i++]=(c-'@')&'\177');
  1068.                     break;
  1069.                 } 
  1070.                 else if(c>='`'&&c<='~') {
  1071.                     outc('\b');
  1072.                     ctloutc(buf[i++]=c-'`');
  1073.                     break;
  1074.                 } /* otherwise default */
  1075.                 else buf[i++]='^'; /* after adding caret */
  1076.             }
  1077.             else buf[i++]='\\';
  1078.         default:
  1079.             if(c=='V'-'@')
  1080.                 ctloutc(buf[i++] = getch());
  1081.             if(s = macro(c))
  1082.                 addstring(s, buf, &i);
  1083.             else
  1084.                 ctloutc(buf[i++] = c);
  1085.             break;
  1086.         }
  1087.  
  1088.     buf[i] = 0;
  1089.     return intrup?'\033':c;
  1090. }
  1091.  
  1092. ctlouts(s)
  1093. char *s;
  1094. {
  1095.     int cnt = 0;
  1096.  
  1097.     while(*s)
  1098.         cnt += ctlout(*s++);
  1099.     cnt += standend();
  1100.  
  1101.     return cnt;
  1102. }
  1103.  
  1104. ctloutc(c)
  1105. char c;
  1106. {
  1107.     int cnt;
  1108.  
  1109.     cnt = ctlout(c);
  1110.     cnt += standend();
  1111.  
  1112.     return cnt;
  1113. }
  1114.  
  1115. ctlout(c)
  1116. char c;
  1117. {
  1118.     int cnt = 0;
  1119.     if(c&'\200') {
  1120.         cnt += underline();
  1121.         cnt += ctlout(c&'\177');
  1122.         return cnt;
  1123.     } 
  1124.     else if(c<' ' || c=='\177') {
  1125.         cnt += standout();
  1126.         outc((c+'@')&'\177');
  1127.         cnt++;
  1128.         return cnt;
  1129.     } 
  1130.     else {
  1131.         cnt += standend();
  1132.         outc(c);
  1133.         cnt++;
  1134.         return cnt;
  1135.     }
  1136. }
  1137.  
  1138. get_index(file)
  1139. char *file;
  1140. {
  1141.     int i;
  1142.  
  1143.     for(i = 0; i<nentries; i++)
  1144.         if(strcmp(entries[i]->e_name, file) == 0)
  1145.             return i;
  1146.     return -1;
  1147. }
  1148.  
  1149. char *file_name(i)
  1150. int i;
  1151. {
  1152.     if(i < 0 || i >= nentries)
  1153.         return 0;
  1154.     else
  1155.         return entries[i]->e_name;
  1156. }
  1157.  
  1158. enter(dir)
  1159. char *dir;
  1160. {
  1161.     if(access(dir, 5)==0 && chdir(dir)==0)
  1162.         return newdir();
  1163.     save_errno(dir);
  1164.     return 0;
  1165. }
  1166.  
  1167. isdir(entry)
  1168. struct entry *entry;
  1169. {
  1170.     return((entry->e_stat.st_mode&S_IFMT)==S_IFDIR);
  1171. }
  1172.  
  1173. getch()
  1174. {
  1175.     return getchar();
  1176. }
  1177.  
  1178. ungetch(c)
  1179. char c;
  1180. {
  1181.     ungetc(c, stdin);
  1182. }
  1183.  
  1184.