home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d169 / dillonstuff.lha / src / shell / comm2.c < prev    next >
C/C++ Source or Header  |  1988-11-22  |  14KB  |  702 lines
  1.  
  2. /*
  3.  * COMM2.C
  4.  *
  5.  *
  6.  * (c)1986 Matthew Dillon     Feb 1987
  7.  *
  8.  *    ABORTLINE
  9.  *    RETURN
  10.  *    STRHEAD
  11.  *    STRTAIL
  12.  *    IF
  13.  *    LABEL
  14.  *    GOTO
  15.  *    INC
  16.  *    INPUT
  17.  *    VER
  18.  *    CP
  19.  *    SHELLSTAT
  20.  *    SETENV
  21.  *    UNSETENV
  22.  *    IPC
  23.  *    CLDRES
  24.  *
  25.  */
  26.  
  27. #include "shell.h"
  28. #include <libraries/dos.h>
  29. #include <libraries/dosextens.h>
  30. #include <local/ipc.h>
  31.  
  32. typedef struct CommandLineInterface CLI;
  33.  
  34. extern LOCK *CurrentDir(), *Lock(), *CreateDir();
  35. extern IPCMSG *SendIPC();
  36.  
  37. do_cldres()
  38. {
  39.     if (DResBase)
  40.     CloseLibrary(DResBase);
  41.     DResBase = NULL;
  42. }
  43.  
  44. /*
  45.  *  do_ipc appname[.project] command
  46.  */
  47.  
  48. do_ipc(command)
  49. char *command;
  50. {
  51.     IPCMSG *msg;
  52.     char *str = next_word(next_word(command));
  53.     char *ptr;
  54.     char appname[64];
  55.     char *cmd;
  56.     long result;
  57.  
  58.     if (!DResBase)
  59.     DResBase = (long)OpenLibrary("dres.library", 0);
  60.     if (!DResBase) {
  61.     puts("Unable to open dres.library");
  62.     return(-1);
  63.     }
  64.     for (ptr = av[1]; *ptr && *ptr != '.'; ++ptr);
  65.     if (*ptr == '.') {
  66.     if (cmd = malloc(strlen(ptr+1)+strlen(str)+2)) {
  67.         strcpy(cmd, ptr+1);
  68.         strcpy(cmd + strlen(cmd) + 1, str);
  69.     }
  70.     } else {
  71.     if (cmd = malloc(strlen(str)+2)) {
  72.         cmd[0] = 0;
  73.         strcpy(cmd+1, str);
  74.     }
  75.     }
  76.     if (!cmd)
  77.     return(-1);
  78.     strcpy(appname, av[1]);
  79.     appname[ptr - av[1]] = 0;
  80.     strcat(appname, ".CMD");
  81.  
  82.     msg = SendIPC(appname, cmd, strlen(cmd)+strlen(str)+2, 0);
  83.     free(cmd);
  84.     if (!msg)
  85.     return(-1);
  86.     WaitMsg(msg);
  87.     if (msg->RFlags & IF_ERROR) {
  88.     if (msg->RFlags & IF_NOAPP)
  89.         printf("Application not found");
  90.     else
  91.         printf("Operation Failed");
  92.     if (msg->RBuf)
  93.         printf(": %s\n", msg->RBuf);
  94.     puts("");
  95.     if (!msg->Error)
  96.         msg->Error = 20;
  97.     } else {
  98.     if (msg->RBuf)
  99.         Oputs(msg->RBuf);
  100.     }
  101.     result = msg->Error;
  102.     FreeIPC(msg);
  103.     return(result);
  104. }
  105.  
  106. do_abortline()
  107. {
  108.     Exec_abortline = 1;
  109.     return (0);
  110. }
  111.  
  112. do_return()
  113. {
  114.     Exec_abortline = 1;
  115.     if (Src_stack) {
  116.     fseek (Src_base[Src_stack - 1], 0, 2);
  117.     return ((ac < 2) ? 0 : atoi(av[1]));
  118.     } else {
  119.     main_exit ((ac < 2) ? 0 : atoi(av[1]));
  120.     }
  121. }
  122.  
  123. /*
  124.  * STRHEAD
  125.  *
  126.  * place a string into a variable removing everything after and including
  127.  * the 'break' character or until a space is found in the string.
  128.  *
  129.  * strhead varname breakchar string
  130.  *
  131.  */
  132.  
  133. do_strhead()
  134. {
  135.     register char *str = av[3];
  136.     register char bc = *av[2];
  137.  
  138.     while (*str && *str != bc)
  139.     ++str;
  140.     *str = '\0';
  141.     set_var (LEVEL_SET, av[1], av[3]);
  142.     return (0);
  143. }
  144.  
  145. do_strtail()
  146. {
  147.     register char *str = av[3];
  148.     register char bc = *av[2];
  149.  
  150.     while (*str && *str != bc)
  151.     ++str;
  152.     if (*str)
  153.     ++str;
  154.     set_var (LEVEL_SET, av[1], str);
  155.     return (0);
  156. }
  157.  
  158. /*
  159.  * if A < B   <, >, =, <=, >=, !=, where A and B are either:
  160.  * nothing
  161.  * a string
  162.  * a value (begins w/ number)
  163.  *
  164.  *  if -[!]f file
  165.  *
  166.  */
  167.  
  168. do_if(garbage, com)
  169. char *garbage;
  170. {
  171.     register char *v1, *v2, *v3, result, num;
  172.     register int n1, n2;
  173.  
  174.     switch (com) {
  175.     case 0:
  176.     if (If_stack && If_base[If_stack - 1]) {
  177.         if (If_stack == MAXIF) {
  178.         ierror(NULL, 510);
  179.         } else {
  180.         If_base[If_stack++] = 1;
  181.         }
  182.         break;
  183.     }
  184.     result = num = 0;
  185.     v1 = av[1];
  186.     switch(ac) {
  187.     case 2:          /* if $var; */
  188.         if (v1[0] == 0 || (v1[1] == 0 && v1[0] == ' '))
  189.         goto do_result;
  190.         result = 1;      /* fall through    */
  191.     case 1:          /* if        */
  192.         goto do_result;
  193.     case 3:          /* if -flag name    */
  194.         if (*v1 == '-')
  195.         ++v1;
  196.         if (*v1 == '!') {
  197.         ++v1;
  198.         result = 1 - result;
  199.         }
  200.         switch(*v1) {
  201.         case 'f':
  202.         {
  203.             LOCK *lock;
  204.             mountrequest(0);
  205.             if (lock = Lock(av[2], SHARED_LOCK)) {
  206.             result = 1 - result;
  207.             UnLock(lock);
  208.             }
  209.             mountrequest(1);
  210.         }
  211.         break;
  212.         default:
  213.         goto splug;
  214.         }
  215.         goto do_result;
  216.     case 4:
  217.         goto cond;
  218.     }
  219. splug:
  220.     ierror(NULL, 500);
  221.     goto do_result;
  222. cond:
  223.     v1 = av[1]; v2 = av[2]; v3 = av[3];
  224.     while (*v1 == ' ')
  225.         ++v1;
  226.     while (*v2 == ' ')
  227.         ++v2;
  228.     while (*v3 == ' ')
  229.         ++v3;
  230.     if (*v1 >= '0' && *v1 <= '9') {
  231.         num = 1;
  232.         n1 = atoi(v1);
  233.         n2 = atoi(v3);
  234.     }
  235.     while (*v2) {
  236.         switch (*v2++) {
  237.         case '>':
  238.         result |= (num) ? (n1 >  n2) : (strcmp(v1, v3) > 0);
  239.         break;
  240.         case '<':
  241.         result |= (num) ? (n1 <  n2) : (strcmp(v1, v3) < 0);
  242.         break;
  243.         case '=':
  244.         result |= (num) ? (n1 == n2) : (strcmp(v1, v3) ==0);
  245.         break;
  246.         default:
  247.         ierror (NULL, 503);
  248.         break;
  249.         }
  250.     }
  251. do_result:
  252.     if (If_stack == MAXIF)
  253.         ierror(NULL,510);
  254.     else
  255.         If_base[If_stack++] = !result;
  256.     break;
  257.     case 1:
  258.     if (If_stack > 1 && If_base[If_stack - 2])
  259.         break;
  260.     if (If_stack)
  261.         If_base[If_stack - 1] ^= 1;
  262.     break;
  263.     case 2:
  264.     if (If_stack)
  265.         --If_stack;
  266.     break;
  267.     }
  268.     SDisable = (If_stack) ? If_base[If_stack - 1] : 0;
  269.     return (0);
  270. }
  271.  
  272. do_label()
  273. {
  274.     char aseek[32];
  275.  
  276.     if (Src_stack == 0) {
  277.     ierror (NULL, 502);
  278.     return (-1);
  279.     }
  280.     sprintf (aseek, "%ld %ld", Src_pos[Src_stack-1], If_stack);
  281.     set_var (LEVEL_LABEL + Src_stack - 1, av[1], aseek);
  282.     return (0);
  283. }
  284.  
  285. do_goto()
  286. {
  287.     register long new;
  288.     register long pos;
  289.     register char *lab;
  290.  
  291.     if (Src_stack == 0) {
  292.     ierror (NULL, 502);
  293.     } else {
  294.     lab = get_var (LEVEL_LABEL + Src_stack - 1, av[1]);
  295.     if (lab == NULL) {
  296.         ierror (NULL, 501);
  297.     } else {
  298.         pos = atoi(lab);
  299.         fseek (Src_base[Src_stack - 1], pos, 0);
  300.         Src_pos[Src_stack - 1] = pos;
  301.         new = atoi(next_word(lab));
  302.         if (new > MAXIF)
  303.         new = MAXIF;
  304.         for (; If_stack < new; ++If_stack)
  305.         If_base[If_stack] = 0;
  306.         If_stack = new;
  307.     }
  308.     }
  309.     Exec_abortline = 1;
  310.     return (0);      /* Don't execute rest of this line */
  311. }
  312.  
  313.  
  314. do_inc(garbage, com)
  315. char *garbage;
  316. {
  317.     register char *var;
  318.     char num[32];
  319.  
  320.     if (ac == 3)
  321.     com = atoi(av[2]);
  322.     var = get_var (LEVEL_SET, av[1]);
  323.     if (var) {
  324.     sprintf (num, "%ld", atoi(var)+com);
  325.     set_var (LEVEL_SET, av[1], num);
  326.     }
  327.     return (0);
  328. }
  329.  
  330. do_input()
  331. {
  332.     char in[256];
  333.  
  334.     if (Ogets(in))
  335.     set_var (LEVEL_SET, av[1], in);
  336.     return (0);
  337. }
  338.  
  339. do_ver()
  340. {
  341.     Oputs (VERSION);
  342.     return (0);
  343. }
  344.  
  345.  
  346. /*
  347.  * CP file            (to current directory)
  348.  * CP [-r] dir            (to current directory)
  349.  * CP file file
  350.  * CP file file file... destdir
  351.  * CP [-r] dir dir dir... destdir
  352.  */
  353.  
  354. do_cp()
  355. {
  356.     register short recur, i, ierr;
  357.     register char *destname;
  358.     register char destisdir;
  359.     register FIB *fib;
  360.     char copysilent = (get_var(LEVEL_SET, V_COPYSILENT) != NULL);
  361.  
  362.     if (get_var(LEVEL_SET, V_COPYDATE) != NULL)
  363.     copysilent |= 2;
  364.  
  365.     ierr = 0;
  366.     fib = (FIB *)AllocMem(sizeof(FIB), 0);
  367.     recur = (strncmp(av[1], "-r", 2)) ? 0 : 1;
  368.     destname = av[ac - 1];
  369.  
  370.     if (ac < recur + 3) {
  371.     ++ac;
  372.     destname = "";
  373.     }
  374.     /*
  375.      *    ierr = 500;
  376.      *    goto done;
  377.      */
  378.  
  379.     destisdir = isdir(destname);
  380.     if (ac > recur + 3 && !destisdir) {
  381.     ierr = 507;
  382.     goto done;
  383.     }
  384.  
  385.     /*
  386.      * copy set:            reduce to:
  387.      *      file to file               file to file
  388.      *      dir  to file (NOT ALLOWED)
  389.      *      file to dir               dir to dir
  390.      *      dir  to dir               dir to dir
  391.      *
  392.      */
  393.  
  394.  
  395.     for (i = recur + 1; i < ac - 1; ++i) {
  396.     short srcisdir = isdir(av[i]);
  397.     if (srcisdir) {
  398.         struct FileLock *srcdir, *destdir;
  399.         if (!destisdir) {        /* disallow dir to file */
  400.         ierr = 507;
  401.         goto done;
  402.         }
  403.         if (!(destdir = Lock(destname, ACCESS_READ))) {
  404.         ierr = 205;
  405.         goto done;
  406.         }
  407.         if (!(srcdir = Lock(av[i], ACCESS_READ))) {
  408.         ierr = 205;
  409.         UnLock(destdir);
  410.         goto done;
  411.         }
  412.         ierr = copydir(srcdir, destdir, recur, copysilent, 1);
  413.         UnLock(srcdir);
  414.         UnLock(destdir);
  415.         if (ierr)
  416.         break;
  417.     } else {              /* FILE to DIR,    FILE to FILE   */
  418.         struct FileLock *destdir, *srcdir, *tmp;
  419.         char *destfilename;
  420.  
  421.         srcdir = (struct FileLock *)((PROC *)FindTask(NULL))->pr_CurrentDir;
  422.         if (destisdir) {
  423.         if ((tmp = Lock(av[i], ACCESS_READ)) == NULL || !Examine(tmp,fib)){
  424.             if (tmp)
  425.             UnLock(tmp);
  426.             ierr = 205;
  427.             goto done;
  428.         }
  429.         UnLock(tmp);
  430.         destdir = Lock(destname, ACCESS_READ);
  431.         destfilename = fib->fib_FileName;
  432.         } else {
  433.         destdir = srcdir;
  434.         destfilename = destname;
  435.         copysilent |= 1;
  436.         }
  437.         ierr = copyfile(av[i], srcdir, destfilename, destdir, copysilent, 0);
  438.         if (destisdir)
  439.         UnLock(destdir);
  440.         if (ierr)
  441.         break;
  442.     }
  443.     }
  444. done:
  445.     FreeMem(fib, sizeof(*fib));
  446.     if (ierr) {
  447.     ierror("cp", ierr);
  448.     return(20);
  449.     }
  450.     return(0);
  451. }
  452.  
  453.  
  454. copydir(srcdir, destdir, recur, silent, tab)
  455. register struct FileLock *srcdir, *destdir;
  456. {
  457.     LOCK *cwd;
  458.     register FIB *srcfib;
  459.     register LOCK *destlock, *srclock;
  460.     DATESTAMP DS;
  461.     int ierr;
  462.  
  463.     ierr = 0;
  464.     srcfib = (FIB *)AllocMem(sizeof(FIB), 0);
  465.     if (Examine(srcdir, srcfib)) {
  466.     DS = srcfib->fib_Date;
  467.     if (!(silent & 1))
  468.         printf("%*s%s (DIR)\n", tab, "", srcfib->fib_FileName);
  469.     while (ExNext(srcdir, srcfib)) {
  470.         if (srcfib->fib_DirEntryType < 0) {
  471.         ierr = copyfile(srcfib->fib_FileName,srcdir,srcfib->fib_FileName,destdir,silent,tab+4);
  472.         if (ierr)
  473.             break;
  474.         } else {
  475.         if (recur) {
  476.             cwd = CurrentDir(srcdir);
  477.             if (srclock = Lock(srcfib->fib_FileName, ACCESS_READ)) {
  478.             CurrentDir(destdir);
  479.             if (!(destlock = Lock(srcfib->fib_FileName, ACCESS_READ))) {
  480.                 if (destlock = CreateDir(srcfib->fib_FileName)) {
  481.                 UnLock(destlock);
  482.                 if (silent & 2) {
  483.                     setfiledate(srcfib->fib_FileName, &DS);
  484.                     if (srcfib->fib_Comment[0])
  485.                     SetComment(srcfib->fib_FileName, srcfib->fib_Comment);
  486.                 }
  487.                 destlock = Lock(srcfib->fib_FileName, ACCESS_READ);
  488.                 }
  489.             }
  490.             if (destlock) {
  491.                 ierr = copydir(srclock, destlock, recur, silent, tab+4);
  492.                 UnLock(destlock);
  493.             } else {
  494.                 ierr = IoErr();
  495.             }
  496.             UnLock(srclock);
  497.             } else {
  498.             ierr = IoErr();
  499.             }
  500.             CurrentDir(cwd);
  501.             if (ierr)
  502.             break;
  503.         }
  504.         }
  505.     }
  506.     } else {
  507.     ierr = IoErr();
  508.     }
  509.     FreeMem(srcfib, sizeof(FIB));
  510.     return(ierr);
  511. }
  512.  
  513.  
  514. copyfile(srcname, srcdir, destname, destdir, silent, tab)
  515. char *srcname, *destname;
  516. struct FileLock *srcdir, *destdir;
  517. {
  518.     LOCK *cwd;
  519.     DATESTAMP DS;
  520.     int i, ierr;
  521.     char *buf;
  522.     char *com = NULL;
  523.     long  buflen;
  524.     long  fhs, fhd;
  525.  
  526.     if (!(silent&1))
  527.     printf("%*s%s\n", tab, "", srcname);
  528.     for (buflen = 65536; buflen; buflen >>= 1) {
  529.     if (buf = AllocMem(buflen, MEMF_PUBLIC))
  530.         break;
  531.     }
  532.     if (buf == NULL)
  533.     return(103);    /* ERROR_NO_FREE_STORE      */
  534.     ierr = 0;
  535.     cwd = (LOCK *)CurrentDir(srcdir);
  536.  
  537.     if (silent & 2) {
  538.     register FIB *fib = (FIB *)AllocMem(sizeof(FIB), MEMF_PUBLIC);
  539.     register LOCK *lock = Lock(srcname, ACCESS_READ);
  540.     if (lock && fib && Examine(lock, fib)) {
  541.         if (fib->fib_Comment[0]) {
  542.         com = malloc(strlen(fib->fib_Comment)+1);
  543.         strcpy(com, fib->fib_Comment);
  544.         }
  545.         DS = fib->fib_Date;
  546.     } else {
  547.         silent &= ~2;
  548.     }
  549.     if (lock)
  550.         UnLock(lock);
  551.     if (fib)
  552.         FreeMem(fib, sizeof(FIB));
  553.     }
  554.     fhs = Open(srcname, 1005);
  555.     if (fhs == NULL) {
  556.     ierr = 205;
  557.     goto fail;
  558.     }
  559.     CurrentDir(destdir);
  560.     fhd = Open(destname, 1006);
  561.     if (fhd == NULL) {
  562.     ierr = IoErr();
  563.     Close(fhs);
  564.     goto fail;
  565.     }
  566.     while ((i = Read(fhs, buf, buflen)) > 0) {
  567.     if (CHECKBREAK()) {
  568.         ierr = 509;
  569.         break;
  570.     }
  571.     if (Write(fhd, buf, i) != i) {
  572.         ierr = IoErr();
  573.         break;
  574.     }
  575.     if (CHECKBREAK()) {
  576.         ierr = 509;
  577.         break;
  578.     }
  579.     }
  580.     if (i < 0)
  581.     ierr = IoErr();
  582.     Close(fhd);
  583.     Close(fhs);
  584.     if (!ierr && (silent & 2)) {
  585.     setfiledate(destname, &DS);
  586.     if (com)
  587.         SetComment(destname, com);
  588.     }
  589. fail:
  590.     if (com)
  591.     free(com);
  592.     FreeMem(buf, buflen);
  593.     CurrentDir(cwd);
  594.     return(ierr);
  595. }
  596.  
  597. do_shellstat()
  598. {
  599.     {
  600.     register short i = 0;
  601.     register unsigned long mask = ((TASK *)FindTask(NULL))->tc_SigAlloc;
  602.     printf("Signals: %08lx  ", mask);
  603.     while (mask) {
  604.         if (mask & 1)
  605.         ++i;
  606.         mask >>= 1;
  607.     }
  608.     printf("(%ld)\n", i);
  609.     }
  610.     /*
  611.     {
  612.     register PROC *proc = (PROC *)FindTask(NULL);
  613.     register CLI  *cli = (CLI *)((long)proc->pr_CLI << 2);
  614.     if (proc) {
  615.         long stack;
  616.         printf("pr_TaskNum: %ld\n", proc->pr_TaskNum);
  617.         printf("pr_CIS: %08lx\n", proc->pr_CIS);
  618.         printf("pr_COS: %08lx\n", proc->pr_COS);
  619.         printf("cli_standardinput : %08lx\n", cli->cli_StandardInput);
  620.         printf("cli_standardoutput: %08lx\n", cli->cli_StandardOutput);
  621.         printf("cli_currentinput  : %08lx\n", cli->cli_CurrentInput);
  622.         printf("cli_currentoutput : %08lx\n", cli->cli_CurrentOutput);
  623.         printf("cli_Module        : %08lx\n", cli->cli_Module);
  624.         printf("STACK:  %ld bytes, %08lx %08lx %08lx (%ld Free)\n",
  625.         cli->cli_DefaultStack*4,
  626.         proc->pr_ReturnAddr - cli->cli_DefaultStack*4, &stack, proc->pr_ReturnAddr,
  627.         (long)&stack - (long)proc->pr_ReturnAddr + cli->cli_DefaultStack*4
  628.         );
  629.     }
  630.     }
  631.     */
  632.     return(0);
  633. }
  634.  
  635. do_printenv()
  636. {
  637.     register long lock;
  638.     register FIB *fib = (FIB *)malloc(sizeof(FIB));
  639.     register short i;
  640.     char buf[256];
  641.     long fh;
  642.  
  643.     if (lock = (long)Lock("ENV:", SHARED_LOCK)) {
  644.     if (Examine(lock, fib)) {
  645.         while (ExNext(lock, fib)) {
  646.         sprintf(buf, "%-10s ", fib->fib_FileName);
  647.         Write(Cout, buf, strlen(buf));
  648.         sprintf(buf, "ENV:%s", fib->fib_FileName);
  649.         if (fh = Open(buf, 1005)) {
  650.             while ((i = Read(fh, buf, sizeof(buf))) > 0) {
  651.             Write(Cout, buf, i);
  652.             }
  653.             Close(fh);
  654.             Oputs("");
  655.         } else {
  656.             Oputs("<unable to open>");
  657.         }
  658.         }
  659.     }
  660.     UnLock(lock);
  661.     }
  662.     free(fib);
  663.     return(0);
  664. }
  665.  
  666.  
  667.  
  668. do_setenv(command)
  669. char *command;
  670. {
  671.     long fh;
  672.     char buf[256];
  673.     short ierr = 0;
  674.  
  675.     if (ac <= 2)
  676.     return(0);
  677.     strcpy(buf, "ENV:");
  678.     strcat(buf, av[1]);
  679.     if (fh = Open(buf, 1006)) {
  680.     register char *str = next_word(next_word(command));
  681.     Write(fh, str, strlen(str));
  682.     Close(fh);
  683.     } else {
  684.     ierr = IoErr();
  685.     }
  686.     return(ierr);
  687. }
  688.  
  689. do_unsetenv()
  690. {
  691.     char buf[256];
  692.     short i;
  693.  
  694.     for (i = 1; i < ac; ++i) {
  695.     strcpy(buf, "ENV:");
  696.     strcat(buf, av[i]);
  697.     DeleteFile(buf);
  698.     }
  699.     return(0);
  700. }
  701.  
  702.