home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d199 / csh.lha / Csh / comm3.c < prev    next >
C/C++ Source or Header  |  1989-03-31  |  10KB  |  543 lines
  1. /*
  2.  * COMM3.C
  3.  *
  4.  * Version 3.02A by Carlo Borreo & Cesare Dieni 20-Dec-88
  5.  *
  6.  */
  7.  
  8. do_assign() {
  9. switch(ac) {
  10.     case 1:  assignlist();
  11.          break;
  12.     case 2:  doassign(av[1], NULL);
  13.          break;
  14.     case 3:  doassign(av[1], av[2]);
  15.          break;
  16.     default: ierror(NULL, 500);
  17.          break;
  18.     }
  19. return 0;
  20. }
  21.  
  22. char *assign_errors[4]={
  23.     "",
  24.     "Name %s is not valid\n",
  25.     "Weird error\n",
  26.     "Can't cancel %s\n"
  27.     };
  28.  
  29. doassign(log, phy)
  30. char *log, *phy;
  31. {
  32. int last=strlen(log) - 1;
  33.  
  34. if (log[last] != ':') fprintf(stderr, "Bad name %s\n", log);
  35. else {
  36.     log[last] = 0;
  37.     fprintf(stderr,assign_errors[Assign(log, phy)],log);
  38.     }
  39. }
  40.  
  41. assignlist()
  42. {
  43. struct DirectoryEntry *de_head=NULL, *de;
  44. char buf[256];
  45. BPTR lock;
  46. int ctr=0;
  47.  
  48. AddDADevs(&de_head, DLF_DEVICES | DLF_VOLUMES | DLF_DIRS);
  49. printf("Devices:\n");
  50. for (de=de_head; de && de->de_Type==DLX_DEVICE; de=de->de_Next) {
  51.     printf("%-8s",de->de_Name);
  52.     if (ctr++ == 5) { ctr=0; printf("\n"); }
  53.     }
  54. printf("\n\nVolumes:\n");
  55. for (    ;
  56.     de && (de->de_Type==DLX_VOLUME || de->de_Type==DLX_UNMOUNTED);
  57.     de=de->de_Next
  58.     )
  59.     printf( "%-16s %s\n",
  60.         de->de_Name,
  61.         de->de_Type == DLX_VOLUME ? "[Mounted]" : ""
  62.         );
  63. printf("\nDirectories:\n");
  64. for (; de && de->de_Type==DLX_ASSIGN; de=de->de_Next) {
  65.     if (lock=Lock(de->de_Name, ACCESS_READ)) {
  66.         PathName(lock, buf, 256L);
  67.         UnLock(lock);
  68.         }
  69.     else
  70.         strcpy(buf,"Unexisting lock");
  71.     printf("%-20s%s\n",de->de_Name,buf);
  72.     }
  73. FreeDAList(&de_head);
  74. }
  75.  
  76. do_join()
  77. {
  78. BPTR sou, dest;
  79. char *buffer;
  80. unsigned int i;
  81. long n;
  82. char *namedest=av[--ac];
  83.  
  84. get_opt("r", &i);
  85. if (options==0 && exists(namedest)) { ierror(namedest,203); return 20; }
  86. if ( (buffer=malloc(8192)) == NULL ) { ierror(NULL,103); return 20; }
  87. if ( (dest=Open(namedest, MODE_NEWFILE)) == NULL )
  88.     { pError(namedest); goto fail1; }
  89. for (i=1; i<ac; i++) {
  90.     if ( (sou=Open(av[i], MODE_OLDFILE)) == NULL ) pError(av[i]);
  91.     else
  92.         while( (n=Read(sou, buffer, 8192L)) > 0 )
  93.             if (Write(dest, buffer, n) != n)
  94.                 { pError(namedest); Close(sou); goto fail2; }
  95.     Close(sou);
  96.     }
  97. fail2:
  98.     Close(dest);
  99. fail1:
  100.     free(buffer);
  101.     return 0;
  102. }
  103.  
  104. #define BUFDIM 512L
  105. #define MAXSTR 256
  106.  
  107. int minstr;
  108.  
  109. strings_in_file(s)
  110. char *s;
  111. {
  112. char c;
  113. char readbuf[BUFDIM+1], strbuf[MAXSTR+1];
  114. register unsigned int i, strctr=0;
  115. BPTR fh;
  116. int out, n;
  117.  
  118. if ( fh=Open(s, MODE_OLDFILE) ) {
  119.     fprintf(stderr, "Strings in %s (len>=%d):\n",s,minstr);
  120.     while ( (n=(int)Read(fh, readbuf, BUFDIM)) > 0 && !CHECKBREAK() )
  121.         for (i=0; i<n; i++) {
  122.         c=readbuf[i];
  123.         if (c<0x20 || c>0x7f) {
  124.             out=(strctr>=minstr);
  125.             if (!out) strctr=0;
  126.             }
  127.         else {
  128.             strbuf[strctr++]=c;
  129.             out=(strctr>=BUFDIM);
  130.             }
  131.         if (out) {
  132.             strbuf[strctr]='\0';
  133.             puts(strbuf);
  134.             strctr=0;
  135.             }
  136.         }
  137.     Close(fh);
  138.     }
  139. else pError(s);
  140. }
  141.  
  142. do_strings()
  143. {
  144. minstr=myatoi(av[--ac],1,255);
  145. all_args("r", strings_in_file, 0);
  146. return 0;
  147. }
  148.  
  149. BPTR myfile[MAXMYFILES];
  150.  
  151. do_open()
  152. {
  153. long mode;
  154. unsigned int n;
  155.  
  156. switch (av[2][0]) {
  157.     case 'r': mode=MODE_OLDFILE; break;
  158.     case 'w': mode=MODE_NEWFILE; break;
  159.     default : ierror(NULL,500); return;
  160.     }
  161. Errno=0;
  162. n=(unsigned int)myatoi(av[3],0,MAXMYFILES); if (Errno) return 20;
  163. myfile[n]=Open(av[1],mode);
  164. return (myfile[n]==NULL);
  165. }
  166.  
  167. do_close()
  168. {
  169. register unsigned int i;
  170. int n;
  171.  
  172. for (i=1; i<ac; i++) {
  173.     Errno=0;
  174.     n=myatoi(av[i],0,MAXMYFILES); if (Errno) return 20;
  175.     myclose(n);
  176.     }
  177. return 0;
  178. }
  179.  
  180. myclose(n)
  181. {
  182. if (myfile[n]) { Close(myfile[n]); myfile[n]=NULL; }
  183. }
  184.  
  185. do_fileslist()
  186. {
  187. register unsigned short i;
  188. int flag=0;
  189.  
  190. printf("Open files:");
  191. for (i=0; i<MAXMYFILES; i++)
  192.     if (myfile[i]) { printf(" %d",i); flag=1; }
  193. if (!flag) printf(" None!");
  194. printf("\n");
  195. return 0;
  196. }
  197.  
  198. BPTR extOpen(name,mode)
  199. char *name;
  200. long mode;
  201. {
  202. if (name[0]=='.') return myfile[atoi(name+1)];
  203. return Open(name,mode);
  204. }
  205.  
  206. extClose(fh)
  207. BPTR fh;
  208. {
  209. register unsigned short i;
  210.  
  211. for (i=0; i<MAXMYFILES; i++)
  212.     if (myfile[i]==fh) return;
  213. Close(fh);
  214. }
  215.  
  216. do_resident(avline)
  217. char *avline;
  218. {
  219. unsigned int i;
  220. BPTR seg;
  221. struct ResidentPrgNode *p;
  222. char *args;
  223.  
  224. get_opt("ar", &i);
  225. switch (options) {
  226.     case 0:
  227.     ObtainSemaphore (& (ArpBase->ResPrgProtection) );
  228.     if (p=ArpBase->ResidentPrgList) {
  229.         printf("Name             Users\n");
  230.         for (; p; p=p->rpn_Next)
  231.             printf("%-16s %-3ld\n",p->rpn_Name,p->rpn_Usage);
  232.         }
  233.     else printf("No resident program(s)\n");
  234.     ReleaseSemaphore(& (ArpBase->ResPrgProtection) );
  235.     break;
  236.     case 1:
  237.     for (; i<ac; i++)
  238.         if ( (seg=(BPTR)LoadPrg(av[i])) && AddResidentPrg(seg,av[i]) )
  239.             printf("OK! %s is now resident\n", BaseName(av[i]));
  240.         else pError(av[i]);
  241.     break;
  242.     case 2:
  243.     for (; i<ac; i++)
  244.         if (RemResidentPrg(av[i])) ierror(av[i],202);
  245.         else printf("Removed %s\n",av[i]);
  246.     break;
  247.     default:
  248.     ierror(NULL,500);
  249.     break;
  250.     }
  251. return 0;
  252. }
  253.  
  254. struct ProcessControlBlock pcb={
  255.     4000,        /* pcb_StackSize    */
  256.     0,        /* pcb_Pri        */
  257.     };
  258. /* remaining field are NULL */
  259.     
  260. do_truerun(avline, backflag)
  261. char *avline;
  262. {
  263. char name[200];
  264. char *FindIt();
  265.  
  266. if (backflag) {
  267.     pcb.pcb_Control=NULL;
  268.     pcb.pcb_Input=pcb.p_Output=Open("NIL:",MODE_OLDFILE);
  269.     }
  270. else {
  271.     pcb.pcb_Control=PRB_SAVEIO;
  272.     pcb.pcb_Input=pcb.p_Output =NULL;
  273.     }
  274. if (FindIt(av[1], "", name))
  275.     ASyncRun(name,next_word(next_word(avline)),&pcb);
  276. else
  277.     ierror(av[1],205);
  278. return 0;
  279. }
  280.  
  281. int exists(name)
  282. char *name;
  283. {
  284. BPTR lock;
  285.  
  286. if (lock=Lock(name,ACCESS_READ)) {
  287.     UnLock(lock);
  288.     return 1;
  289.     }
  290. return 0;
  291. }
  292.  
  293. do_aset()
  294. {
  295. Setenv(av[1],av[2]);
  296. return 0;
  297. }
  298.  
  299. #define HTYPELINE 16L
  300.  
  301. htype_a_file(s)
  302. char *s;
  303. {
  304. BPTR fh;
  305. long n, filesize=0;
  306. char buf[HTYPELINE+1];
  307. register unsigned int i;
  308.  
  309. if ( (fh=Open(s,MODE_OLDFILE))==NULL ) { pError(s); return 20; }
  310. while ( (n=Read(fh,buf,HTYPELINE))>0 && !dobreak()) {
  311.     printf("%06lx: ",filesize);
  312.     filesize+=n;
  313.     for (i=0; i<n; i++) {
  314.         printf( (i&3) ? "%02x" : " %02x",(int)(unsigned char)buf[i]);
  315.         if (buf[i]<=0x20) buf[i]='.';
  316.         }
  317.     for ( ; i<HTYPELINE; i++) {
  318.         printf( (i&3) ? "  " : "   ");
  319.         buf[i]=' ';
  320.         }
  321.     buf[i]=0;
  322.     printf("    %s\n",buf);
  323.     }
  324. Close(fh);
  325. return 0;
  326. }
  327.  
  328. do_htype()
  329. {
  330. all_args("", htype_a_file, 0);
  331. return 0;
  332. }
  333.  
  334. do_stack()
  335. {
  336. long n;
  337.  
  338. if (ac>1) {
  339.     Errno=0;
  340.     n=Atol(av[1]);
  341.     if (!Errno) Mycli->cli_DefaultStack=(long)(n >> 2L);
  342.     }
  343. else printf("current stack size is %ld bytes\n",
  344.                 (long)Mycli->cli_DefaultStack << 2L);
  345. return 0;
  346. }
  347.  
  348. do_fault()
  349. {
  350. struct PERROR *p;
  351. register unsigned int i;
  352. int n;
  353.  
  354. for (i=1; i<ac; i++) {
  355.     n=myatoi(av[i],0,32767);
  356.     if (!Errno) {
  357.         for (p=Perror; p->errnum && p->errnum!=n; p++);
  358.         if (p->errnum)
  359.             printf("Fault %d: %s\n",n,p->errstr);
  360.         else
  361.             printf("Fault %d not recognized\n",n);
  362.         }
  363.     }
  364. return 0;
  365. }
  366.  
  367. struct rpncommand {
  368.     char *str;
  369.     int parsin, parsout;
  370.     };
  371.  
  372. struct rpncommand rpn[]={
  373.     "+",    2,    1,
  374.     "-",    2,    1,
  375.     "*",    2,    1,
  376.     "/",    2,    1,
  377.     "%",    2,    1,
  378.     "&",    2,    1,
  379.     "|",    2,    1,
  380.     "~",    1,    1,
  381.     ">",    2,    1,
  382.     "<",    2,    1,
  383.     "==",    2,    1,
  384.     "!",    1,    1,
  385.     "DUP",    1,    2,
  386.     "DROP",    1,    0,
  387.     "SWAP",    2,    2,
  388.     "HELP",    0,    0,
  389.     NULL,    0,    1,    /* this looks for a number */
  390. };
  391.  
  392. do_rpn(garbage,ifflag) /* ifflag!=0 if called from if */
  393. char *garbage;
  394. {
  395. register long n0, n1;
  396. long t;
  397. unsigned int i, j;
  398. int sp=0;
  399. long stack[100];
  400. struct rpncommand *temp;
  401.  
  402. i=1;
  403. if (ifflag) get_opt("rn",&i);
  404. for (; i<ac; i++) {
  405.     for (j=0; rpn[j].str && Strcmp(rpn[j].str,av[i]); j++) ;
  406.     n0=stack[sp-1];
  407.     n1=stack[sp-2];
  408.     sp -= (rpn[j].parsin);
  409.     if (sp<0) { fprintf(stderr, "RPN: Empty stack\n"); return 1; }
  410.     switch (j) {
  411.       case 0:    n0 += n1;        break;
  412.       case 1:    n0 = n1-n0;        break;
  413.       case 2:    n0 *= n1;        break;
  414.       case 3:    n0 = n1/n0;        break;
  415.       case 4:    n0 = n1%n0;        break;
  416.       case 5:    n0 &= n1;        break;
  417.       case 6:    n0 |= n1;        break;
  418.       case 7:    n0 =  ~n0;        break;
  419.       case 8:    n0 = (n1 > n0);        break;
  420.       case 9:    n0 = (n1 < n0);        break;
  421.       case 10:    n0 = (n0 == n1);    break;
  422.       case 11:    n0 = !n0;        break;
  423.       case 12:    n1=n0;            break;
  424.       case 13:    t=n0; n0=n1; n1=t;    break;
  425.       case 14:                break;
  426.       case 15:    printf("In Commands Out\n");
  427.             for (temp=rpn; temp->str; temp++)
  428.                 printf(" %d %-10s%d\n",
  429.                 temp->parsin,temp->str,temp->parsout);
  430.             break;
  431.       default:    Errno=0;
  432.             n0=Atol(av[i]);
  433.             if (Errno) {
  434.                 fprintf(stderr, "Bad RPN cmd: %s\n",av[i]);
  435.                 return 20;
  436.                 }
  437.             break;
  438.       }
  439.     stack[sp]=n0;
  440.     stack[sp+1]=n1;
  441.     sp += rpn[j].parsout;
  442.     }
  443. if (ifflag) return (int)(stack[sp-1]);    /* called from if: return top value */
  444. for (i=sp-1;(int)i>=0;i--) printf("%ld\n", stack[i]); /* else print stack */
  445. return 0;
  446. }
  447.  
  448. do_path()
  449. {
  450. union {    long *lp; long ll; } l;
  451. BPTR lock;
  452. char buf[256];
  453.  
  454. puts("Current dir");
  455. l.lp = (long *) Mycli->cli_CommandDir;
  456. while (l.ll) {
  457.     l.ll <<= 2;
  458.     PathName(l.lp[1], buf, 256L);
  459.     puts(buf);
  460.     l.ll = *l.lp;
  461.     }
  462. puts("C:");
  463. return 0;
  464. }
  465.  
  466. do_pri()
  467. {
  468. int t, pri;
  469. struct Process *proc;
  470.  
  471. t=myatoi(av[1],0,20); if (Errno) return 20;
  472. pri=myatoi(av[2],-128,127); if (Errno) return 20;
  473. Forbid();
  474. proc=(t==0 ? Myprocess : FindCLI((long)t));
  475. if (proc==NULL) fprintf(stderr, "process not found\n");
  476.     else SetTaskPri(proc, (long)pri);
  477. Permit();
  478. return 0;
  479. }
  480.  
  481. do_strleft()
  482. {
  483. char buf[256];
  484. int n;
  485.  
  486. strcpy(buf,av[2]);
  487. n=myatoi(av[3],1,strlen(buf)); if (Errno) return 20;
  488. buf[n]='\0';
  489. set_var(LEVEL_SET, av[1], buf);
  490. return 0;
  491. }
  492.  
  493. do_strright()
  494. {
  495. char buf[256];
  496. int n;
  497.  
  498. strcpy(buf, av[2]);
  499. n=myatoi(av[3],1,strlen(buf)); if (Errno) return 20;
  500. set_var(LEVEL_SET, av[1], buf+strlen(buf)-n);
  501. return 0;
  502. }
  503.  
  504. do_strmid()
  505. {
  506. char buf[256];
  507. int n1, n2;
  508.  
  509. strcpy(buf, av[2]);
  510. n1=myatoi(av[3],1,strlen(buf))-1; if (Errno) return 20;
  511. if (ac>4) {
  512.     n2=myatoi(av[4],1,strlen(buf)-n1);
  513.     if (Errno) return 20;
  514.     buf[n1+n2]='\0';
  515.     }
  516. set_var(LEVEL_SET, av[1], buf+n1);
  517. return 0;
  518. }
  519.  
  520. do_strlen()
  521. {
  522. char buf[16];
  523.  
  524. sprintf(buf,"%d",strlen(av[2]));
  525. set_var(LEVEL_SET, av[1], buf);
  526. return 0;
  527. }
  528.  
  529. myatoi(s,min,max)
  530. char *s;
  531. {
  532. long n;
  533.  
  534. Errno=0;
  535. n=Atol(s);
  536. if (Errno==ERRBADINT) ierror(s,511);
  537.     else if (n<min || n>max) {
  538.         Errno=ERRBADINT;
  539.         printf("%s not in (%d,%d)\n",s,min,max);
  540.         }
  541. return (int)n;
  542. }
  543.