home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / disks / disk458.lzh / Csh / src / comm2.c < prev    next >
C/C++ Source or Header  |  1991-02-15  |  13KB  |  605 lines
  1. /*
  2.  * COMM2.C
  3.  *
  4.  * (c)1986 Matthew Dillon     9 October 1986
  5.  *
  6.  * Version 2.07M by Steve Drew 10-Sep-87
  7.  *
  8.  * Version 4.01A by Carlo Borreo & Cesare Dieni 17-Feb-90
  9.  *
  10.  */
  11.  
  12. /* Casting conveniences */
  13. #define BPTR_TO_C(strtag, var)  ((struct strtag *)(BADDR( (ULONG) var)))
  14. #define PROC(task)              ((struct Process *)task)
  15. #define CLI(proc)               (BPTR_TO_C(CommandLineInterface, proc->pr_CLI))
  16.  
  17. /* Externs */
  18. extern int has_wild;                    /* flag set if any arg has a ? or * */
  19.  
  20. /* globals */
  21. int cp_update, cp_date, cp_flags;
  22.  
  23. do_abortline()
  24. {
  25. Exec_abortline = 1;
  26. return 0;
  27. }
  28.  
  29. do_return()
  30. {
  31. register int retcode=(ac<2 ? 0 : atoi(av[1]));
  32.    Exec_abortline = 1;
  33.    if (Src_stack) {
  34.        FILE *ptr = (FILE *)Src_base[Src_stack - 1];
  35.        ptr->_bp = ptr->_bend;
  36.        ptr->_flags |= _EOF;
  37. /*     fseek (Src_base[Src_stack - 1], 0L, 2); */
  38.       return retcode;
  39.    } else main_exit(retcode);
  40. }
  41.  
  42. /*
  43.  * STRHEAD
  44.  *
  45.  * place a string into a variable removing everything after and including
  46.  * the 'break' character
  47.  *
  48.  * strhead varname breakchar string
  49.  *
  50.  */
  51.  
  52. do_strhead()
  53. {
  54. char *s;
  55. if (s=index(av[3],*av[2])) *s='\0';
  56. set_var (LEVEL_SET, av[1], av[3]);
  57. return 0;
  58. }
  59.  
  60. do_strtail()
  61. {
  62. char *s;
  63. if (s=index(av[3],*av[2])) s++; else s=av[3];
  64. set_var (LEVEL_SET, av[1], s);
  65. return 0;
  66. }
  67.  
  68. long dptrtosecs(d)
  69. struct DPTR *d;
  70. {
  71. register struct DateStamp *ds=(&d->fib->fib_Date);
  72. return ds->ds_Days*86400 + ds->ds_Minute*60 + ds->ds_Tick/TICKS_PER_SECOND;
  73. }
  74.  
  75. long timeof(s)
  76. char *s;
  77. {
  78. struct DPTR *d;
  79. int dummy;
  80. long n;
  81.  
  82. if ( (d=dopen(s,&dummy))==NULL ) return 0L;
  83. n=dptrtosecs(d);
  84. dclose(d);
  85. return n;
  86. }
  87.  
  88. /*
  89.  * if -f file (exists) or:
  90.  *
  91.  * if A < B   <, >, =, <=, >=, <>, where A and B are either:
  92.  * nothing
  93.  * a string
  94.  * a value (begins w/ number)
  95.  */
  96.  
  97. do_if(garbage, com)
  98. char *garbage;
  99. {
  100. int result;
  101. int i;
  102.  
  103. switch (com) {
  104.     case 0:
  105.     if (If_stack && If_base[If_stack - 1]) If_base[If_stack++] = 1;
  106.     else {
  107.         get_opt("rftmdvn",&i);
  108.         result=evalif(i);
  109.         If_base[If_stack++]=(options & 64 ? result : !result);
  110.         }
  111.     break;
  112.     case 1:
  113.     if (If_stack > 1 && If_base[If_stack - 2]) break;
  114.     if (If_stack) If_base[If_stack - 1] ^= 1;
  115.     break;
  116.     case 2:
  117.     if (If_stack) --If_stack;
  118.     break;
  119.      }
  120. disable = (If_stack) ? If_base[If_stack - 1] : 0;
  121. if (If_stack >= MAXIF) {
  122.     fprintf(stderr,"If's too deep\n");
  123.     disable = If_stack = 0;
  124.     return -1;
  125.     }
  126. if (forward_goto) disable = If_base[If_stack - 1] = 0;
  127. return 0;
  128. }
  129.  
  130. evalif(i)
  131. register unsigned int i;
  132. {
  133. char c;
  134. long num, t0, isint;
  135. long AvailMem();
  136.  
  137. switch(options & ~64) {
  138.     case 0:
  139.     if (ac-i != 3) return (ac>i && *av[i]);
  140.     num  = Atol(av[i]);
  141.     isint  = ! IoErr();
  142.     num -= Atol(av[i+2]);
  143.     isint &= ! IoErr();
  144.     if (!isint) num=strcmp(av[i],av[i+2]);
  145.     if (num < 0)       c='<';
  146.     else if (num > 0)  c='>';
  147.     else if (num == 0) c='=';
  148.     return index(av[i+1], c) != NULL;
  149.     case 1:
  150.     return do_rpn(NULL,i);
  151.     case 2:
  152.     return exists(av[i]);
  153.     case 4:
  154.     t0=timeof(av[i++]);
  155.     for ( ; i<ac ; i++)
  156.         if (t0<=timeof(av[i])) return 1;
  157.     return 0;
  158.     case 8:
  159.     return (AvailMem( (long)MEMF_FAST )!=0);
  160.     case 16:
  161.     return (isdir(av[i])!=0);
  162.     case 32:
  163.     return (get_var(LEVEL_SET,av[i]) != 0);
  164.     default:
  165.     ierror(NULL,500);
  166.     return 0;
  167.     }
  168. }
  169.  
  170. do_label()
  171. {
  172.    char aseek[32];
  173.  
  174.    if (Src_stack == 0) {
  175.       ierror (NULL, 502);
  176.       return (-1);
  177.    }
  178.  
  179.    sprintf (aseek, "%ld %d", Src_pos[Src_stack-1], If_stack);
  180.    set_var (LEVEL_LABEL + Src_stack - 1, av[1], aseek);
  181.    if (!strcmp(av[1],get_var(LEVEL_SET,v_gotofwd)))
  182.       forward_goto = 0;
  183.    return 0;
  184. }
  185.  
  186. do_goto()
  187. {
  188.    int new;
  189.    long pos;
  190.    char *lab;
  191.  
  192.    if (Src_stack == 0) {
  193.       ierror (NULL, 502);
  194.    } else {
  195.       lab = get_var (LEVEL_LABEL + Src_stack - 1, av[1]);
  196.       if (lab == NULL) {
  197.          forward_goto = 1;
  198.          set_var (LEVEL_SET, v_gotofwd, av[1]);
  199.          return(0);
  200.       } else {
  201.          pos = atoi(lab);
  202.          fseek (Src_base[Src_stack - 1], pos, 0);
  203.          Src_pos[Src_stack - 1] = pos;
  204.          new = atoi(next_word(lab));
  205.          for (; If_stack < new; ++If_stack)
  206.             If_base[If_stack] = 0;
  207.          If_stack = new;
  208.       }
  209.    }
  210.    Exec_abortline = 1;
  211.    return (0);      /* Don't execute rest of this line */
  212. }
  213.  
  214.  
  215. do_inc(garbage, com)
  216. char *garbage;
  217. {
  218. char *var, num[32];
  219.  
  220. if (ac>2) com *= atoi(av[2]);
  221. if (var = get_var (LEVEL_SET, av[1])) {
  222.     sprintf (num, "%d", atoi(var)+com);
  223.     set_var (LEVEL_SET, av[1], num);
  224.     }
  225. return 0;
  226. }
  227.  
  228. do_input()
  229. {
  230. char in[256], *p,*s;
  231. unsigned int i;
  232.  
  233. for (i=1; i < ac; ++i)
  234.     if (gets(in)) {
  235.     for(p = in; *p; p = s) {
  236.         s = next_word(p);
  237.         if (*s) *(s-1) = 0xA0;
  238.         }
  239.     set_var (LEVEL_SET, av[i], in);
  240.     }
  241. return 0;
  242. }
  243.  
  244. do_ver()
  245. {
  246. extern char shellname[];
  247.  
  248. puts(shellname);
  249. puts("(c)1986 Matthew Dillon\n\
  250. Manx (M) versions by Steve Drew\n\
  251. ARP (A) versions by Carlo Borreo & Cesare Dieni\n");
  252. return 0;
  253. }
  254.  
  255. do_ps()
  256. {
  257. /* this code fragment based on ps.c command by Dewi Williams */
  258.  
  259. register int    count;        /* loop variable        */
  260. struct Task    *task;        /* EXEC descriptor        */
  261. char        strbuf[64+1];    /* scratch for btocstr()    */
  262. char        cmd[40+1];    /* holds cmd name        */
  263. long ncli;
  264.  
  265. printf("Proc Command Name         CLI Type    Pri.  Address  Directory\n");
  266. Forbid();
  267.  
  268. ncli=(long)FindCLI(0L);
  269. for (count = 1; count <= ncli ; count++)
  270.         /* or just assume 20?*/
  271.     if (task = (struct Task *)FindCLI((long)count)) {
  272.     if (task==NULL) continue;
  273.     /* Sanity check just in case */
  274.     if (PROC(task)->pr_TaskNum == 0 || PROC(task)->pr_CLI == 0) continue;
  275.                             /* or complain? */
  276.     BtoCStr(cmd,   CLI(PROC(task))->cli_CommandName, 40L);
  277.     BtoCStr(strbuf,CLI(PROC(task))->cli_SetName    , 64L);
  278.     printf("%2d   %-20.20s %-11.11s %3d  %8lx  %s\n",
  279.         count,
  280.         cmd,
  281.         task->tc_Node.ln_Name,
  282.         task->tc_Node.ln_Pri,
  283.         task,
  284.         strbuf);
  285.     }
  286. Permit();
  287. return 0;
  288. }
  289.  
  290. /*
  291.  * CP [-d] [-u] file file
  292.  * CP [-d] [-u] file file file... destdir
  293.  * CP [-r][-u][-d] dir dir dir... destdir
  294.  */
  295.  
  296. char *errstr;          /* let's be alittle more informative */
  297.  
  298. do_copy()
  299. {
  300. register int recur, ierr;
  301. register char *destname;
  302. register char destisdir;
  303. register FIB *fib;
  304. int i;
  305.  
  306. errstr = "";
  307. ierr = 0;
  308.  
  309. fib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  310.  
  311. get_opt("rudf",&i);
  312. recur     = (options & 0x01);
  313. cp_update = (options & 0x02);
  314. cp_date   = (!(options & 0x04)); /* the default is keep orignal file date */
  315. cp_flags  = (!(options & 0x08)); /* and flags */
  316.  
  317. destname = av[ac - 1];
  318.  
  319. if (ac < i + 2) {
  320.     ierr = 500;
  321.     goto done;
  322.     }
  323. destisdir = isdir(destname);
  324. if (ac > i + 2 && !destisdir) {
  325.     ierr = 507;
  326.     goto done;
  327.     }
  328.  
  329. /*
  330.  * copy set:                        reduce to:
  331.  *    file to file                     file to file
  332.  *    dir  to file (NOT ALLOWED)
  333.  *    file to dir                      dir to dir
  334.  *    dir  to dir                      dir to dir
  335.  *
  336.  */
  337.  
  338. for (; i<ac-1 && !dobreak(); ++i) {
  339.     short srcisdir = isdir(av[i]);
  340.     if (srcisdir && has_wild && (ac >2)) /* hack to stop dir's from */
  341.         continue;             /* getting copied if specified */
  342.                          /* from wild expansion */
  343.     if (srcisdir) {
  344.         BPTR srcdir, destdir;
  345.         if (!destisdir) {
  346.             if (exists(destname)) {
  347.                 ierr = 507;    /* disallow dir to file */
  348.                 goto done;
  349.                 }
  350.             if (destdir = CreateDir(destname)) UnLock(destdir);
  351.             destisdir = 1;
  352.             }
  353.         if (!(destdir = Lock(destname, ACCESS_READ))) {
  354.             ierr = 205;
  355.             errstr = destname;
  356.             goto done;
  357.             }
  358.         if (!(srcdir = Lock(av[i], ACCESS_READ))) {
  359.             ierr = 205;
  360.             errstr = av[i];
  361.             UnLock(destdir);
  362.             goto done;
  363.             }
  364.         ierr = copydir(srcdir, destdir, recur);
  365.         UnLock(srcdir);
  366.         UnLock(destdir);
  367.         if (ierr) break;
  368.         }
  369.     else {        /* FILE to DIR,   FILE to FILE   */
  370.         BPTR destdir, srcdir, tmp;
  371.         char *destfilename;
  372.  
  373.         srcdir = (BPTR)(Myprocess->pr_CurrentDir);
  374.  
  375.         if ((tmp = Lock(av[i], ACCESS_READ)) == NULL || !Examine(tmp,fib)) {
  376.             if (tmp) UnLock(tmp);
  377.             ierr = 205;
  378.             errstr = av[i];
  379.             goto done;
  380.             }
  381.         UnLock(tmp);
  382.         if (destisdir) {
  383.             destdir = Lock(destname, ACCESS_READ);
  384.             destfilename = fib->fib_FileName;
  385.             }
  386.         else {
  387.             destdir = srcdir;
  388.             destfilename = destname;
  389.             }
  390.         printf(" %s..",av[i]);
  391.         fflush(stdout);
  392.         ierr = copyfile(av[i], srcdir, destfilename, destdir);
  393.         if (destisdir) UnLock(destdir);
  394.         if (ierr) break;
  395.         }
  396.     }
  397.  
  398. done:
  399.  
  400. FreeMem(fib, (long)sizeof(FIB));
  401. if (ierr) {
  402.     ierror(errstr, ierr);
  403.     return(20);
  404.     }
  405. return 0;
  406. }
  407.  
  408.  
  409. copydir(srcdir, destdir, recur)
  410. register BPTR srcdir, destdir;
  411. {
  412.    BPTR cwd;
  413.    register FIB *srcfib;
  414.    register BPTR destlock, srclock;
  415.    int ierr;
  416.    static int level;
  417.  
  418.    level++;
  419.    ierr = 0;
  420.    srcfib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  421.    if (Examine(srcdir, srcfib)) {
  422.       while (ExNext(srcdir, srcfib)) {
  423.          if (CHECKBREAK())
  424.             break;
  425.          if (srcfib->fib_DirEntryType < 0) {
  426.             printf("%*s%s..",(level-1) * 6," ",srcfib->fib_FileName);
  427.             fflush(stdout);
  428.             ierr = copyfile(srcfib->fib_FileName,srcdir,srcfib->fib_FileName,destdir);
  429.             if (ierr)
  430.                break;
  431.          } else {
  432.             if (recur) {
  433.                cwd = CurrentDir(srcdir);
  434.                if (srclock = Lock(srcfib->fib_FileName, ACCESS_READ)) {
  435.                   CurrentDir(destdir);
  436.                   if (!(destlock = Lock(srcfib->fib_FileName, ACCESS_WRITE))) {
  437.                      destlock = CreateDir(srcfib->fib_FileName);
  438.                      printf("%*s%s (Dir)....[Created]\n",(level-1) * 6,
  439.                                 " ",srcfib->fib_FileName);
  440.  
  441.                         /* UnLock and re Lock if newly created
  442.                            for file_date() to work properly
  443.                         */
  444.                      if (destlock) UnLock(destlock);
  445.                      destlock = Lock(srcfib->fib_FileName, ACCESS_WRITE);
  446.                   }
  447.                   else
  448.                      printf("%*s%s (Dir)\n",(level-1) * 6," ",srcfib->fib_FileName);
  449.                   if (destlock) {
  450.                      ierr = copydir(srclock, destlock, recur);
  451.                      UnLock(destlock);
  452.                   } else {
  453.                      ierr = (int)((long)IoErr());
  454.                   }
  455.                   UnLock(srclock);
  456.                } else {
  457.                   ierr = (int)((long)IoErr());
  458.                }
  459.                CurrentDir(cwd);
  460.                if (ierr)
  461.                   break;
  462.             }
  463.          }
  464.       }
  465.    } else {
  466.       ierr = (int)((long)IoErr());
  467.    }
  468.    --level;
  469.    FreeMem(srcfib, (long)sizeof(FIB));
  470.    return(ierr);
  471. }
  472.  
  473.  
  474. copyfile(srcname, srcdir, destname, destdir)
  475. char *srcname, *destname;
  476. BPTR srcdir, destdir;
  477. {
  478. BPTR cwd;
  479. BPTR f1, f2;
  480. long i;
  481. int stat,ierr;
  482. char *buf;
  483. struct DPTR *dp, *dps = NULL;
  484.  
  485. if ((buf = (char *)AllocMem(8192L, MEMF_PUBLIC|MEMF_CLEAR))==NULL)
  486.     { ierr = 103; goto fail; }
  487. ierr = 0;
  488. cwd = CurrentDir(srcdir);
  489. if ((f1=Open(srcname, MODE_OLDFILE))==NULL)
  490.     { errstr = srcname; ierr = 205; goto fail; }
  491. dps = dopen(srcname,&stat);
  492. CurrentDir(destdir);
  493. if (cp_update)
  494.     {
  495.     dp=dopen(destname, &stat);
  496.     if ( dptrtosecs(dp) >= dptrtosecs(dps) &&
  497.         !strcmp(dps->fib->fib_FileName, dp->fib->fib_FileName))
  498.         { dclose(dp); Close(f1); printf("..not newer\n"); goto fail; }
  499.     dclose(dp);
  500.     }
  501. if ((f2=Open(destname, MODE_NEWFILE))==NULL)
  502.     { Close(f1); ierr = (int)((long)IoErr()); errstr=destname; goto fail;  }
  503. while (i = Read(f1, buf, 8192L))
  504.     if (Write(f2, buf, i) != i) { ierr = (int)((long)IoErr()); break; }
  505. Close(f2);
  506. Close(f1);
  507. if (!ierr)
  508.     {
  509.     if (cp_date) file_date(&dps->fib->fib_Date, destname);
  510.     if (cp_flags) SetProtection(destname, dps->fib->fib_Protection);
  511.     printf("..copied\n");
  512.     }
  513. else DeleteFile(destname);
  514. fail:
  515.  dclose(dps);
  516.  if (buf) FreeMem(buf, 8192L);
  517.  CurrentDir(cwd);
  518.  return(ierr);
  519. }
  520.  
  521. do_touch()
  522. {
  523. struct DateStamp ds;
  524. register unsigned int i;
  525. DateStamp(&ds);
  526. for (i=1; i<ac; i++) if (file_date(&ds, av[i])) ierror(av[i],500);
  527. return 0;
  528. }
  529.  
  530. file_date(date,name)
  531. struct DateStamp *date;
  532. char *name;
  533. {
  534. long packargs[7];
  535. UBYTE *ptr;
  536. struct MsgPort *task;
  537. BPTR dirlock;
  538. struct DPTR *tmp;
  539. int stat;
  540.  
  541. if (!(task = (struct MsgPort *)DeviceProc(name))) return(1);
  542. if (tmp = dopen(name, &stat)) {
  543.     dirlock = ParentDir(tmp->lock);
  544.     ptr=AllocMem(65L,MEMF_PUBLIC);
  545.     CtoBStr(tmp->fib->fib_FileName,(ULONG)ptr >> 2L,64L);
  546.     dclose(tmp);
  547.     packargs[1]=dirlock;
  548.     packargs[2]=(ULONG)ptr >> 2L;
  549.     packargs[3]=(long)date;
  550.     SendPacket(ACTION_SET_DATE,packargs,task);
  551.     UnLock(dirlock);
  552.     FreeMem(ptr,65L);
  553.     }
  554. return 0;
  555. }
  556.  
  557. do_addbuffers()
  558. {
  559. long packargs[7];
  560. long n;
  561. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  562.  
  563. if (!task) { ierror(av[1],510); return 20; }
  564. n=myatoi(av[2],1,32767); if (atoierr) return 20;
  565. packargs[0]=n;
  566. SendPacket(ACTION_MORE_CACHE,packargs,task);
  567. return 0;
  568. }
  569.  
  570. do_relabel()
  571. {
  572. long packargs[7];
  573. UBYTE *ptr;
  574. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  575.  
  576. if (!task) { ierror(av[1],510); return 20; }
  577. ptr=AllocMem(65L,MEMF_PUBLIC);
  578. CtoBStr(av[2],(ULONG)ptr >> 2L,64L);
  579. packargs[0]=(ULONG)ptr >> 2L;
  580. SendPacket(ACTION_RENAME_DISK,packargs,task);
  581. FreeMem(ptr,65L);
  582. changedisk(task);
  583. return 0;
  584. }
  585.  
  586. do_diskchange()
  587. {
  588. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  589.  
  590. if (!task) { ierror(av[1],510); return 20; }
  591. changedisk(task);
  592. return 0;
  593. }
  594.  
  595. changedisk(task)
  596. struct MsgPort *task;
  597. {
  598. long packargs[7];
  599.  
  600. packargs[0]=1L;
  601. SendPacket(ACTION_INHIBIT,packargs,task);
  602. packargs[0]=0L;
  603. SendPacket(ACTION_INHIBIT,packargs,task);
  604. }
  605.