home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d145 / csh.lha / Csh / DIFFS < prev    next >
Text File  |  1988-05-26  |  12KB  |  507 lines
  1. *** :z/comm1.c    Sun Apr 10 20:41:22 1988
  2. --- comm1.c    Sat Apr 30 16:47:04 1988
  3. ***************
  4. *** 11,18 ****
  5.   typedef struct FileInfoBlock FIB;
  6.   
  7.   #define DIR_SHORT 0x01
  8. ! #define DIR_FILES 0x02
  9. ! #define DIR_DIRS  0x04
  10.   
  11.   extern int has_wild;
  12.   char cwd[256];
  13. --- 11,19 ----
  14.   typedef struct FileInfoBlock FIB;
  15.   
  16.   #define DIR_SHORT 0x01
  17. ! #define DIR_VERY_SHORT 0x02
  18. ! #define DIR_FILES 0x04
  19. ! #define DIR_DIRS  0x08
  20.   
  21.   extern int has_wild;
  22.   char cwd[256];
  23. ***************
  24. *** 151,157 ****
  25.      bytes = blocks = 0L;
  26.      *lspec = '\0';
  27.   
  28. !    options  = get_opt("sfd",&i);
  29.   
  30.      if (ac == i) {
  31.         ++ac;
  32. --- 157,163 ----
  33.      bytes = blocks = 0L;
  34.      *lspec = '\0';
  35.   
  36. !    options  = get_opt("sSfd",&i);
  37.   
  38.      if (ac == i) {
  39.         ++ac;
  40. ***************
  41. *** 158,163 ****
  42. --- 164,170 ----
  43.         av[i] = "";
  44.      }
  45.      if (!(options & (DIR_FILES | DIR_DIRS)))  options |= (DIR_FILES | DIR_DIRS);
  46. +    if (options & DIR_VERY_SHORT) options |= DIR_SHORT;
  47.   
  48.      for (; i < ac; ++i) {
  49.         char **eav;
  50. ***************
  51. *** 170,178 ****
  52.         if (CHECKBREAK()) break;
  53.      }
  54.      if (col)  printf("\n");
  55. !    if (filecount > 1) {
  56.         blocks += filecount;     /* account for dir blocks */
  57. !       printf (" %ld Blocks, %ld Bytes used in %d files\n", blocks, bytes, filecount);
  58.      }
  59.      return (0);
  60.   }
  61. --- 177,186 ----
  62.         if (CHECKBREAK()) break;
  63.      }
  64.      if (col)  printf("\n");
  65. !    if (filecount > 1 && !(options & DIR_VERY_SHORT)) {
  66.         blocks += filecount;     /* account for dir blocks */
  67. !       printf (" %ld Blocks, %ld Bytes used in %d files\n",
  68. !           blocks, bytes, filecount);
  69.      }
  70.      return (0);
  71.   }
  72. ***************
  73. *** 182,194 ****
  74.   int options;
  75.   char *filestr;
  76.   {
  77. -    long atol();
  78.      int isadir,slen;
  79.      char sc;
  80.      char *c,*s,*fi;
  81.      struct FileLock *lock;
  82.      char *get_pwd();
  83. !    char *strcpy();
  84.      
  85.   /*     if current dir different from lspec then
  86.          look for ':' or '/' if found lock it and get_pwd.
  87. --- 190,206 ----
  88.   int options;
  89.   char *filestr;
  90.   {
  91.      int isadir,slen;
  92.      char sc;
  93.      char *c,*s,*fi;
  94. + #ifdef MANX
  95.      struct FileLock *lock;
  96. +    long atol();
  97.      char *get_pwd();
  98. ! #else
  99. !    BPTR lock;
  100. !    char *get_pwd(BPTR);
  101. ! #endif
  102.      
  103.   /*     if current dir different from lspec then
  104.          look for ':' or '/' if found lock it and get_pwd.
  105. ***************
  106. *** 200,209 ****
  107.      *s = '\0';
  108.      c = filestr;
  109.      if (!*c) c = cwd;
  110. !    if (strcmp (c, &lspec))  {
  111.         strcpy(lspec, c);
  112.         if (col)      printf("\n");
  113. !       if (lock = (struct FileLock *)Lock(c,SHARED_LOCK)) {
  114.        printf ("Directory of %s\n", get_pwd(lock));
  115.        UnLock(lock);
  116.         }
  117. --- 212,221 ----
  118.      *s = '\0';
  119.      c = filestr;
  120.      if (!*c) c = cwd;
  121. !    if (strcmp (c, lspec))  {
  122.         strcpy(lspec, c);
  123.         if (col)      printf("\n");
  124. !       if (lock = Lock(c,SHARED_LOCK)) {
  125.        printf ("Directory of %s\n", get_pwd(lock));
  126.        UnLock(lock);
  127.         }
  128. *** :z/execom.c    Sun Apr 10 20:41:42 1988
  129. --- execom.c    Sat Apr 30 20:08:27 1988
  130. ***************
  131. *** 96,110 ****
  132.   exec_command(base)
  133.   char *base;
  134.   {
  135.      register char *scr;
  136.      register int i;
  137. -    char buf[32];
  138.    
  139. -    if (!H_stack) {
  140. -       add_history(base);
  141. -       sprintf(buf, "%d", H_tail_base + H_len);
  142. -       set_var(LEVEL_SET, V_HISTNUM, buf);
  143. -    }
  144.      scr = malloc((strlen(base) << 2) + 2);    /* 4X */
  145.      preformat(base, scr);
  146.      i = fcomm(scr, 1);
  147. --- 96,169 ----
  148.   exec_command(base)
  149.   char *base;
  150.   {
  151. +     char comBuf[270];
  152. +     register char *cp;
  153. +     char *cpBeg;
  154. +     char *rcp;
  155. +     FILE *argResult;
  156. +     int ch;
  157. +     int l1, l2;
  158. +  
  159. +     if (!H_stack) {
  160. +     add_history(base);
  161. +     sprintf(comBuf, "%d", H_tail_base + H_len);
  162. +     set_var(LEVEL_SET, V_HISTNUM, comBuf);
  163. +     }
  164. +     for(cp = base; *cp; cp++) {
  165. +     if(*cp == '\\')
  166. +         cp++;
  167. +     else if(*cp == '`') {
  168. +         cpBeg = cp++;
  169. +         for(; *cp; cp++) {
  170. +         if(*cp == '\\')
  171. +             cp++;
  172. +         else if(*cp == '`')
  173. +             break;
  174. +         }
  175. +         if(*cp != '`')
  176. +         break;
  177. +         if(cp - cpBeg == 1) {
  178. +         strcpy(cpBeg, cp + 1);
  179. +         cp = cpBeg - 1;
  180. +         continue;
  181. +         }
  182. +         movmem(cpBeg + 1, comBuf, cp - cpBeg - 1);
  183. +         comBuf[cp - cpBeg - 1] = 0;
  184. +         strcat(comBuf, " >");
  185. +         strcat(comBuf, argExec);
  186. +         exec1_command(comBuf);
  187. +         rcp = comBuf;
  188. +         if(argResult = fopen(argExec,"r")) {
  189. +         while(rcp - comBuf < sizeof(comBuf) - 1 &&
  190. +               (ch = getc(argResult)) != EOF) {
  191. +             if(ch == '\n')
  192. +             ch = ' ';
  193. +             *rcp++ = ch;
  194. +         }
  195. +         fclose(argResult);
  196. +         DeleteFile(argExec);
  197. +         }
  198. +         l2 = rcp - comBuf;
  199. +         l2 = min(l2, max(0, 255 - (cpBeg - base)));
  200. +         l1 = strlen(cp + 1);
  201. +         l1 = min(l1, max(0, 255 - ((cpBeg + l2) - base)));
  202. +         if(l1 && (cp + 1) != (cpBeg + l2)) {
  203. +         movmem(cp + 1, cpBeg + l2, l1);
  204. +         } else if(!l1)
  205. +         cpBeg[l2] = 0;
  206. +         if(l2)
  207. +         movmem(comBuf, cpBeg, l2);
  208. +     }
  209. +     }
  210. +     return(exec1_command(base));
  211. + }
  212. + 
  213. + exec1_command(base)
  214. + char *base;
  215. + {
  216.      register char *scr;
  217.      register int i;
  218.    
  219.      scr = malloc((strlen(base) << 2) + 2);    /* 4X */
  220.      preformat(base, scr);
  221.      i = fcomm(scr, 1);
  222. *** :z/globals.c    Sun Apr 10 20:41:46 1988
  223. --- globals.c    Sat Apr 30 18:20:24 1988
  224. ***************
  225. *** 84,89 ****
  226. --- 84,90 ----
  227.   long  Uniq;              /* unique value                */
  228.   char  *Cin_name, *Cout_name;  /* redirection input/output name or NULL    */
  229.   char  *Pipe1, *Pipe2;          /* the two pipe temp. files        */
  230. + char  *argExec;              /* `arg exec` temp. file            */
  231.   struct Process *Myprocess;
  232.   int   S_histlen = 20;          /* Max # history entries            */
  233.    
  234. *** :z/main.c    Sun Apr 10 20:41:48 1988
  235. --- main.c    Sat Apr 30 18:18:15 1988
  236. ***************
  237. *** 90,96 ****
  238.    
  239.   init()
  240.   {
  241. !    static char pipe1[32], pipe2[32];
  242.    
  243.      stdin->_flags  |= 0x80;         /* make sure we're set as a tty */
  244.      stdout->_flags |= 0x80;       /* incase of redirection in .login */
  245. --- 102,108 ----
  246.    
  247.   init()
  248.   {
  249. !    static char pipe1[32], pipe2[32], arg_exec[32];
  250.    
  251.      stdin->_flags  |= 0x80;         /* make sure we're set as a tty */
  252.      stdout->_flags |= 0x80;       /* incase of redirection in .login */
  253. ***************
  254. *** 107,114 ****
  255. --- 124,133 ----
  256.      Uniq     = (long)Myprocess;
  257.      Pipe1 = pipe1;
  258.      Pipe2 = pipe2;
  259. +    argExec = arg_exec;
  260.      sprintf (pipe1, "ram:pipe1_%ld", Uniq);
  261.      sprintf (pipe2, "ram:pipe2_%ld", Uniq);
  262. +    sprintf (arg_exec, "ram:argExec_%ld", Uniq);
  263.   }
  264.    
  265.    
  266. *** :z/shell.h    Sun Apr 10 20:42:00 1988
  267. --- shell.h    Sat Apr 30 18:19:06 1988
  268. ***************
  269. *** 117,122 ****
  270. --- 140,146 ----
  271.   extern char *Cin_name, *Cout_name;
  272.   extern char  Cin_type,  Cout_type;  /* these variables are in transition */
  273.   extern char *Pipe1, *Pipe2;
  274. + extern char *argExec;
  275.    
  276.   extern long Src_base[MAXSRC];
  277.   extern long Src_pos[MAXSRC];
  278. *** :z/rawconsole.c    Sun Apr 10 20:41:32 1988
  279. --- rawconsole.c    Sat Apr 30 21:43:32 1988
  280. ***************
  281. *** 9,32 ****
  282.    *
  283.    */
  284.   
  285.   #if RAW_CONSOLE
  286.   extern int aux; /* for use with aux: */
  287.   
  288. - #include "shell.h"
  289. - 
  290.   void
  291.   setraw(onoff)
  292.   {
  293.       if (onoff) set_raw();
  294.       else set_con();
  295.   }
  296.   
  297.   char *
  298.   rawgets(line,prompt)
  299.   char *line, *prompt;
  300.   {
  301. !     char *get_var();
  302.       char *gets();
  303.       register int n, pl;
  304.       register int max, i;
  305.       unsigned char c1,c2,c3;
  306. --- 9,71 ----
  307.    *
  308.    */
  309.   
  310. + #include "shell.h"
  311. + 
  312.   #if RAW_CONSOLE
  313.   extern int aux; /* for use with aux: */
  314.   
  315.   void
  316.   setraw(onoff)
  317.   {
  318. + #ifdef MANX
  319.       if (onoff) set_raw();
  320.       else set_con();
  321. + #else
  322. +     if (onoff) raw(stdin);
  323. +     else cooked(stdin);
  324. + #endif
  325.   }
  326.   
  327. + /* fignore is a ',' separated list of file name suffixes.
  328. +  * return true if one of the suffixes is a suffix str + baseLength.
  329. +  */
  330. + 
  331. + static int
  332. + ignoreSuff(baseLength, fignore, str)
  333. + int baseLength;
  334. + char *fignore;
  335. + char *str;
  336. + {
  337. +     char suff[32];
  338. +     char *endStr;
  339. +     char *cp;
  340. +     int len1, len2;
  341. + 
  342. +     if(!fignore || strlen(str) <= baseLength)
  343. +     return(0);
  344. +     endStr = str + baseLength;
  345. +     len1 = strlen(endStr);
  346. +     for(;*fignore; fignore++) {
  347. +     for(cp = suff; *fignore && *fignore != ',';) {
  348. +         *cp++ = *fignore++;
  349. +     }
  350. +     *cp = 0;
  351. +     len2 = strlen(suff);
  352. +     if(!len2 || len1 < len2)
  353. +         continue;
  354. +     if(!strcmp(suff, endStr + (len1 - len2)))
  355. +         return(1);
  356. +     }
  357. +     return(0);
  358. + }
  359. + 
  360.   char *
  361.   rawgets(line,prompt)
  362.   char *line, *prompt;
  363.   {
  364. ! #ifdef MANX
  365.       char *gets();
  366. + #endif
  367.       register int n, pl;
  368.       register int max, i;
  369.       unsigned char c1,c2,c3;
  370. ***************
  371. *** 37,42 ****
  372. --- 76,82 ----
  373.       int insert = 1;
  374.       char rep[20];
  375.       char typeahd[256];
  376. +     char metaExpBuf[256];
  377.       static int width;
  378.       int recall = -1;
  379.       struct HIST *hist;
  380. ***************
  381. *** 46,51 ****
  382. --- 86,92 ----
  383.       fflush(stdout);
  384.       }
  385.       if (!IsInteractive(Input()) || aux ) return(gets(line));
  386. + #ifdef MANX
  387.       if (WaitForChar((long)Input(), 100L) ||   /* don't switch to 1L ...*/
  388.          stdin->_bp < stdin->_bend) {        /* else causes read err's*/
  389.       /*    printf("%s",prompt); */
  390. ***************
  391. *** 52,57 ****
  392. --- 93,99 ----
  393.       gets(line);
  394.       return(line);
  395.       }
  396. + #endif
  397.       setraw(1);
  398.       printf("\015%s\2336n",prompt);
  399.       savn = pl = n = 0;
  400. ***************
  401. *** 148,153 ****
  402. --- 190,283 ----
  403.               break;
  404.               }
  405.           break;
  406. +         case 4: /* List filename alternatives. The parsing is too simple. */
  407. +         strcpy(metaExpBuf, "dir -S ");
  408. +         {
  409. +             int j;
  410. + 
  411. +             for(j = i; j > pl; j--) {
  412. +             if(line[j - 1] == 32)
  413. +                 break;
  414. +             }
  415. +             if(i > j) {
  416. +             strncat(metaExpBuf, line + j, i - j);
  417. +             }
  418. +             strcat(metaExpBuf, "*");
  419. +         }
  420. +         printf("\233%dC\n",max - i);
  421. +         setraw(0);
  422. +         exec1_command(metaExpBuf);
  423. +         setraw(1);
  424. +         line[max] = 0;
  425. +         printf( "%s%s\015\233%dC", prompt, ps, i);
  426. +         break;
  427. +         case 9: /* Filename completion. */
  428. +         metaExpBuf[0] = 0;
  429. +         {
  430. +             char **eav;
  431. +             int eac;
  432. +             int j, k;
  433. +             int length;
  434. +             char *c1, *c2;
  435. +             char *fignore;
  436. +             int orgLen;
  437. + 
  438. +             fignore = get_var(LEVEL_SET,"fignore");
  439. +             for(j = i; j > pl; j--) {
  440. +             if(line[j - 1] == 32)
  441. +                 break;
  442. +             }
  443. +             if(i > j) {
  444. +             strncat(metaExpBuf, line + j, i - j);
  445. +             }
  446. +             orgLen = strlen(metaExpBuf);
  447. +             strcat(metaExpBuf, "*");
  448. +             if(eav = expand(metaExpBuf, &eac)) {
  449. +             for(k = 0; k < eac && fignore; k++) {
  450. +                 if(!ignoreSuff(orgLen, fignore, eav[k]))
  451. +                 break;
  452. +             }
  453. +             if(k == eac) {
  454. +                 free_expand (eav);
  455. +                 break;
  456. +             }
  457. +             strcpy(metaExpBuf, eav[k]);
  458. +             for(; k < eac; k++) {
  459. +                 if(ignoreSuff(orgLen, fignore, eav[k]))
  460. +                 continue;
  461. +                 c1 = metaExpBuf;
  462. +                 c2 = eav[k];
  463. +                 while(*c1 && *c1 == *c2) {
  464. +                 c1++;
  465. +                 c2++;
  466. +                 }
  467. +                 *c1 = 0;
  468. +             }
  469. +             free_expand (eav);
  470. +             if(length = strlen(metaExpBuf)) {
  471. +                 if(isdir(metaExpBuf)) {
  472. +                 if(metaExpBuf[length - 1] != '/' &&
  473. +                    metaExpBuf[length - 1] != ':') {
  474. +                     strcat(metaExpBuf, "/");
  475. +                     length++;
  476. +                 }
  477. +                 } else if(!access(metaExpBuf, 0)) {
  478. +                 strcat(metaExpBuf, " ");
  479. +                 length++;
  480. +                 }
  481. +             }
  482. +             if(i != j + length && max - i)
  483. +                 movmem(line + i, line + j + length,
  484. +                    max - i);
  485. +             if(length)
  486. +                 movmem(metaExpBuf, line + j, length);
  487. +             max += length - (i - j);
  488. +             line[max] = 0;
  489. +             i = j + length;
  490. +             printf( "\015%s%s\015\233%dC", prompt, ps, i);
  491. +             }
  492. +         }
  493. +         break;
  494.           case 8:
  495.           if (i > pl) {
  496.               i--;
  497. ***************
  498. *** 242,247 ****
  499. --- 373,379 ----
  500.               line[max] = '\0';
  501.           }
  502.       }
  503. +     fflush(stdout);
  504.       }
  505.       setraw(0);
  506.       return(NULL);
  507.