home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 255.lha / Shell_v3.03a / src / comm1.c < prev    next >
C/C++ Source or Header  |  1989-05-26  |  18KB  |  854 lines
  1. /*
  2.  * COMM1.C
  3.  *
  4.  * Matthew Dillon, August 1986
  5.  *
  6.  * Version 2.07M by Steve Drew 10-Sep-87
  7.  *
  8.  * Version 3.03A by Carlo Borreo & Cesare Dieni 12-May-89
  9.  *
  10.  */
  11.  
  12. extern char *v_passed, *v_gotofwd, *v_cwd, *v_lasterr;
  13.  
  14. #define DIR_SHORT 0x01
  15. #define DIR_FILES 0x02
  16. #define DIR_DIRS  0x04
  17. #define DIR_NOCOL 0x08
  18.  
  19. extern int has_wild;
  20. char cwd[256];
  21.  
  22. /*
  23.     Parse the options specified in sw[]
  24.     Setting a bit in global variable options
  25.     for each one found
  26. */
  27.  
  28. get_opt(sw,count)
  29. char *sw;
  30. int *count;
  31. {
  32. register char *c,*s;
  33. unsigned int l,i = 0;
  34.  
  35. options=0;
  36. while((++i < ac) && (av[i][0] == '-')) {
  37.     for (c = av[i]+1; *c ; c++) {
  38.         for(l = 0,s = sw;*s && *s != *c; ++s) ++l;
  39.         if (*s) options |= (1 << l);
  40.         }
  41.     }
  42. *count = i;
  43. }
  44.  
  45. do_sleep()
  46. {
  47. int i;
  48.  
  49. if (ac == 2) for (i=atoi(av[1]); i>0 && !CHECKBREAK(); i-=2) Delay(100L);
  50. return 0;
  51. }
  52.  
  53. do_protect()
  54. {
  55. register long mask=0xf;
  56. register char *s, *p, *flags="DEWRAPSH";
  57. register unsigned int i;
  58. for (s=av[--ac]; *s; s++)
  59.     if (p=index(flags,Toupper(*s))) mask^=(1 << (p-flags));
  60.     else ierror(av[ac],500);
  61. for (i=1; i<ac; i++) if (!SetProtection(av[i],mask)) pError(av[i]);
  62. return 0;
  63. }
  64.  
  65. do_filenote()
  66. {
  67. char *note=av[--ac];
  68. register unsigned int i;
  69.  
  70. for (i=1; i<ac; i++) if (!SetComment(av[i], note)) pError(av[i]);
  71. return 0;
  72. }
  73.  
  74. do_cat()
  75. {
  76. FILE *fopen(), *fi;
  77. register unsigned int lctr;
  78. unsigned int i;
  79. char buf[256];
  80.  
  81. get_opt("n",&i);
  82. if (i>=ac) {
  83.     if (has_wild) { printf("No files matching\n"); return 20; }
  84.     lctr=0;
  85.     while (gets(buf) && !dobreak()) {
  86.         if (options) printf("%4d ",++lctr);
  87.         puts(buf);
  88.         }
  89.     }
  90. for (; i<ac; i++)
  91.     if (fi = fopen (av[i], "r")) {
  92.         lctr=0;
  93.         while (fgets(buf,256,fi) && !dobreak()) {
  94.             if (options) printf("%4d ",++lctr);
  95.             printf("%s",buf);
  96.             }
  97.         fclose (fi);
  98.         }
  99.     else pError(av[i]);
  100. return 0;
  101. }
  102.  
  103. do_info()
  104. {
  105. BPTR lock;
  106. struct InfoData *info;
  107. unsigned int size, free;
  108. char *p,*s,*state;
  109. struct DirectoryEntry *de_head=NULL, *de;
  110.  
  111. info=(struct InfoData *)AllocMem((long)sizeof(struct InfoData),MEMF_PUBLIC);
  112. AddDADevs(&de_head, DLF_DEVICES | DLF_DISKONLY );
  113. Myprocess->pr_WindowPtr = (APTR)(-1);
  114. printf ("Unit  Size  Bytes  Used Blk/By-Free Full Errs  Status    Name\n");
  115. for (de=de_head; de; de=de->de_Next) {
  116.     printf("%-5s",de->de_Name);
  117.     if (lock=Lock(de->de_Name,ACCESS_READ)) {
  118.         if (Info(lock, info)) {
  119.         s = get_pwd(lock);
  120.         if (p=index(s,':')) *p = '\0';
  121.         size = ((info->id_NumBlocks + 2)* info->id_BytesPerBlock)/ 1024;
  122.         free = (((info->id_NumBlocks-info->id_NumBlocksUsed))*
  123.                info->id_BytesPerBlock)/ 1024;
  124.         switch(info->id_DiskState) {
  125.             case ID_WRITE_PROTECTED: state="Read Only "; break;
  126.             case ID_VALIDATED:     state="Read/Write"; break;
  127.             case ID_VALIDATING:     state="Validating"; break;
  128.             }
  129.         printf("%4d%c%6ld%7ld%7ld%4d%c%4ld%%%4ld  %s %s\n",
  130.             (size>1024) ? ((size+512) >> 10) : size,
  131.             (size>1024) ? 'M' : 'K',
  132.             info->id_BytesPerBlock,
  133.             info->id_NumBlocksUsed,
  134.             info->id_NumBlocks-info->id_NumBlocksUsed,
  135.             (free>1024) ? ((free+512) >> 10) : free,
  136.             (free>1024) ? 'M' : 'K',
  137.             (info->id_NumBlocksUsed * 100)/info->id_NumBlocks,
  138.             info->id_NumSoftErrors,
  139.             state,
  140.             s);
  141.         }
  142.         else pError (de->de_Name);
  143.         UnLock(lock);
  144.         }
  145.     else puts("  No disk present");
  146.     }
  147. FreeDAList(&de_head);
  148. Myprocess->pr_WindowPtr = NULL;
  149. FreeMem(info,(long)sizeof(struct InfoData));
  150. return 0;
  151. }
  152.  
  153. /* things shared with display_file */
  154.  
  155. char lspec[128];
  156. int filecount, col;
  157. long bytes, blocks;
  158.  
  159. /*
  160.  * the args passed to do_dir will never be expanded
  161.  */
  162. do_dir()
  163. {
  164.    void display_file();
  165.    int i;
  166.  
  167.    col = filecount = 0;
  168.    bytes = blocks = 0L;
  169.    *lspec = '\0';
  170.  
  171.    get_opt("sfdc",&i);
  172.  
  173.    if (ac == i) {
  174.       ++ac;
  175.       av[i] = "";
  176.    }
  177.    if (!(options & (DIR_FILES | DIR_DIRS)))  options|=(DIR_FILES | DIR_DIRS);
  178.  
  179.    for (; i < ac && !CHECKBREAK(); ++i) {
  180.       char **eav;
  181.       int c,eac;
  182.       if (!(eav = expand(av[i], &eac))) continue;
  183.       QuickSort(eav, eac);
  184.       for(c=0;c < eac && !breakcheck();++c) display_file(options,eav[c]);
  185.       free_expand (eav);
  186.    }
  187.    if (col)  printf("\n");
  188.    if (filecount > 1) {
  189.       blocks += filecount; /* account for dir blocks */
  190.       printf (" %ld Blocks, %ld Bytes used in %d files\n", blocks, bytes, filecount);
  191.    }
  192.    return 0;
  193. }
  194.  
  195. void
  196. display_file(options,filestr)
  197. int options;
  198. char *filestr;
  199. {
  200.    long atol();
  201.    int isadir,slen;
  202.    char sc;
  203.    char *c,*s,*fi;
  204.    BPTR lock;
  205.  
  206. /*    if current dir different from lspec then
  207.     look for ':' or '/' if found lock it and get_pwd.
  208.     else then use cwd.
  209. */
  210.    for(s = c = filestr; *c; ++c) if (*c == ':' || *c == '/') s = c;
  211.    if (*s == ':') ++s;
  212.    sc = *s;
  213.    *s = '\0';
  214.    c = filestr;
  215.    if (!*c) c = cwd;
  216.    if (strcmp (c, &lspec))  {
  217.     strcpy(lspec, c);
  218.     if (col) printf("\n");
  219.     if (lock=Lock(c,SHARED_LOCK)) {
  220.         printf("Directory of %s\n", get_pwd(lock));
  221.         UnLock(lock);
  222.         }
  223.     col = 0;
  224.     }
  225.    *s = sc;
  226.    if (sc == '/') s++;
  227.    slen = strlen(s);
  228.    fi = s + slen + 1;
  229.    isadir = (fi[12] =='D');
  230.  
  231.    if (!(((options & DIR_FILES) && !isadir) ||
  232.       ((options & DIR_DIRS) &&  isadir)))
  233.       return;
  234.    if (isadir && !(options & DIR_NOCOL)) printf ("\23333m");
  235.    if (options & DIR_SHORT) {
  236.     if (col==3 && slen>18) { printf("\n"); col = 0; }
  237.     if (slen>18) { printf(" %-37s",s); col+= 2; }
  238.         else { printf(" %-18s",s); col++; }
  239.     if (col > 3) { printf("\n"); col=0; }
  240.     }
  241.    else printf("   %-24s %s",s ,fi);
  242.    if (isadir && !(options & DIR_NOCOL)) printf("\2330m");
  243.    fflush(stdout);
  244.    fi[16] = fi[21] = '\0';
  245.    bytes  += atol(fi+10);
  246.    blocks += atol(fi+17);
  247.    filecount++;
  248.    return;
  249. }
  250.  
  251. do_quit()
  252. {
  253. if (Src_stack) {
  254.     Quit = 1;
  255.     return(do_return());
  256.     }
  257. main_exit(0);
  258. }
  259.  
  260. do_echo(str)
  261. register char *str;
  262. {
  263. char nl=1;
  264.  
  265. for (; *str && *str != ' '; ++str);
  266. if (*str==' ') ++str;
  267. if (av[1] && !strcmp(av[1],"-n")) {
  268.     nl = 0;
  269.     str += 2;
  270.     if (*str==' ') ++str;
  271.     }
  272. printf("%s",str);
  273. if (nl) printf("\n");
  274. fflush(stdout);
  275. return 0;
  276. }
  277.  
  278. /* gets a line from file, joining two lines if the first ends in '\' */
  279.  
  280. char *myfgets(buf, buflen, file)
  281. char *buf;
  282. FILE *file;
  283. {
  284. char *bufptr=buf;
  285. int remain=buflen, n, flag;
  286.  
  287. do {
  288.     if (fgets(bufptr, remain, file)==NULL) {
  289.         if (remain != buflen)
  290.             fprintf(stderr,"Source: file ends in '\\'\n");
  291.         return NULL;
  292.         }
  293.     n=strlen(buf);
  294.     bufptr += n;
  295.     if (flag= (*(bufptr-2)=='\\')) bufptr-=2;
  296.     remain -= (n+2);
  297.     } while (flag);
  298. return buf;
  299. }
  300.  
  301. do_source(str)
  302. char *str;
  303. {
  304. register FILE *fi;
  305. char buf[256];
  306.  
  307. if (Src_stack == MAXSRC) {
  308.     ierror(NULL,217);
  309.     return -1;
  310.     }
  311. if ((fi = fopen (av[1], "r")) == 0) { pError(av[1]); return -1;    }
  312. set_var(LEVEL_SET, v_passed, next_word(next_word(str)));
  313. ++H_stack;
  314. Src_pos[Src_stack] = 0;
  315. Src_base[Src_stack] = (long)fi;
  316. ++Src_stack;
  317. while (myfgets (buf, 256, fi) && !dobreak()) {
  318.     int len = strlen(buf);
  319.     buf[len-1] = '\0';
  320.     Src_pos[Src_stack - 1] += len;
  321.     if (Verbose && !forward_goto) fprintf(stderr,"%s\n",buf);
  322.     exec_command (buf);
  323.     }
  324. --H_stack;
  325. --Src_stack;
  326. if (forward_goto) ierror(NULL,501);
  327. forward_goto = 0;
  328. unset_level(LEVEL_LABEL + Src_stack);
  329. unset_var(LEVEL_SET, v_gotofwd);
  330. unset_var(LEVEL_SET, v_passed);
  331. fclose (fi);
  332. return 0;
  333. }
  334.  
  335. /*
  336.  * return ptr to string that contains full cwd spec.
  337.  */
  338. char *get_pwd(flock)
  339. BPTR flock;
  340. {
  341. static char pwdstr[130];
  342. PathName(flock, pwdstr, 128L);
  343. return pwdstr;
  344. }
  345.  
  346. /*
  347.  * set process cwd name and $_cwd, if str != NULL also print it.
  348.  */
  349. do_pwd(str)
  350. char *str;
  351. {
  352. if (Myprocess->pr_CurrentDir == 0)
  353.     attempt_cd(":"); /* if we just booted 0 = root lock */
  354. strcpy(cwd,get_pwd(Myprocess->pr_CurrentDir,1));
  355. if (str) puts(cwd);
  356. set_var(LEVEL_SET, v_cwd, cwd);
  357. /* put the current dir name in our CLI task structure */
  358. CtoBStr(cwd, Mycli->cli_SetName, 128L);
  359. }
  360.  
  361. /*
  362.  * CD
  363.  *
  364.  * CD(str, 0)      -do CD operation.
  365.  *
  366.  *    standard operation: breakup path by '/'s and process independantly
  367.  *    x:    -reset cwd base
  368.  *    ..    -remove last cwd element
  369.  *    N     -add N or /N to cwd
  370.  */
  371.  
  372. do_cd(str)
  373. char *str;
  374. {
  375.    char sc, *ptr;
  376.    int err=0;
  377.  
  378.    str = next_word(str);
  379.    if (*str == '\0') {
  380.       puts(cwd);
  381.       return(0);
  382.    }
  383.    str[strlen(str)+1] = '\0';        /* add second \0 on end */
  384.    while (*str) {
  385.       for (ptr = str; *ptr && *ptr != '/' && *ptr != ':'; ++ptr);
  386.       switch (*ptr) {
  387.       case ':':
  388.       sc = ptr[1];
  389.       ptr[1] = '\0';
  390.       err = attempt_cd(str);
  391.       ptr[1] = sc;
  392.       break;
  393.       case '\0':
  394.       case '/':
  395.       *ptr = '\0';
  396.       if (strcmp(str, "..") == 0 || str == ptr)
  397.          str = "/";
  398.       if (*str) err = attempt_cd(str);
  399.       break;
  400.       }
  401.       if (err) break;
  402.       str = ptr + 1;
  403.    }
  404.    do_pwd(NULL);      /* set $_cwd */
  405.    return err;
  406. }
  407.  
  408. attempt_cd(str)
  409. char *str;
  410. {
  411. BPTR oldlock, filelock;
  412.  
  413. if (filelock=Lock(str, ACCESS_READ)) {
  414.     if (isdir(str)) {
  415.         if (oldlock=CurrentDir(filelock)) UnLock(oldlock);
  416.         return (0);
  417.         }
  418.     UnLock(filelock);
  419.     ierror(str, 212);
  420.     }
  421. else ierror(str, 205);
  422. return -1;
  423. }
  424.  
  425. do_mkdir()
  426. {
  427. register unsigned int i;
  428. BPTR lock;
  429.  
  430. for (i=1; i<ac; ++i) {
  431.     if (exists(av[i])) ierror(av[i],203);
  432.     else if (lock=CreateDir(av[i])) UnLock (lock);
  433.     else pError(av[i]);
  434.     }
  435. return 0;
  436. }
  437.  
  438. do_mv()
  439. {
  440. char *dest, buf[256];
  441. int dirflag;
  442. register unsigned int i;
  443.  
  444. dirflag=isdir(dest=av[--ac]);
  445. if (ac>3 && !dirflag) { ierror(dest, 507); return (-1); }
  446. for (i=1; i<ac; ++i) {
  447.     strcpy(buf, dest);
  448.     if (dirflag) TackOn(buf, BaseName(av[i]));
  449.     if (Rename(av[i], buf)==0)
  450.         { pError(av[i]); return -1; }
  451.     }
  452. return 0;
  453. }
  454.  
  455. int dirstoo;
  456.  
  457. all_args(args, action, dirsflag)
  458. char *args;
  459. int (*action)();
  460. {
  461. unsigned int i;
  462.  
  463. get_opt(args, &i);
  464. dirstoo=dirsflag;
  465. for (; i<ac && !dobreak(); ++i)
  466.     if (isdir(av[i])) {
  467.         if (options & 1) recurse(av[i], action);
  468.             else if (dirstoo) (*action)(av[i]);
  469.         }
  470.     else (*action)(av[i]);
  471. return 0;
  472. }
  473.  
  474. char *searchstring;
  475.  
  476. search_file(s)
  477. char *s;
  478. {
  479. FILE *fopen(), *fi;
  480. unsigned int lctr, len=strlen(searchstring);
  481. int yesno;
  482. char buf[256], lowbuf[256], first;
  483. register char *p, *l, *t;
  484.  
  485. if (!(options & 2)) for (t=searchstring; *t=Toupper(*t); t++);
  486. first=*searchstring;
  487. if ((fi=fopen(s, "r"))==NULL) { pError(s); return; }
  488. lctr=0;
  489. if (!(options & 32)) printf("Examining %s...\n",s);
  490. while (fgets(buf,256,fi) && !dobreak()) {
  491.     lctr++;
  492.     if (options & 4) yesno=compare_ok(searchstring,buf);
  493.     else {
  494.         yesno=0;
  495.         p=buf;
  496.         if (!(options & 2)) {
  497.             l=lowbuf;            /* p is already =buf */
  498.             while (*l++=Toupper(*p++));    /* lowbuf=upper(buf) */
  499.             p=lowbuf;
  500.             }
  501.         while (p=index(p,first))
  502.             if (!strncmp(p++,searchstring,len)) { yesno=1; break; }
  503.         }
  504.     if (yesno ^ ((options & 16)!=0) ) {
  505.             /* default: print line numbers */
  506.         if (!(options & 8)) printf("%4d ",lctr);
  507.         printf("%s",buf);
  508.         }
  509.     }
  510. fclose (fi);
  511. }
  512.  
  513. do_search()
  514. {
  515. searchstring=av[--ac];
  516. all_args("rcwneq", search_file, 0);
  517. return 0;
  518. }
  519.  
  520. rm_file(file)
  521. char *file;
  522. {
  523. if (has_wild) printf(" %s...",file);
  524. if (options & 2) SetProtection(file,0L);
  525. if (!DeleteFile(file)) pError (file); else if (has_wild) printf("Deleted\n");
  526. }
  527.  
  528. do_rm()
  529. {
  530. all_args("rp", rm_file, 1);
  531. return 0;
  532. }
  533.  
  534. recurse(name, action)
  535. char *name;
  536. int (*action)();
  537. {
  538. register BPTR lock, cwd;
  539. register FIB *fib=(FIB *)AllocMem((long)sizeof(FIB),MEMF_PUBLIC);
  540. char *namecopy=malloc(256);
  541.  
  542. if (name[0] =='\0') return;
  543. namecopy[0]=0;
  544. if (lock=Lock(name,ACCESS_READ)) {
  545.     cwd =CurrentDir(lock);
  546.     if (Examine(lock, fib))
  547.     while (ExNext(lock, fib) && !CHECKBREAK()) {
  548.         if (*namecopy) { (*action)(namecopy); namecopy[0]=0; }
  549.         if (fib->fib_DirEntryType>=0) recurse(fib->fib_FileName,action);
  550.         else strcpy(namecopy,fib->fib_FileName);
  551.         }
  552.     if (*namecopy) (*action)(namecopy);
  553.     UnLock(CurrentDir(cwd));
  554.     if (dirstoo) (*action)(name);
  555.     }
  556. else pError(name);
  557. free(namecopy);
  558. FreeMem(fib, (long)sizeof(FIB));
  559. }
  560.  
  561. do_history()
  562. {
  563. register struct HIST *hist;
  564. int i = H_tail_base;
  565. int len = (av[1]) ? strlen(av[1]) : 0;
  566.  
  567. for (hist = H_tail; hist && !dobreak(); hist = hist->prev)
  568.     if (len == 0 || !strncmp(av[1], hist->line, len))
  569.         printf("%3d %s\n", i++, hist->line);
  570. return 0;
  571. }
  572.  
  573. do_mem()
  574. {
  575. long cfree, ffree;
  576. extern long AvailMem();
  577.  
  578. Forbid();
  579. cfree = AvailMem (MEMF_CHIP);
  580. ffree = AvailMem (MEMF_FAST);
  581. Permit();
  582. if (ffree) printf ("FAST memory: %ld\nCHIP memory: %ld\n", ffree, cfree);
  583. printf("Total  Free: %ld\n", cfree+ffree);
  584. return 0;
  585. }
  586.  
  587. /* forline i RAM:temp echo line $_linenum: $i */
  588.  
  589. do_forline()
  590. {
  591. char vname[33], buf[256];
  592. register unsigned short lctr;
  593. FILE *f;
  594. char *cstr;
  595. static char *linenumname="_linenum";
  596.  
  597. strcpy(vname,av[1]);
  598. f=fopen(av[2],"r");
  599. if (f==NULL) pError(av[2]);
  600. lctr=0;
  601. ++H_stack;
  602. cstr = compile_av (av, 3, ac, ' ');
  603. while (fgets(buf,256,f) && !dobreak()) {
  604.     buf[strlen(buf)-1]='\0';    /* remove CR */
  605.     lctr++;
  606.     set_var(LEVEL_SET, vname, buf);
  607.     sprintf(buf,"%d",lctr);
  608.     set_var(LEVEL_SET, linenumname, buf);
  609.     exec_command(cstr);
  610.     }
  611. fclose(f);
  612. --H_stack;
  613. free (cstr);
  614. unset_var (LEVEL_SET, vname);
  615. unset_var (LEVEL_SET, linenumname);
  616. return 0;
  617. }
  618.  
  619. /* fornum i 1 10 echo $i */
  620.  
  621. do_fornum()
  622. {
  623. char vname[33], buf[16];
  624. int n1, n2;
  625. char *cstr;
  626. register int i;
  627.  
  628. strcpy(vname,av[1]);
  629. n1=myatoi(av[2],0 ,32767); if (Errno) return 20;
  630. n2=myatoi(av[3],n1,    32767); if (Errno) return 20;
  631. ++H_stack;
  632. cstr = compile_av (av, 4, ac, ' ');
  633. for (i=n1; i<=n2 && !CHECKBREAK(); i++) {
  634.     sprintf(buf,"%d",i);
  635.     set_var (LEVEL_SET, vname, buf);
  636.     exec_command(cstr);
  637.     }
  638. --H_stack;
  639. free (cstr);
  640. unset_var (LEVEL_SET, vname);
  641. return 0;
  642. }
  643.  
  644. /*
  645.  * foreach var_name  ( str str str str... str ) commands
  646.  * spacing is important (unfortunately)
  647.  *
  648.  * ac=0    1 2 3 4 5 6 7
  649.  * foreach i ( a b c ) echo $i
  650.  * foreach i ( *.c ) "echo -n "file ->";echo $i"
  651.  */
  652.  
  653. do_foreach()
  654. {
  655. register int cstart, cend;
  656. register char *cstr;
  657. char **fav;
  658. char vname[33];
  659. int i;
  660.  
  661. get_opt("v",&i);
  662. strcpy(vname, av[i++]);
  663. if (*av[i] == '(') i++;
  664. cstart = i;
  665. while (i<ac && *av[i] != ')') i++;
  666. if (i > ac) { fprintf(stderr,"')' expected\n"); return 20; }
  667. ++H_stack;
  668. cend = i;
  669.  
  670. fav = (char **)malloc(sizeof(char *) * (ac));
  671. cstr = compile_av (av, cend + 1, ac, ' ');
  672.  
  673. for (i = cstart; i < cend; ++i) fav[i] = av[i];
  674.  
  675. for (i = cstart; i<cend && !CHECKBREAK(); ++i) {
  676.     set_var (LEVEL_SET, vname, fav[i]);
  677.     if (options & 1) printf("foreach: %s\n", fav[i]);
  678.     exec_command(cstr);
  679.     }
  680. --H_stack;
  681. free (fav);
  682. free (cstr);
  683. unset_var (LEVEL_SET, vname);
  684. return 0;
  685. }
  686.  
  687. do_forever(str)
  688. char *str;
  689. {
  690. int rcode = 0;
  691. char *ptr = next_word(str);
  692.  
  693. ++H_stack;
  694. for (;;) {
  695.     if (CHECKBREAK()) { rcode = 20; break; }
  696.     if (exec_command (ptr) < 0) {
  697.         str = get_var(LEVEL_SET, v_lasterr);
  698.         rcode = (str) ? atoi(str) : 20;
  699.         break;
  700.         }
  701.     }
  702. --H_stack;
  703. return rcode;
  704. }
  705.  
  706. do_exec(str)
  707. char *str;
  708. {
  709. return exec_command(next_word(str));
  710. }
  711.  
  712. extern struct Window *w;
  713. extern struct IntuitionBase *IntuitionBase;
  714.  
  715. do_window()
  716. {
  717. long x, y, maxwidth, maxheight, arg[5];
  718. unsigned int i;
  719. struct Screen *screen;
  720. struct Window *window;
  721.  
  722. get_opt("slfbaq", &i);
  723. if (options & 1)
  724.     SizeWindow(w, (long)(w->MinWidth-w->Width), (long)(w->MinHeight-w->Height));
  725. if (options & 2) {
  726.     x=-w->LeftEdge;
  727.     y=-w->TopEdge;
  728.     MoveWindow(w,x,y);
  729.     x=IntuitionBase->ActiveScreen->Width -w->Width;
  730.     y=IntuitionBase->ActiveScreen->Height-w->Height;
  731.     SizeWindow(w,x,y);
  732.     }
  733. if (options & 4) WindowToFront(w);
  734. if (options & 8) WindowToBack(w);
  735. if (options & 16) ActivateWindow(w);
  736. if(ac >= 5) {
  737.     for(i=1; i<5; i++) {
  738.         arg[i] = myatoi(av[i],0,1023);
  739.         if (Errno) return 20;
  740.         }
  741.     maxwidth = w->WScreen->Width;
  742.     maxheight= w->WScreen->Height;
  743.     if (arg[3] > maxwidth - arg[1] || arg[4] > maxheight- arg[2]) {
  744.         ierror(NULL, 500);
  745.         return 20;
  746.         }
  747.     x = -w->LeftEdge;
  748.     y = -w->TopEdge;
  749.     MoveWindow(w, x, y);
  750.     x = arg[3] - w->Width;
  751.     y = arg[4] - w->Height;
  752.     SizeWindow(w, x, y);
  753.     x = arg[1];
  754.     y = arg[2];
  755.     MoveWindow(w, x, y);
  756.     }
  757. if(options & 32) {
  758.     for (screen=IntuitionBase->FirstScreen; screen; screen=screen->NextScreen) {
  759.         printf("\nScreen \"%s\" (%d,%d,%dx%d):\n",
  760.             screen->Title,
  761.             screen->LeftEdge,
  762.             screen->TopEdge,
  763.             screen->Width,
  764.             screen->Height
  765.             );
  766.         for (window=screen->FirstWindow; window; window=window->NextWindow) {
  767.         printf("\tWindow\t\"%s\" (%d,%d,%dx%d)\n",
  768.             window->Title,
  769.             window->LeftEdge,
  770.             window->TopEdge,
  771.             window->Width,
  772.             window->Height
  773.             );
  774.         }
  775.         }
  776.     return 0;
  777.     }
  778. Delay(25L); /* pause 1/2 sec. before trying to print */
  779. printf("\014");
  780. return 0;
  781. }
  782.  
  783. setsystemtime(ds)
  784. struct DateStamp *ds;
  785. {
  786. struct timerequest tr;
  787. long secs= ds->ds_Days*86400 + ds->ds_Minute*60 + ds->ds_Tick/TICKS_PER_SECOND;
  788.  
  789. if (OpenDevice(TIMERNAME, UNIT_VBLANK, &tr, 0L)) {
  790.     fprintf(stderr,"Clock error: can't open timer device\n");
  791.     return;
  792.     }
  793. tr.tr_node.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  794. tr.tr_node.io_Message.mn_Node.ln_Pri = 0L;
  795. tr.tr_node.io_Message.mn_Node.ln_Name = NULL;
  796. tr.tr_node.io_Message.mn_ReplyPort = NULL;
  797. tr.tr_node.io_Command = TR_SETSYSTIME;
  798. tr.tr_time.tv_secs = secs;
  799. tr.tr_time.tv_micro = 0L;
  800. if (DoIO (&tr)) fprintf(stderr,"Clock error: can't talk to timer device\n");
  801. CloseDevice (&tr);
  802. }
  803.  
  804. char tday[10];
  805.  
  806. char *dates(dss)
  807. struct DateStamp *dss;
  808. {
  809. static char timestr[40];
  810. char tdate[10], ttime[10];
  811. struct DateTime dt;
  812. struct DateStamp *myds=&(dt.dat_Stamp);
  813.  
  814. dt.dat_Format=FORMAT_DOS;
  815. dt.dat_StrDay=tday;
  816. dt.dat_StrDate=tdate;
  817. dt.dat_StrTime=ttime;
  818. dt.dat_Flags=NULL;
  819. myds->ds_Days=dss->ds_Days;
  820. myds->ds_Minute=dss->ds_Minute;
  821. myds->ds_Tick=dss->ds_Tick;
  822. StamptoStr(&dt);
  823. sprintf(timestr,"%s %s\n",tdate,ttime);
  824. timestr[18]='\n';
  825. timestr[19]='\0';    /* protection against bad timestamped files */
  826. return timestr;
  827. }
  828.  
  829. date()
  830. {
  831. struct DateStamp dss;
  832. register unsigned short i;
  833. struct DateTime dt;
  834.  
  835. dt.dat_Format=FORMAT_DOS;
  836. if (ac==1) {
  837.     DateStamp(&dss);
  838.     printf("%s %s",tday,dates(&dss));
  839.     }
  840. else {
  841.     DateStamp(& (dt.dat_Stamp));
  842.     for (i=1; i<ac; i++) {
  843.         dt.dat_StrDate=NULL;
  844.         dt.dat_StrTime=NULL;
  845.         dt.dat_Flags=DTF_FUTURE;
  846.         if (index(av[i],':')) dt.dat_StrTime=av[i];
  847.             else dt.dat_StrDate=av[i];
  848.         if (StrtoStamp(&dt)) ierror(av[i],500);
  849.         }
  850.     setsystemtime( & (dt.dat_Stamp) );
  851.     }
  852. return 0;
  853. }
  854.