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