home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 182.lha / CShell_v3.0a / comm3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-04-28  |  9.1 KB  |  508 lines
  1. /*
  2.  * COMM3.C
  3.  *
  4.  * Version 3.00A by Carlo Borreo & Cesare Dieni 30-Oct-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=atoi(av[--ac]);
  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)myatol(av[3]);
  163. if (Errno) return 20;
  164. if (n<0 || n>MAXMYFILES) { ierror(av[3],500); return 20; }
  165. myfile[n]=Open(av[1],mode);
  166. return (myfile[n]==NULL);
  167. }
  168.  
  169. do_close()
  170. {
  171. register unsigned int i;
  172. int n;
  173.  
  174. for (i=1; i<ac; i++) {
  175.     Errno=0;
  176.     n=(int)myatol(av[i]);
  177.     if (Errno) return 20;
  178.     if (n<0 || n>MAXMYFILES) { ierror(av[i],500); return 20; }
  179.     myclose(n);
  180.     }
  181. return 0;
  182. }
  183.  
  184. myclose(n)
  185. {
  186. if (myfile[n]) { Close(myfile[n]); myfile[n]=NULL; }
  187. }
  188.  
  189. do_fileslist()
  190. {
  191. register unsigned short i;
  192. int flag=0;
  193.  
  194. printf("Open files:");
  195. for (i=0; i<MAXMYFILES; i++)
  196.     if (myfile[i]) { printf(" %d",i); flag=1; }
  197. if (!flag) printf(" None!");
  198. printf("\n");
  199. }
  200.  
  201. BPTR extOpen(name,mode)
  202. char *name;
  203. long mode;
  204. {
  205. if (name[0]=='.') return myfile[atoi(name+1)];
  206. return Open(name,mode);
  207. }
  208.  
  209. extClose(fh)
  210. BPTR fh;
  211. {
  212. register unsigned short i;
  213.  
  214. for (i=0; i<MAXMYFILES; i++)
  215.     if (myfile[i]==fh) return;
  216. Close(fh);
  217. }
  218.  
  219. do_resident(avline)
  220. char *avline;
  221. {
  222. unsigned int i;
  223. BPTR seg;
  224. struct ResidentPrgNode *p;
  225. char *args;
  226.  
  227. get_opt("ar", &i);
  228. switch (options) {
  229.     case 0:
  230.     ObtainSemaphore (& (ArpBase->ResPrgProtection) );
  231.     if (p=ArpBase->ResidentPrgList) {
  232.         printf("Name             Users\n");
  233.         for (; p; p=p->rpn_Next)
  234.             printf("%-16s %-3ld\n",p->rpn_Name,p->rpn_Usage);
  235.         }
  236.     else printf("No resident program(s)\n");
  237.     ReleaseSemaphore(& (ArpBase->ResPrgProtection) );
  238.     break;
  239.     case 1:
  240.     for (; i<ac; i++)
  241.         if ( (seg=(BPTR)LoadPrg(av[i])) && AddResidentPrg(seg,av[i]) )
  242.             printf("OK! %s is now resident\n", BaseName(av[i]));
  243.         else pError(av[i]);
  244.     break;
  245.     case 2:
  246.     for (; i<ac; i++)
  247.         if (RemResidentPrg(av[i])) ierror(av[i],202);
  248.         else printf("Removed %s\n",av[i]);
  249.     break;
  250.     default:
  251.     ierror(NULL,500);
  252.     break;
  253.     }
  254. }
  255.  
  256. struct ProcessControlBlock pcb={
  257.     4000,        /* pcb_StackSize    */
  258.     0,        /* pcb_Pri        */
  259.     };
  260. /* remaining field are NULL */
  261.     
  262. do_truerun(avline, backflag)
  263. char *avline;
  264. {
  265. char name[200];
  266. char *FindIt();
  267.  
  268. if (backflag) {
  269.     pcb.pcb_Control=NULL;
  270.     pcb.pcb_Input=pcb.p_Output=Open("NIL:",MODE_OLDFILE);
  271.     }
  272. else {
  273.     pcb.pcb_Control=PRB_SAVEIO;
  274.     pcb.pcb_Input=pcb.p_Output =NULL;
  275.     }
  276. if (FindIt(av[1], "", name))
  277.     ASyncRun(name,next_word(next_word(avline)),&pcb);
  278. else
  279.     ierror(av[1],205);
  280. return 0;
  281. }
  282.  
  283. int exists(name)
  284. char *name;
  285. {
  286. BPTR lock;
  287.  
  288. if (lock=Lock(name,ACCESS_READ)) {
  289.     UnLock(lock);
  290.     return 1;
  291.     }
  292. return 0;
  293. }
  294.  
  295. do_aset()
  296. {
  297. Setenv(av[1],av[2]);
  298. return 0;
  299. }
  300.  
  301. #define HTYPELINE 16L
  302.  
  303. htype_a_file(s)
  304. char *s;
  305. {
  306. BPTR fh;
  307. long n, filesize=0;
  308. char buf[HTYPELINE+1];
  309. register unsigned int i;
  310.  
  311. if ( (fh=Open(s,MODE_OLDFILE))==NULL ) { pError(s); return 20; }
  312. while ( (n=Read(fh,buf,HTYPELINE))>0 && !dobreak()) {
  313.     printf("%06lx: ",filesize);
  314.     filesize+=n;
  315.     for (i=0; i<n; i++) {
  316.         printf( (i&3) ? "%02x" : " %02x",(int)(unsigned char)buf[i]);
  317.         if (buf[i]<=0x20) buf[i]='.';
  318.         }
  319.     for ( ; i<HTYPELINE; i++) printf( (i&3) ? "  " : "   ");
  320.     buf[i]=0;
  321.     printf("    %s\n",buf);
  322.     }
  323. Close(fh);
  324. return 0;
  325. }
  326.  
  327. do_htype()
  328. {
  329. all_args("", htype_a_file, 0);
  330. return 0;
  331. }
  332.  
  333. do_stack()
  334. {
  335. long n;
  336.  
  337. if (ac>1) {
  338.     n=myatol(av[1]);
  339.     if (!Errno) Mycli->cli_DefaultStack=(long)(n >> 2L);
  340.     }
  341. else printf("current stack size is %ld bytes\n",
  342.                 (long)Mycli->cli_DefaultStack << 2L);
  343. }
  344.  
  345. long myatol(s)
  346. char *s;
  347. {
  348. long n;
  349.  
  350. Errno=0;
  351. n=Atol(s);
  352. if (Errno==ERRBADINT) ierror(s,511);
  353. else Errno=0;
  354. return n;
  355. }
  356.  
  357. do_fault()
  358. {
  359. struct PERROR *p;
  360. register unsigned int i;
  361. int n;
  362.  
  363. for (i=1; i<ac; i++) {
  364.     n=(int)myatol(av[i]);
  365.     if (!Errno) {
  366.         for (p=Perror; p->errnum && p->errnum!=n; p++);
  367.         if (p->errnum)
  368.             printf("Fault %d: %s\n",n,p->errstr);
  369.         else
  370.             printf("Fault %d not recognized\n",n);
  371.         }
  372.     }
  373. return 0;
  374. }
  375.  
  376. struct rpncommand {
  377.     char *str;
  378.     int parsin, parsout;
  379.     };
  380.  
  381. struct rpncommand rpn[]={
  382.     "+",    2,    1,
  383.     "-",    2,    1,
  384.     "*",    2,    1,
  385.     "/",    2,    1,
  386.     "%",    2,    1,
  387.     "&",    2,    1,
  388.     "|",    2,    1,
  389.     "~",    1,    1,
  390.     ">",    2,    1,
  391.     "<",    2,    1,
  392.     "==",    2,    1,
  393.     "!",    1,    1,
  394.     ".",    1,    0,
  395.     "CR",    0,    0,
  396.     "EXISTS", 1,    1,
  397.     "STR",    0,    1,
  398.     "PRINT",1,    0,
  399.     "$",    1,    1,
  400.     "HELP",    0,    0,
  401.     "LEN",    1,    1,
  402.     "STRCMP", 2,    1,
  403.     "[]",    2,    1,
  404.     "SETVAR", 2,    0,
  405.     "DUP",    1,    2,
  406.     "DROP",    1,    0,
  407.     "SWAP",    2,    2,
  408.     "ATOL",    1,    1,
  409.     NULL,    0,    1,    /* this looks for a number */
  410. };
  411.  
  412. do_rpn(garbage,ifflag) /* ifflag!=0 if called from if */
  413. char *garbage;
  414. {
  415. register long n0, n1;
  416. long t;
  417. unsigned int i, j;
  418. int sp=0;
  419. long stack[100];
  420. struct rpncommand *temp;
  421.  
  422. i=1;
  423. if (ifflag) get_opt("rn",&i);
  424. for (; i<ac; i++) {
  425.     for (j=0; rpn[j].str && Strcmp(rpn[j].str,av[i]); j++) ;
  426.     n0=stack[sp-1];
  427.     n1=stack[sp-2];
  428.     sp -= (rpn[j].parsin);
  429.     if (sp<0) { fprintf(stderr, "Empty stack\n"); return 1; }
  430.     switch (j) {
  431.       case 0:    n0 += n1;        break;
  432.       case 1:    n0 = n1-n0;        break;
  433.       case 2:    n0 *= n1;        break;
  434.       case 3:    n0 = n1/n0;        break;
  435.       case 4:    n0 %= n1;        break;
  436.       case 5:    n0 &= n1;        break;
  437.       case 6:    n0 |= n1;        break;
  438.       case 7:    n0 =  ~n0;        break;
  439.       case 8:    n0 = (n1 > n0);        break;
  440.       case 9:    n0 = (n1 < n0);        break;
  441.       case 10:    n0 = (n0 == n1);    break;
  442.       case 11:    n0 = !n0;        break;
  443.       case 12:    printf("%ld", n0);    break;
  444.       case 13:    printf("\n");        break;
  445.       case 14:    n0=exists(n0);        break;
  446.       case 15:    n0=(long)av[++i];
  447.             if (i==ac) { ierror(av[i-1],500); return 20; }
  448.             break;
  449.       case 16:    printf("%s",n0);    break;
  450.       case 17:    n0=(long)get_var(LEVEL_SET,n0); break;
  451.       case 18:    printf("In Commands Out\n");
  452.             for (temp=rpn; temp->str; temp++)
  453.                 printf(" %d %-10s%d\n",
  454.                 temp->parsin,temp->str,temp->parsout);
  455.             break;
  456.       case 19:    n0=(long)strlen(n0);    break;
  457.       case 20:    n0=(long)strcmp(n0,n1); break;
  458.       case 21:    n0=*((char *)(n0+n1));    break;
  459.       case 22:    set_var(LEVEL_SET,n1,n0); break;
  460.       case 23:    n1=n0;            break;
  461.       case 24:    t=n0; n0=n1; n1=t;    break;
  462.       case 25:                break;
  463.       case 26:    n0=atol(n0);        break;
  464.       default:    n0=myatol(av[i]);
  465.             if (Errno) ierror(av[i],500);
  466.             break;
  467.       }
  468.     stack[sp]=n0;
  469.     stack[sp+1]=n1;
  470.     sp += rpn[j].parsout;
  471.     }
  472. if (!ifflag) for (i=0;i<sp;i++) printf("stack[%d]: %ld\n", i, stack[i]);
  473. return (sp>0 ? (int)stack[sp-1] : 0);
  474. }
  475.  
  476. do_path()
  477. {
  478. union {    long *lp; long ll; } l;
  479. BPTR lock;
  480. char buf[256];
  481.  
  482. puts("Current dir");
  483. l.lp = (long *) Mycli->cli_CommandDir;
  484. while (l.ll) {
  485.     l.ll <<= 2;
  486.     PathName(l.lp[1], buf, 256L);
  487.     puts(buf);
  488.     l.ll = *l.lp;
  489.     }
  490. puts("C:");
  491. return 0;
  492. }
  493.  
  494. do_pri()
  495. {
  496. long t, pri;
  497.  
  498. t=myatol(av[1]);
  499. if (Errno) return 20;
  500. if (t<1 || t>20) { ierror(av[1],500); return 20; }
  501. pri=myatol(av[2]);
  502. if (Errno) return 20;
  503. if (pri<-128 || t>127) { ierror(av[2],500); return 20; }
  504. Forbid();
  505. SetTaskPri(FindCLI(t),pri);
  506. return 0;
  507. }
  508.