home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 13 / MA_Cover_13.bin / source / c / apl / aj.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-11-23  |  6.1 KB  |  338 lines
  1. #include "apl.h"
  2. #include <string.h>
  3. #include <dirent.h>
  4.  
  5. double atof();
  6. static char *gettoken();
  7.  
  8. clear()
  9. {
  10.     struct nlist *n;
  11.  
  12.     for(n=nlist; n->namep; n++) {
  13.         n->use = 0;
  14.         n->itemp = 0;
  15.         n->namep = 0;
  16.     }
  17.     afreset();    /* release all dynamic memory */
  18.     gsip = 0;    /* reset state indicator */
  19. }
  20.  
  21. wsload(ffile, port)
  22. {
  23.     char buffer[64], flag, *gettoken(), c;
  24.     int use, size, rank, i, dim[MRANK];
  25.     struct nlist *n;
  26.     struct item *p;
  27.  
  28.     gettoken(ffile, buffer);
  29.     if (!equal(buffer, "apl\\11")) error("bad ws file magic number");
  30.     gettoken(ffile, buffer);
  31.     gettoken(ffile, buffer);
  32.     thread.fuzz = atof(buffer);
  33.     gettoken(ffile, buffer);
  34.     gettoken(ffile, buffer);
  35.     thread.iorg = atoi(buffer);
  36.     gettoken(ffile, buffer);
  37.     gettoken(ffile, buffer);
  38.     thread.width = atoi(buffer);
  39.     gettoken(ffile, buffer);
  40.     gettoken(ffile, buffer);
  41.     thread.digits = atoi(buffer);
  42.  
  43.     while (1) {
  44.         if (0 == gettoken(ffile, buffer)) break;
  45.         if (equal(buffer, "DA")) use = DA;
  46.         if (equal(buffer, "CH")) use = CH;
  47.         if (equal(buffer, "NF")) use = NF;
  48.         if (equal(buffer, "MF")) use = MF;
  49.         if (equal(buffer, "DF")) use = DF;
  50.  
  51.         gettoken(ffile, buffer);
  52.         for (n=nlist; n->namep; n++) {
  53.             if (equal(buffer, n->namep)) {
  54.                 erase(n);
  55.                 goto hokay;
  56.             }
  57.         }
  58.         n->namep = alloc(1+strlen(buffer));
  59.         strcpy(n->namep, buffer);
  60. hokay:
  61.         n->use = use;
  62.         if (n->use == CH) n->use = DA;
  63.         n->type = LV;
  64.  
  65.         switch (use) {
  66.  
  67.             default:
  68.             close(ffile);
  69.             error("bad ws file format");
  70.  
  71.             case DA:
  72.             case CH:
  73.             rank = atoi(gettoken(ffile, buffer));
  74.             size = 1;
  75.             for (i=0; i<rank; i++) {
  76.                 dim[i] = atoi(gettoken(ffile, buffer));
  77.                 size *= dim[i];
  78.             }
  79.             p = newdat(use, rank, size);
  80.             for (i=0; i<rank; i++) p->dim[i] = dim[i];
  81.             if (use == CH) read(ffile, (char *)p->datap, size);
  82.             else {
  83.                 if (port) {
  84.                     data *dp;
  85.                     dp = p->datap;
  86.                     for (i=0; i<size; i++) {
  87.                         *dp++ = atof(gettoken(ffile, buffer));
  88.                     }
  89.                 }
  90.                 else read(ffile, (data *)p->datap, size*sizeof(data));
  91.             }
  92.             n->itemp = p;
  93.             break;
  94.  
  95.             case NF:
  96.             case MF:
  97.             case DF:
  98.             n->itemp = 0;
  99.             n->label = lseek(wfile, 0L, 2);
  100.             while (1) {
  101.                 if (read(ffile, &c, 1) != 1) {
  102.                     close(ffile);
  103.                     error("wsload unexpected eof");
  104.                 }
  105.                 write(wfile, &c, 1);
  106.                 if (c == 0) break;
  107.             }
  108.             break;
  109.         }
  110.     }
  111.     fdat(ffile);
  112.     close(ffile);
  113. }
  114.  
  115.  
  116. static
  117. char *
  118. gettoken(ffile, buffer)
  119. char *buffer;
  120. {
  121.     int i;
  122.     char c;
  123.  
  124.     i = 0;
  125.     while (1) {
  126.         if (read(ffile, &c, 1) != 1) return 0;
  127.         if (isspace(c)) continue;
  128.         break;
  129.     }
  130.     buffer[i++] = c;
  131.     while (1) {
  132.         if (read(ffile, &c, 1) != 1) break;
  133.         if (isspace(c)) break;
  134.         buffer[i++] = c;
  135.     }
  136.     buffer[i] = 0;
  137.     return buffer;
  138. }
  139.  
  140.  
  141. static int portFlag = 0;
  142.  
  143. wssave(ffile, port)
  144. {
  145.     struct nlist *n;
  146.     int oldPortFlag;
  147.  
  148.     oldPortFlag = portFlag;
  149.     portFlag = port;
  150.     nsave(ffile, 0);
  151.     for(n=nlist; n->namep; n++) nsave(ffile, n);
  152.     fdat(ffile);
  153.     close(ffile);
  154.     portFlag = oldPortFlag;
  155. }
  156.  
  157. vsave(fd)
  158. {
  159.     struct nlist *n;
  160.     struct nlist *getnm();
  161.  
  162.     nsave(fd, 0);
  163.     while(n = getnm()) nsave(fd, n);
  164.     fdat(fd);
  165.     close(fd);
  166. }
  167.  
  168.  
  169. nsave(ffile, an)
  170. struct nlist *an;
  171. {
  172.     char c, buffer[64];
  173.     int i, n, size;
  174.     struct item *p;
  175.  
  176.     if (an == 0){
  177.         write(ffile, "apl\\11\n", 7);
  178.         sprintf(buffer, "fuzz %lg\n", thread.fuzz);
  179.         write(ffile, buffer, strlen(buffer));
  180.         sprintf(buffer, "origin %d\n", thread.iorg);
  181.         write(ffile, buffer, strlen(buffer));
  182.         sprintf(buffer, "width %d\n", thread.width);
  183.         write(ffile, buffer, strlen(buffer));
  184.         sprintf(buffer, "digits %d\n", thread.digits);
  185.         write(ffile, buffer, strlen(buffer));
  186.         return 0;
  187.     }
  188.  
  189.     if (an->use == 0 || (an->use == DA && an->itemp == 0)) return 0;
  190.  
  191.     switch (an->use) {
  192.         default:
  193.         close(ffile);
  194.         error("save B");
  195.  
  196.         case DA:
  197.         p = an->itemp;
  198.         if (p->type == DA) write(ffile, "DA ", 3);
  199.         else write(ffile, "CH ", 3);
  200.         write(ffile, an->namep, strlen(an->namep));
  201.         sprintf(buffer, " %d", p->rank);
  202.         write(ffile, buffer, strlen(buffer));
  203.         size = 1;
  204.         for (i=0; i<p->rank; i++) {
  205.             sprintf(buffer, " %d", p->dim[i]);
  206.             write(ffile, buffer, strlen(buffer));
  207.             size *= p->dim[i];
  208.         }
  209.         write(ffile, "\n", 1);
  210.         if (p->type == DA) {
  211.             data *dp;
  212.             dp = p->datap;
  213.             if (portFlag) {
  214.                 for (i=0; i<size; i++) {
  215.                     sprintf(buffer, "%14lg\n", *dp++);
  216.                     write(ffile, buffer, strlen(buffer));
  217.                 }
  218.             }
  219.             else write(ffile, dp, size*sizeof(data));
  220.         }
  221.         else {
  222.             write(ffile, (char *)p->datap, size);
  223.             write(ffile, "\n", 1);
  224.         }
  225.         break;
  226.  
  227.         case NF:
  228.         write(ffile, "NF ", 3);
  229.         goto real;
  230.  
  231.         case MF:
  232.         write(ffile, "MF ", 3);
  233.         goto real;
  234.  
  235.         case DF:
  236.         write(ffile, "DF ", 3);
  237. real:
  238.         write(ffile, an->namep, strlen(an->namep));
  239.         write(ffile, "\n", 1);
  240.         lseek(wfile,(long)an->label,0);
  241.         while (1) {
  242.             read(wfile, &c, 1);
  243.             write(ffile, &c, 1);
  244.             if (c == 0) break;
  245.         }
  246.         break;
  247.     }
  248.     return 0;
  249. }
  250.  
  251. struct nlist *
  252. getnm()
  253. {
  254.     char *p, name[100];
  255.     struct nlist *n;
  256.     int c;
  257.  
  258.     while(1){
  259.         printf("variable name? ");
  260.         c = read(1, name, 100);
  261.         if(c <= 1) return(0);
  262.         name[c-1] = 0;
  263.         for(n=nlist; n->namep; n++) if(equal(name, n->namep)) return(n);
  264.         printf("%s does not exist\n", name);
  265.     }
  266. }
  267.  
  268.  
  269. listdir()
  270. {
  271. /*
  272.     int f;
  273.     char *p;
  274.     struct direct dir;
  275.  
  276.     if((f = open(".",0)) < 0) error("directory B");
  277.     while(read(f,&dir,sizeof dir) == sizeof dir) {
  278.         if(dir.d_ino != 0 && dir.d_name[0] != '.') {
  279.             if(column+10 >= thread.width) printf("\n\t");
  280.             for(p=dir.d_name; p<dir.d_name+14 && *p; p++) putchar(*p);
  281.             putchar('\t');
  282.         }
  283.     }
  284.     putchar('\n');
  285.     close(f);
  286. */
  287.  
  288. /*
  289.     system("ls .");
  290. */
  291.  
  292.     DIR *thisDirectory;
  293.     struct dirent *entry;
  294.     int widest, i;
  295.  
  296.     thisDirectory = opendir(".");
  297.     if (thisDirectory == 0) error("directory B");
  298.     while (1) {
  299.         entry = readdir(thisDirectory);
  300.         if (entry == 0) break;
  301.         if(entry->d_ino != 0 && entry->d_name[0] != '.') {
  302.             if (column+10 >= thread.width) printf("\n\t");
  303.             for (i=0; i<14 && entry->d_name[i]; i++) putchar(entry->d_name[i]);
  304.             putchar('\t');
  305.         }
  306.     }
  307.     putchar('\n');
  308.     closedir(thisDirectory);
  309. }
  310.  
  311. fdat(f)
  312. {
  313.     struct stat b;
  314.     struct tm *p, *localtime();
  315.  
  316.     fstat(f,&b);
  317.     p = localtime(&b.st_mtime);
  318.  
  319.     printf("  ");
  320.     pr2d(p->tm_hour);
  321.     putchar('.');
  322.     pr2d(p->tm_min);
  323.     putchar('.');
  324.     pr2d(p->tm_sec);
  325.     putchar(' ');
  326.     pr2d(p->tm_mon+1);
  327.     putchar('/');
  328.     pr2d(p->tm_mday);
  329.     putchar('/');
  330.     pr2d(p->tm_year);
  331. }
  332.  
  333. pr2d(i)
  334. {
  335.     putchar(i/10+'0');
  336.     putchar(i % 10 + '0');
  337. }
  338.