home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / C / ROBOT01.ZIP / RCCL006 < prev    next >
Encoding:
Text File  |  1987-03-02  |  9.6 KB  |  477 lines
  1. /*
  2.  * DBOT Version 1.0           Author :  Vincent Hayward
  3.  *                                      School of Electrical Engineering
  4.  *                                      Purdue University
  5.  *      Dir     : db
  6.  *      File    : dbot.c
  7.  *      Remarks : All the functions of the library are there.
  8.  *      Usage   : make install
  9.  */
  10.  
  11. /*LINTLIBRARY*/
  12.  
  13. #include <stdio.h>
  14. #include <sys/types.h>
  15. #include "../h/rccl.h"
  16. #include "../h/umac.h"
  17.  
  18. #define BEGIN   0               /* seek options */
  19. #define RELAT   1               /* ....         */
  20. #define ENDOF   3               /* ....         */
  21. #define RW      2               /* open ....... */
  22. #define BUFS    1024            /* best r/w buf */
  23. #define FREE    0               /* entry not allocated  */
  24. #define HOLE    -1              /* entry removed        */
  25. #define MAGICD  0123            /* magic number data b  */
  26. #define LABS    16              /* label size           */
  27.  
  28. #define MAX     85              /* 85 * sizeof(TRID) == 2040 */
  29.  
  30. typedef struct {                /* transform identity   */
  31.     char label[LABS];       /* name                 */
  32.     time_t ttime;           /* birth date           */
  33.     long addr;              /* address              */
  34. }TRID;
  35.  
  36. typedef struct {                /* internal storage represention */
  37.     float px, py, pz, ox, oy, oz, ax, ay, az;
  38. } DBTR, *DBTR_PTR;
  39.  
  40. /*
  41.  * core image of the file header
  42.  */
  43.  
  44. static struct head {
  45.     int magic;
  46.     int nb;
  47.     TRID table[MAX];
  48. } hd;
  49.  
  50. char *ctime();
  51. time_t time();
  52. long lseek();
  53.  
  54.  
  55.  
  56.  
  57. #define READS(f, p)\
  58. if (read(f, (char *)&p, sizeof(p)) < 0) {\
  59.     fprintf(stderr, "read error on data base file\n");\
  60.     return(-1);}
  61.  
  62. #define WRITES(f, p)\
  63. if (write(f, (char *)&p, sizeof(p)) < 0) {\
  64.     fprintf(stderr, "write error on data base file\n");\
  65.     return(-1);}
  66.  
  67. #define SEEK(f, a, n)\
  68. if (lseek(f, a, n) < 0) {\
  69.     fprintf(stderr, "seek error on data base file\n");\
  70.     return(-1);}
  71.  
  72. #define ISDB(h)\
  73. if (h .magic != MAGICD) {\
  74.     fprintf(stderr, "bad magic number\n");\
  75.     return(-1);}
  76.  
  77. /*
  78.  * creates a new data base file, which contains at least a table
  79.  * of MAX TRID records.
  80.  * All the records are initialize with a 0 creation or change time.
  81.  *
  82.  * A 'FREE' teach time means free entry in table.
  83.  * Each time an entry is added, all the addr pointers of the 'FREE'
  84.  * entries are set to the size of the file.
  85.  * When an entry is removed, a HOLE is created.
  86.  * The labels are C strings and therefore cannot contain more
  87.  * than LABS -1 chars.
  88.  */
  89.  
  90. /*
  91.  * create an empty data base
  92.  */
  93.  
  94. makedb(name) /*::*/
  95. char *name;
  96. {
  97.     int fd, i, j;
  98.  
  99.     if ((fd = creat(name, 0644)) < 0) {
  100.         fprintf(stderr, "could'nt creat transform data base file\n");
  101.         return(-1);
  102.     }
  103.     if ((fd = open(name, RW)) < 0) {
  104.         fprintf(stderr, "open error on data base file");
  105.         return(-1);
  106.     }
  107.     for (i = 0; i < MAX; ++i) {
  108.         for (j = 0; j < LABS; ++j) {
  109.             hd.table[i].label[j] = '\0';
  110.         }
  111.         hd.table[i].ttime = FREE;
  112.         hd.table[i].addr = sizeof(hd);
  113.     }
  114.     hd.magic = MAGICD;
  115.     hd.nb = 0;
  116.     WRITES(fd, hd);
  117.     return(fd);
  118. }
  119.  
  120.  
  121. /*
  122.  * sequential search of the entries in the table
  123.  * return
  124.  *              index in the table,
  125.  *              -2 if not found,
  126.  *              -1 if io error
  127.  */
  128.  
  129. static search(n, fd) /*##*/
  130. char *n;
  131. int fd;
  132. {
  133.     int i;
  134.  
  135.     SEEK(fd, 0L, BEGIN);
  136.     READS(fd, hd);
  137.     ISDB(hd);
  138.     for (i = 0; i < MAX; ++i) {
  139.         if (hd.table[i].ttime == FREE || hd.table[i].ttime == HOLE) {
  140.             continue;
  141.         }
  142.         if (strncmp(n, hd.table[i].label, LABS - 1) == 0) {
  143.             return(i);
  144.         }
  145.     }
  146.     return(-2);
  147. }
  148.  
  149.  
  150. /*
  151.  * save a transform in the data base
  152.  * 1) look if exits, if yes prompts the user if can change change
  153.  * 2) tries to fill holes
  154.  * 3) extent if no hole
  155.  *
  156.  * return
  157.  *              1  if change aborted by user
  158.  *              0  if store successful
  159.  *              -1 if io error
  160.  */
  161.  
  162. savetr(t, fd) /*::*/
  163. TRSF_PTR t;
  164. int fd;
  165. {
  166.     int q, i, j;
  167.     DBTR dbt;
  168.     char *m;
  169.  
  170.     i = search(t->name, fd);
  171.     if (i == -1) {
  172.         fprintf(stderr, "search error\n");
  173.         return(-1);
  174.     }
  175.     if (i >= 0) {
  176.         printf("savetr : %s created : %s",
  177.             hd.table[i].label, ctime(&hd.table[i].ttime));
  178.         printf("change ? ");
  179.         QUERY(q);
  180.         if (q == 'n') {
  181.             return(1);
  182.         }
  183.      (void) time(&hd.table[i].ttime);
  184.         m = "savetr : %s changed at %s";
  185.     }
  186.     else {
  187.         q = NO;
  188.         for (i = 0; i < MAX; ++i) {
  189.             if (hd.table[i].ttime == HOLE) {
  190.              (void) time(&hd.table[i].ttime);
  191.                 m = "savetr : %s Added at %s";
  192.                 q = YES;
  193.                 ++hd.nb;
  194.                 break;
  195.             }
  196.         }
  197.         if (!q) {
  198.             q = NO;
  199.             for (i = 0; i < MAX; ++i) {
  200.                 if (hd.table[i].ttime == FREE) {
  201.                  (void) time(&hd.table[i].ttime);
  202.                     m = "savetr : %s added at %s";
  203.                     q = YES;
  204.                     ++hd.nb;
  205.                     break;
  206.                 }
  207.             }
  208.  
  209.             if (!q) {
  210.                 fprintf(stderr, "data base file saturated\n");
  211.                 return(-1);
  212.             }
  213.             for (j = 0; j < MAX; ++j) {
  214.                 if (hd.table[j].ttime == FREE) {
  215.                     hd.table[j].addr += sizeof(DBTR);
  216.                 }
  217.             }
  218.         }
  219.     }
  220.     strcpyn(hd.table[i].label, t->name, LABS);
  221.     printf(m, hd.table[i].label, ctime(&hd.table[i].ttime));
  222.     SEEK(fd, hd.table[i].addr, BEGIN);
  223.     cnvtrdb(&dbt, t);
  224.     WRITES(fd, dbt);
  225.     SEEK(fd, 0L, BEGIN);
  226.     WRITES(fd, hd);
  227.     return(0);
  228. }
  229.  
  230.  
  231. /*
  232.  * get a transform out of the data base
  233.  *
  234.  * return
  235.  *              0  if found
  236.  *              -2 if not found
  237.  *              -1 if io error
  238.  */
  239.  
  240.  
  241. gettr(t, fd) /*::*/
  242. TRSF_PTR t;
  243. int fd;
  244. {
  245.     int i;
  246.     DBTR dbt;
  247.  
  248.     i = search(t->name, fd);
  249.     if (i == -1) {
  250.         fprintf(stderr, "search error\n");
  251.         return(-1);
  252.     }
  253.     if (i >= 0) {
  254.         SEEK(fd, hd.table[i].addr, BEGIN);
  255.         READS(fd, dbt);
  256.         cnvdbtr(t, &dbt);
  257.         printf("gettr : %s last change : %s",
  258.             hd.table[i].label, ctime(&hd.table[i].ttime));
  259.         return(0);
  260.     }
  261.     else {
  262.         printf("gettr : %s not found\n", t->name);
  263.         return(-2);
  264.     }
  265. }
  266.  
  267.  
  268. /*
  269.  * remove a transform out of the data base
  270.  *
  271.  * return
  272.  *              0  is successful
  273.  *              -2 if not found
  274.  *              -1 if io error
  275.  */
  276.  
  277. remtr(n, fd) /*::*/
  278. char *n;
  279. int fd;
  280. {
  281.     int i;
  282.  
  283.     i = search(n, fd);
  284.     if (i == -1) {
  285.         fprintf(stderr, "search error\n");
  286.         return(-1);
  287.     }
  288.     if (i >= 0) {
  289.         hd.table[i].ttime = HOLE;
  290.         --hd.nb;
  291.         SEEK(fd, 0L, BEGIN);
  292.         WRITES(fd, hd);
  293.         printf("remtr : %s removed\n", n);
  294.         return(0);
  295.     }
  296.     else {
  297.         printf("remtr : %s not found\n", n);
  298.         return(-2);
  299.     }
  300. }
  301.  
  302.  
  303.  
  304. /*
  305.  * print the content of the data base
  306.  *
  307.  * return
  308.  *              0  if ok
  309.  *              -1 if io error
  310.  */
  311.  
  312. dumpdb(fd, v) /*::*/
  313. int fd;
  314. bool v;
  315. {
  316.     TRSF tr;
  317.     DBTR dbt;
  318.     int i;
  319.  
  320.     SEEK(fd, 0L, BEGIN);
  321.     READS(fd, hd);
  322.     ISDB(hd);
  323.     printf("dump : %d entries\n", hd.nb);
  324.     for (i = 0; i < MAX; ++i) {
  325.         if (hd.table[i].ttime != FREE && hd.table[i].ttime != HOLE) {
  326.             printf("%d  ", (hd.table[i].addr - sizeof(hd)) / sizeof(DBTR));
  327.             printf("%s , %s", hd.table[i].label, ctime(&hd.table[i].ttime));
  328.             if(v) {
  329.                 SEEK(fd, hd.table[i].addr, BEGIN);
  330.                 READS(fd, dbt);
  331.                 cnvdbtr(&tr, &dbt);
  332.                 printf("%8.3f %8.3f %8.3f %8.3f\n",
  333.                     tr.n.x, tr.o.x, tr.a.x, tr.p.x);
  334.                 printf("%8.3f %8.3f %8.3f %8.3f\n",
  335.                     tr.n.y, tr.o.y, tr.a.y, tr.p.y);
  336.                 printf("%8.3f %8.3f %8.3f %8.3f\n",
  337.                     tr.n.z, tr.o.z, tr.a.z, tr.p.z);
  338.             }
  339.         }
  340.     }
  341.     return(0);
  342. }
  343.  
  344.  
  345. /*
  346.  * compact the data base in place, for that make a copy of it
  347.  *
  348.  * return
  349.  *              0  if ok
  350.  *              -1 if io error
  351.  */
  352.  
  353.  
  354. static struct head hdc;
  355.  
  356. compactdb(name)
  357. char *name;
  358. {
  359.     char temp[40];
  360.     int fd, fdt;
  361.     char bd[BUFS];
  362.     int n;
  363.     DBTR dbt;
  364.     int i, j, inc;
  365.     char *sprintf();
  366.  
  367.     if ((fd = open(name, RW)) < 0) {
  368.         fprintf(stderr, "open error on data base file %s\n", name);
  369.         return(-1);
  370.     }
  371.  (void) sprintf(temp, "%d.cdb", getpid());
  372.     if ((fdt = creat(temp, 0644)) < 0) {
  373.         fprintf(stderr, "can't creat data base file %s\n", temp);
  374.         return(-1);
  375.     }
  376.     if ((fdt = open(temp, RW)) < 0) {
  377.         fprintf(stderr, "open error on data base file %s\n", temp);
  378.         return(-1);
  379.     }
  380.     SEEK(fd, 0L, BEGIN);
  381.     while ((n = read(fd, bd, BUFS)) > 0) {
  382.         if (write(fdt, bd, n) < 0) {
  383.             fprintf(stderr, "can't duplicate data base file\n");
  384.             return(-1);
  385.         }
  386.     }
  387.  
  388.     fd = makedb(name);
  389.     SEEK(fdt, 0L, BEGIN);
  390.     READS(fdt, hdc);
  391.     j = 0;
  392.     inc = 0;
  393.     for (i = 0; i < MAX; ++i) {
  394.         if (hdc.table[i].ttime != HOLE && hdc.table[i].ttime != FREE) {
  395.             SEEK(fdt, hdc.table[i].addr, BEGIN);
  396.             READS(fdt, dbt);
  397.             WRITES(fd, dbt);
  398.             hd.table[j].addr += inc;
  399.             inc += sizeof(DBTR);
  400.             hd.table[j].ttime = hdc.table[i].ttime;
  401.             strcpyn(hd.table[j].label, hdc.table[i].label, LABS);
  402.             ++hd.nb;
  403.             ++j;
  404.         }
  405.     }
  406.     for (;j < MAX; ++j) {
  407.         hd.table[j].addr += inc;
  408.     }
  409.     SEEK(fd, 0L, BEGIN);
  410.     WRITES(fd, hd);
  411.     if (unlink(temp) < 0) {
  412.         fprintf(stderr, "could'nt unlink\n");
  413.         return(-1);
  414.     }
  415.     return(0);
  416. }
  417.  
  418.  
  419. /*
  420.  * convert a regular transform into data base format
  421.  */
  422.  
  423. static cnvtrdb(d, t) /*##*/
  424. DBTR_PTR d;
  425. TRSF_PTR t;
  426. {
  427.     d->px = t->p.x;
  428.     d->py = t->p.y;
  429.     d->pz = t->p.z;
  430.     d->ax = t->a.x;
  431.     d->ay = t->a.y;
  432.     d->az = t->a.z;
  433.     d->ox = t->o.x;
  434.     d->oy = t->o.y;
  435.     d->oz = t->o.z;
  436. }
  437.  
  438.  
  439. /*
  440.  * convert a data base format transform into regular
  441.  */
  442.  
  443. static cnvdbtr(t, d) /*##*/
  444. DBTR_PTR d;
  445. TRSF_PTR t;
  446. {
  447.     t->p.x = d->px;
  448.     t->p.y = d->py;
  449.     t->p.z = d->pz;
  450.     t->a.x = d->ax;
  451.     t->a.y = d->ay;
  452.     t->a.z = d->az;
  453.     t->o.x = d->ox;
  454.     t->o.y = d->oy;
  455.     t->o.z = d->oz;
  456.     t->n.x = t->o.y * t->a.z - t->o.z * t->a.y;
  457.     t->n.y = t->o.z * t->a.x - t->o.x * t->a.z;
  458.     t->n.z = t->o.x * t->a.y - t->o.y * t->a.x;
  459. }
  460.  
  461.  
  462. /*
  463.  * copy n chars of a string
  464.  */
  465.  
  466. static strcpyn(s1, s2, n) /*##*/
  467. char *s1, *s2;
  468. int n;
  469. {
  470.     while (*s1++ = *s2++) {
  471.         if (--n == 0) {
  472.             *--s1 = '\0';
  473.             return;
  474.         }
  475.     }
  476. }
  477.