home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / disks / disk458.lzh / Csh / src / comm3.c < prev    next >
C/C++ Source or Header  |  1991-02-15  |  14KB  |  782 lines
  1. /*
  2.  * COMM3.C
  3.  *
  4.  * Version 4.01A by Carlo Borreo & Cesare Dieni 17-Feb-90
  5.  *
  6.  */
  7.  
  8. do_tee()
  9. {
  10. char buf[256];
  11.  
  12. while (gets(buf)) {
  13.     puts(buf);
  14.     fprintf(stderr, "%s\n", buf);
  15.     }
  16. }
  17.  
  18. do_head(garbage, com)
  19. char *garbage;
  20. {
  21. int i, n;
  22. FILE *f;
  23. char buf[256];
  24.  
  25. if (ac>2) {
  26.     n=(int)(long)Atol(av[2]);
  27.     if (IoErr()) {
  28.         ierror(av[2],511);
  29.         return 20;
  30.         }
  31.     }
  32. else n=10;
  33. f=fopen(av[1], "r");
  34. if (f==NULL) {
  35.     pError(av[1]);
  36.     return 20;
  37.     }
  38. if (com) {    /* tail specific part */
  39.     i=0;
  40.     while (fgets(buf, 256, f) && ! dobreak()) i++;
  41.     rewind(f);
  42.     if (n>i) n=i;
  43.     i=i-n;
  44.     while (i-- && fgets(buf, 256, f) && ! dobreak()) ;
  45.     }
  46. for (i=1; i<=n && fgets(buf, 256, f) && ! dobreak(); i++)
  47.     printf("%s", buf);
  48. fclose(f);
  49. return 0;
  50. }
  51.  
  52. man(f, s)
  53. FILE *f;
  54. char *s;
  55. {
  56. char buf[256], entry[256];
  57. int len=sprintf(entry, "    %s", s);
  58.  
  59. rewind(f);
  60. do    /* look for required argument */
  61.     if (fgets(buf, 256, f) == NULL) {
  62.         fprintf(stderr, "Help not found for %s\n", s);
  63.         return;
  64.         }
  65. while ( Strncmp(entry, buf, len) );
  66. do {    /* display help */
  67.     printf("%s", buf);
  68.     if (fgets(buf, 256, f) == NULL) return;
  69.     }
  70. while ( ( ! isalphanum(*buf) ) && strncmp(buf, "    ", 4) );
  71. }
  72.  
  73. do_man()
  74. {
  75. FILE *f;
  76. register unsigned int i = 1;
  77.  
  78. f=fopen("DOC:Shell.doc", "r");
  79. if (f==NULL) {
  80.     fprintf(stderr, "You must assign directory DOC:, and copy Shell.doc there\n");
  81.     return 20;
  82.     }
  83. for (i=1; i<ac; i++) man(f, av[i]);
  84. if (ac==1) man(f, "MAN");
  85. fclose(f);
  86. return 0;
  87. }
  88.  
  89. do_assign()
  90. {
  91. switch(ac) {
  92.     case 1:  assignlist();
  93.          break;
  94.     case 2:  doassign(av[1], NULL);
  95.          break;
  96.     case 3:  doassign(av[1], av[2]);
  97.          break;
  98.     default: ierror(NULL, 500);
  99.          break;
  100.     }
  101. return 0;
  102. }
  103.  
  104. char *assign_errors[4]={
  105.     "",
  106.     "Name %s is not valid\n",
  107.     "Weird error\n",
  108.     "Can't cancel %s\n"
  109.     };
  110.  
  111. doassign(log, phy)
  112. char *log, *phy;
  113. {
  114. int last=strlen(log) - 1;
  115.  
  116. if (log[last] != ':') fprintf(stderr, "Bad name %s\n", log);
  117. else {
  118.     log[last] = 0;
  119.     fprintf(stderr,assign_errors[Assign(log, phy)],phy);
  120.     }
  121. }
  122.  
  123. assignlist()
  124. {
  125. struct DirectoryEntry *de_head=NULL, *de;
  126. char buf[256];
  127. BPTR lock;
  128. int ctr=0;
  129.  
  130. AddDADevs(&de_head, DLF_DEVICES | DLF_VOLUMES | DLF_DIRS);
  131. printf("Devices:\n");
  132. for (de=de_head; de && de->de_Type==DLX_DEVICE; de=de->de_Next) {
  133.     printf("%-8s",de->de_Name);
  134.     if (ctr++ == 5) { ctr=0; printf("\n"); }
  135.     }
  136. printf("\n\nVolumes:\n");
  137. for (    ;
  138.     de && (de->de_Type==DLX_VOLUME || de->de_Type==DLX_UNMOUNTED);
  139.     de=de->de_Next
  140.     )
  141.     printf( "%-16s %s\n",
  142.         de->de_Name,
  143.         de->de_Type == DLX_VOLUME ? "[Mounted]" : ""
  144.         );
  145. printf("\nDirectories:\n");
  146. for (; de && de->de_Type==DLX_ASSIGN; de=de->de_Next) {
  147.     if (lock=Lock(de->de_Name, ACCESS_READ)) {
  148.         PathName(lock, buf, 256L);
  149.         UnLock(lock);
  150.         }
  151.     else
  152.         strcpy(buf,"Unexisting lock");
  153.     printf("%-20s%s\n",de->de_Name,buf);
  154.     }
  155. FreeDAList(&de_head);
  156. }
  157.  
  158. do_join()
  159. {
  160. BPTR sou, dest;
  161. char *buffer;
  162. unsigned int i;
  163. long n;
  164. char *namedest=av[--ac];
  165.  
  166. get_opt("r", &i);
  167. if (options==0 && exists(namedest)) { ierror(namedest,203); return 20; }
  168. if ( (buffer=malloc(8192)) == NULL ) { ierror(NULL,103); return 20; }
  169. if ( (dest=Open(namedest, MODE_NEWFILE)) == NULL )
  170.     { pError(namedest); goto fail1; }
  171. for (i=1; i<ac; i++) {
  172.     if ( (sou=Open(av[i], MODE_OLDFILE)) == NULL ) pError(av[i]);
  173.     else
  174.         while( (n=Read(sou, buffer, 8192L)) > 0 )
  175.             if (Write(dest, buffer, n) != n)
  176.                 { pError(namedest); Close(sou); goto fail2; }
  177.     Close(sou);
  178.     }
  179. fail2:
  180.     Close(dest);
  181. fail1:
  182.     free(buffer);
  183.     return 0;
  184. }
  185.  
  186. #define BUFDIM 512L
  187. #define MAXSTR 256
  188.  
  189. int minstr;
  190.  
  191. strings_in_file(s)
  192. char *s;
  193. {
  194. char c;
  195. char readbuf[BUFDIM+1], strbuf[MAXSTR+1];
  196. register unsigned int i, strctr=0;
  197. BPTR fh;
  198. int out, n;
  199.  
  200. if ( fh=Open(s, MODE_OLDFILE) ) {
  201.     fprintf(stderr, "Strings in %s (len>=%d):\n",s,minstr);
  202.     while ( (n=(int)Read(fh, readbuf, BUFDIM)) > 0 && !CHECKBREAK() )
  203.         for (i=0; i<n; i++) {
  204.         c=readbuf[i];
  205.         if (c<0x20 || c>0x7f) {
  206.             out=(strctr>=minstr);
  207.             if (!out) strctr=0;
  208.             }
  209.         else {
  210.             strbuf[strctr++]=c;
  211.             out=(strctr>=BUFDIM);
  212.             }
  213.         if (out) {
  214.             strbuf[strctr]='\0';
  215.             puts(strbuf);
  216.             strctr=0;
  217.             }
  218.         }
  219.     Close(fh);
  220.     }
  221. else pError(s);
  222. }
  223.  
  224. do_strings()
  225. {
  226. minstr=myatoi(av[--ac],1,255);
  227. all_args("r", strings_in_file, 0);
  228. return 0;
  229. }
  230.  
  231. BPTR myfile[MAXMYFILES];
  232.  
  233. do_open()
  234. {
  235. long mode;
  236. unsigned int n;
  237.  
  238. switch (toupper(av[2][0])) {
  239.     case 'R': mode=MODE_OLDFILE; break;
  240.     case 'W': mode=MODE_NEWFILE; break;
  241.     default : ierror(NULL,500); return;
  242.     }
  243. n=(unsigned int)myatoi(av[3],0,MAXMYFILES-1); if (atoierr) return 20;
  244. if (myfile[n]) myclose(n);
  245. myfile[n]=Open(av[1],mode);
  246. return (myfile[n]==NULL);
  247. }
  248.  
  249. do_close()
  250. {
  251. register unsigned int i;
  252. int n;
  253.  
  254. if (ac==1)
  255.     for (i=1; i<MAXMYFILES; i++)
  256.         myclose(i);
  257. for (i=1; i<ac; i++) {
  258.     n=myatoi(av[i],0,MAXMYFILES-1); if (atoierr) return 20;
  259.     myclose(n);
  260.     }
  261. return 0;
  262. }
  263.  
  264. myclose(n)
  265. {
  266. if (myfile[n]) { Close(myfile[n]); myfile[n]=NULL; }
  267. }
  268.  
  269. do_fileslist()
  270. {
  271. register unsigned short i;
  272. int flag=0;
  273.  
  274. printf("Open files:");
  275. for (i=0; i<MAXMYFILES; i++)
  276.     if (myfile[i]) { printf(" %d",i); flag=1; }
  277. if (!flag) printf(" None!");
  278. printf("\n");
  279. return 0;
  280. }
  281.  
  282. BPTR extOpen(name,mode)
  283. char *name;
  284. long mode;
  285. {
  286. if (name[0]=='.') return myfile[atoi(name+1)];
  287. return Open(name,mode);
  288. }
  289.  
  290. extClose(fh)
  291. BPTR fh;
  292. {
  293. register unsigned short i;
  294.  
  295. for (i=0; i<MAXMYFILES; i++)
  296.     if (myfile[i]==fh) return;
  297. Close(fh);
  298. }
  299.  
  300. do_basename()
  301. {
  302. set_var(LEVEL_SET, av[1], BaseName(av[2]));
  303. return 0;
  304. }
  305.  
  306. do_tackon()
  307. {
  308. char buf[256];
  309.  
  310. strcpy(buf, av[2]);
  311. TackOn(buf, av[3]);
  312. set_var(LEVEL_SET, av[1], buf);
  313. return 0;
  314. }
  315.  
  316. do_resident()
  317. {
  318. unsigned int i;
  319. register struct ResidentProgramNode *p;
  320. char buf[256];
  321.  
  322. get_opt("ard", &i);
  323. if (options==0 && ac>1) options=1;
  324. switch (options) {
  325.     case 0:
  326.     ObtainSemaphore (& (ArpBase->ResPrgProtection) );
  327.     if (p=ArpBase->ResidentPrgList) {
  328.         printf("Name             Users Access\n");
  329.         for (; p; p=p->rpn_Next)
  330.             printf("%-17s%5d%6d\n",
  331.                 p->rpn_Name, p->rpn_Usage, p->rpn_AccessCnt);
  332.         }
  333.     else printf("No resident program(s)\n");
  334.     ReleaseSemaphore(& (ArpBase->ResPrgProtection) );
  335.     break;
  336.     case 1:
  337.     for (; i<ac; i++)
  338.         if (loadres(av[i]))
  339.             printf("OK! %s is now resident\n", BaseName(av[i]));
  340.         else pError(av[i]);
  341.     break;
  342.     case 2:
  343.     for (; i<ac; i++)
  344.         if (RemResidentPrg(av[i])) ierror(av[i],202);
  345.         else printf("Removed %s\n",av[i]);
  346.     break;
  347.     case 4:
  348.     for (; i<ac; i++) {
  349.         sprintf(buf,"res_%s",av[i]);
  350.         Setenv(buf,"1");
  351.         }
  352.     break;
  353.     default:
  354.     ierror(NULL,500);
  355.     break;
  356.     }
  357. return 0;
  358. }
  359.  
  360. int loadres(s)
  361. char *s;
  362. {
  363. BPTR seg;
  364.  
  365. if (seg=(BPTR)LoadPrg(s)) AddResidentPrg(seg,BaseName(s));
  366. return (seg != NULL);
  367. }
  368.  
  369. struct ProcessControlBlock pcb={
  370.     4000,        /* pcb_StackSize    */
  371.     0,        /* pcb_Pri        */
  372.     };
  373. /* remaining field are NULL */
  374.     
  375. do_truerun(avline, backflag)
  376. char *avline;
  377. {
  378. char name[200];
  379. char *FindIt();
  380.  
  381. if (backflag) {
  382.     pcb.pcb_Control=NULL;
  383.     pcb.pcb_Input=pcb.pcb_Output=Open("NIL:",MODE_OLDFILE);
  384.     }
  385. else {
  386.     pcb.pcb_Control=NULL;
  387.     pcb.pcb_Input=pcb.pcb_Output =NULL;
  388.     }
  389. if (FindIt(av[1], "", name))
  390.     ASyncRun(name,next_word(next_word(avline)),&pcb);
  391. else
  392.     ierror(av[1],205);
  393. return 0;
  394. }
  395.  
  396. int exists(name)
  397. char *name;
  398. {
  399. BPTR lock;
  400.  
  401. if (lock=Lock(name,ACCESS_READ)) {
  402.     UnLock(lock);
  403.     return 1;
  404.     }
  405. return 0;
  406. }
  407.  
  408. do_aset()
  409. {
  410. Setenv(av[1],av[2]);
  411. return 0;
  412. }
  413.  
  414. #define HTYPELINE 16L
  415.  
  416. htype_a_file(s)
  417. char *s;
  418. {
  419. BPTR fh;
  420. long n, filesize=0;
  421. char buf[HTYPELINE+1];
  422. register unsigned short i;
  423.  
  424. if ( (fh=Open(s,MODE_OLDFILE))==NULL ) { pError(s); return 20; }
  425. while ( (n=Read(fh,buf,HTYPELINE))>0 && !dobreak()) {
  426.     printf("%06lx: ",filesize);
  427.     filesize+=n;
  428.     for (i=0; i<n; i++) {
  429.         printf( (i&3) ? "%02x" : " %02x",(int)(unsigned char)buf[i]);
  430.         if (buf[i]<0x20) buf[i]='.';
  431.         }
  432.     for ( ; i<HTYPELINE; i++) {
  433.         printf( (i&3) ? "  " : "   ");
  434.         buf[i]=' ';
  435.         }
  436.     buf[i]=0;
  437.     printf("    %s\n",buf);
  438.     }
  439. Close(fh);
  440. return 0;
  441. }
  442.  
  443. do_htype()
  444. {
  445. all_args("", htype_a_file, 0);
  446. return 0;
  447. }
  448.  
  449. do_stack()
  450. {
  451. long n;
  452.  
  453. if (ac>1) {
  454.     n=Atol(av[1]);
  455.     if (!IoErr()) Mycli->cli_DefaultStack=(long)(n >> 2L);
  456.     }
  457. else printf("current stack size is %ld bytes\n",
  458.                 (long)Mycli->cli_DefaultStack << 2L);
  459. return 0;
  460. }
  461.  
  462. do_fault()
  463. {
  464. struct PERROR *p;
  465. register unsigned int i;
  466. int n;
  467.  
  468. for (i=1; i<ac; i++) {
  469.     n=myatoi(av[i],0,32767);
  470.     if (!atoierr) {
  471.         for (p=Perror; p->errnum && p->errnum!=n; p++);
  472.         if (p->errnum)
  473.             printf("Fault %d: %s\n",n,p->errstr);
  474.         else
  475.             printf("Fault %d not recognized\n",n);
  476.         }
  477.     }
  478. return 0;
  479. }
  480.  
  481. struct rpncommand {
  482.     char *str;
  483.     int parsin, parsout;
  484.     };
  485.  
  486. struct rpncommand rpn[]={
  487.     "+",    2,    1,
  488.     "-",    2,    1,
  489.     "*",    2,    1,
  490.     "/",    2,    1,
  491.     "%",    2,    1,
  492.     "&",    2,    1,
  493.     "|",    2,    1,
  494.     "~",    1,    1,
  495.     ">",    2,    1,
  496.     "<",    2,    1,
  497.     "==",    2,    1,
  498.     "!",    1,    1,
  499.     "DUP",    1,    2,
  500.     "DROP",    1,    0,
  501.     "SWAP",    2,    2,
  502.     "HELP",    0,    0,
  503.     NULL,    0,    1,    /* this looks for a number */
  504. };
  505.  
  506. do_rpn(garbage,ifflag) /* ifflag!=0 if called from if */
  507. char *garbage;
  508. {
  509. register long n0, n1;
  510. long t;
  511. unsigned int i, j;
  512. int sp=0;
  513. long stack[100];
  514. struct rpncommand *temp;
  515.  
  516. i=1;
  517. if (ifflag) get_opt("rn",&i);
  518. for (; i<ac; i++) {
  519.     for (j=0; rpn[j].str && Strcmp(rpn[j].str,av[i]); j++) ;
  520.     n0=stack[sp-1];
  521.     n1=stack[sp-2];
  522.     sp -= (rpn[j].parsin);
  523.     if (sp<0) { fprintf(stderr, "RPN: Empty stack\n"); return 1; }
  524.     switch (j) {
  525.       case 0:    n0 += n1;        break;
  526.       case 1:    n0 = n1-n0;        break;
  527.       case 2:    n0 *= n1;        break;
  528.       case 3:    n0 = n1/n0;        break;
  529.       case 4:    n0 = n1%n0;        break;
  530.       case 5:    n0 &= n1;        break;
  531.       case 6:    n0 |= n1;        break;
  532.       case 7:    n0 =  ~n0;        break;
  533.       case 8:    n0 = (n1 > n0);        break;
  534.       case 9:    n0 = (n1 < n0);        break;
  535.       case 10:    n0 = (n0 == n1);    break;
  536.       case 11:    n0 = !n0;        break;
  537.       case 12:    n1=n0;            break;
  538.       case 13:    t=n0; n0=n1; n1=t;    break;
  539.       case 14:                break;
  540.       case 15:    printf("In Commands Out\n");
  541.             for (temp=rpn; temp->str; temp++)
  542.                 printf(" %d %-10s%d\n",
  543.                 temp->parsin,temp->str,temp->parsout);
  544.             break;
  545.       default:    n0=Atol(av[i]);
  546.             if (IoErr()) {
  547.                 fprintf(stderr, "Bad RPN cmd: %s\n",av[i]);
  548.                 return 20;
  549.                 }
  550.             break;
  551.       }
  552.     stack[sp]=n0;
  553.     stack[sp+1]=n1;
  554.     sp += rpn[j].parsout;
  555.     }
  556. if (ifflag) return (int)(stack[sp-1]);    /* called from if: return top value */
  557. for (i=sp-1;(int)i>=0;i--) printf("%ld\n", stack[i]); /* else print stack */
  558. return 0;
  559. }
  560.  
  561. do_path()
  562. {
  563. union {    long *lp; long ll; } l;
  564. char buf[256];
  565.  
  566. puts("Current dir");
  567. l.lp = (long *) Mycli->cli_CommandDir;
  568. while (l.ll) {
  569.     l.ll <<= 2;
  570.     PathName(l.lp[1], buf, 256L);
  571.     puts(buf);
  572.     l.ll = *l.lp;
  573.     }
  574. puts("C:");
  575. return 0;
  576. }
  577.  
  578. do_pri()
  579. {
  580. int t, pri;
  581. struct Process *proc;
  582.  
  583. t=(int)(long)FindCLI(0L);
  584. t=myatoi(av[1],0,t); if (atoierr) return 20;
  585. pri=myatoi(av[2],-128,127); if (atoierr) return 20;
  586. Forbid();
  587. proc=(t==0 ? Myprocess : FindCLI((long)t));
  588. if (proc==NULL) fprintf(stderr, "process not found\n");
  589.     else SetTaskPri(proc, (long)pri);
  590. Permit();
  591. return 0;
  592. }
  593.  
  594. do_strleft()
  595. {
  596. char buf[256];
  597. int n;
  598.  
  599. strcpy(buf,av[2]);
  600. n=myatoi(av[3],1,strlen(buf)); if (atoierr) return 20;
  601. buf[n]='\0';
  602. set_var(LEVEL_SET, av[1], buf);
  603. return 0;
  604. }
  605.  
  606. do_strright()
  607. {
  608. char buf[256];
  609. int n;
  610.  
  611. strcpy(buf, av[2]);
  612. n=myatoi(av[3],1,strlen(buf)); if (atoierr) return 20;
  613. set_var(LEVEL_SET, av[1], buf+strlen(buf)-n);
  614. return 0;
  615. }
  616.  
  617. do_strmid()
  618. {
  619. char buf[256];
  620. int n1, n2;
  621.  
  622. strcpy(buf, av[2]);
  623. n1=myatoi(av[3],1,strlen(buf))-1; if (atoierr) return 20;
  624. if (ac>4) {
  625.     n2=myatoi(av[4],1,strlen(buf)-n1); if (atoierr) return 20;
  626.     buf[n1+n2]='\0';
  627.     }
  628. set_var(LEVEL_SET, av[1], buf+n1);
  629. return 0;
  630. }
  631.  
  632. do_strlen()
  633. {
  634. char buf[16];
  635.  
  636. sprintf(buf,"%d",strlen(av[2]));
  637. set_var(LEVEL_SET, av[1], buf);
  638. return 0;
  639. }
  640.  
  641. int atoierr;
  642.  
  643. myatoi(s,min,max)
  644. char *s;
  645. {
  646. int n;
  647.  
  648. n=(int)(long)Atol(s);
  649. if (atoierr=IoErr())
  650.     ierror(s,511);
  651.     else if (n<min || n>max) {
  652.         atoierr=1;
  653.         fprintf(stderr, "%s(%d) not in (%d,%d)\n",s,n,min,max);
  654.         }
  655. return n;
  656. }
  657.  
  658. do_fltlower()
  659. {
  660. char buf[256];
  661. char *strlwr();
  662.  
  663. while (!CHECKBREAK() && gets(buf)) puts(strlwr(buf));
  664. return 0;
  665. }
  666.  
  667. do_fltupper()
  668. {
  669. char buf[256];
  670. char *strupr();
  671.  
  672. while (!CHECKBREAK() && gets(buf)) puts(strupr(buf));
  673. return 0;
  674. }
  675.  
  676. do_uniq()
  677. {
  678. int firstline=1;
  679. char buf[256], oldbuf[256];
  680.  
  681. while (!CHECKBREAK() && gets(buf)) {
  682.     if ( firstline || strcmp(buf, oldbuf)) {
  683.         strcpy(oldbuf, buf);
  684.         puts(buf);
  685.         }
  686.     firstline=0;
  687.     }
  688. return 0;
  689. }
  690.  
  691. #define RXFB_RESULT  17
  692.  
  693. static struct rexxmsg {
  694.     struct Message cm_Node;
  695.     LONG   RFU1;
  696.     LONG   RFU2;
  697.     LONG   rm_Action;
  698.     LONG   rm_Result1;
  699.     LONG   rm_Result2;
  700.     char   *cm_Args[16];
  701.     LONG   RFU7;
  702.     LONG   RFU8;
  703.     LONG   RFU9;
  704.     LONG   RFU10;
  705.     LONG   RFU11;
  706.     LONG   RFU12;
  707. } mymsg;
  708.  
  709. do_rxsend()
  710. {
  711. int i=1, resflag;
  712. char *result;
  713. struct MsgPort *port, *reply;
  714. long len;
  715.  
  716. get_opt("r", &i);
  717. resflag=options;
  718. if (!(port = FindPort(av[i++]))) { fprintf(stderr, "No port %s!\n", av[--i]); return 20; }
  719. mymsg.cm_Node.mn_Node.ln_Type = NT_MESSAGE;
  720. mymsg.cm_Node.mn_Length = sizeof(struct rexxmsg);
  721. mymsg.rm_Action = (resflag ? 1L << RXFB_RESULT : 0);
  722. if (!(reply = CreatePort(NULL, 0L))) {
  723.     fprintf(stderr, "No reply port\n");
  724.     return 20;
  725.     }
  726. mymsg.cm_Node.mn_ReplyPort = reply;
  727.  
  728. for ( ; i<ac; i++) {
  729.     mymsg.cm_Args[0] = av[i];
  730.     mymsg.rm_Result2 = 0;    /* clear out the last result. */
  731.     PutMsg(port, &mymsg.cm_Node);
  732.     WaitPort(reply);
  733.  
  734.     if (resflag) {
  735.         result=(char *)mymsg.rm_Result2;
  736.         len=*( (long *)(result-4) );
  737.         if (len<0 || len>256)
  738.             fprintf(stderr, "Risultato troppo lungo\n");
  739.         else
  740.             printf("%s\n", result);
  741.         FreeMem(result, len);
  742.         }
  743.     }
  744.  
  745. if (reply) DeletePort(reply);
  746. return 0;
  747. }
  748.  
  749. do_rxrec()
  750. {
  751. struct MsgPort *port;
  752. struct rexxmsg *msg;
  753. char *portname, *str;
  754.  
  755. if (ac > 1)
  756.     portname=av[1];
  757. else
  758.     portname="rexx_csh";
  759.  
  760. port=CreatePort(portname, 0L);
  761. if (port==NULL) {
  762.     fprintf(stderr, "Can't have MsgPort %s\n", portname);
  763.     return 20;
  764.     }
  765. for (;;) {
  766.     WaitPort(port);
  767.     while (msg=(struct rexxmsg *)GetMsg(port)) {
  768.         if ( ! Strcmp(msg->cm_Args[0], "bye")) {
  769.             ReplyMsg((struct Message *)msg);
  770.             DeletePort(port);
  771.             return 0;
  772.             }
  773.         exec_command(msg->cm_Args[0]);
  774.         if (msg->rm_Action & (1L << RXFB_RESULT)) {
  775.             str = get_var(LEVEL_SET, v_lasterr);
  776.             msg->rm_Result2=(str) ? atoi(str) : 20;
  777.             }
  778.         ReplyMsg((struct Message *)msg);
  779.         }
  780.     }
  781. }
  782.