home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / modelers / geomview / source.lha / Geomview / src / lib / oogl / refcomm / streampool.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-08-30  |  16.2 KB  |  725 lines
  1. /* Copyright (c) 1992 The Geometry Center; University of Minnesota
  2.    1300 South Second Street;  Minneapolis, MN  55454, USA;
  3.    
  4. This file is part of geomview/OOGL. geomview/OOGL is free software;
  5. you can redistribute it and/or modify it only under the terms given in
  6. the file COPYING, which you should have received along with this file.
  7. This and other related software may be obtained via anonymous ftp from
  8. geom.umn.edu; email: software@geom.umn.edu. */
  9.  
  10. /* Authors: Charlie Gunn, Stuart Levy, Tamara Munzner, Mark Phillips */
  11.  
  12. #include <string.h>
  13. #include <sys/stat.h>
  14. #include <fcntl.h>
  15. #include <math.h>
  16. #include "handleP.h"
  17. #include <sys/socket.h>
  18. #include <sys/un.h>
  19. #include <sys/errno.h>
  20.  
  21. static Pool *AllPools = NULL;
  22. static Pool *FreePools = NULL;
  23.  
  24. static fd_set poolwatchfds;
  25. static int poolmaxfd = 0;
  26. static fd_set poolreadyfds;
  27. static int poolnready = 0;
  28.  
  29. #define    FOREVER  ((1<<31)-1)
  30. static struct timeval nexttowake = { FOREVER };
  31.  
  32. static Pool *newPool(char *name);
  33.  
  34. extern Handle *AllHandles;    /* From handle.c */
  35.  
  36. /*
  37.  * Does the whole job of handling stream references to named objects.
  38.  * Interprets strings of the forms:
  39.  *    name:file
  40.  *        referring to a specific named object to be read from a
  41.  *        specific file, or
  42.  *    file
  43.  *        referring to the nameless content of that file, or
  44.  *    name:
  45.  *        referring to a specific named object from any source.
  46.  *
  47.  * In the first two cases, we open (as a Pool) the specified file and
  48.  * attempt to read it using the functions in *ops.
  49.  */
  50. Handle *
  51. HandleReferringTo(int prefixch, char *str, HandleOps *ops, Handle **hp)
  52. {
  53.     Pool *p = NULL;
  54.     Handle *h = NULL;
  55.     Handle *hknown;
  56.     char *sep;
  57.     char *fname;
  58.     char *name;
  59.     char nb[128];
  60.  
  61.     if(str == NULL || ops == NULL)
  62.     return 0;
  63.  
  64.     sep = strrchr(str, ':');
  65.     if(prefixch == ':') {    /*   :  name   -- take 'name' from anywhere */
  66.     name = str;
  67.     fname = NULL;
  68.     } else if(sep == NULL) {    /*   <  file   -- read from file 'name' */
  69.     fname = str;
  70.     name = str;
  71.     } else {            /*   <  file:name */
  72.     name = sep+1;
  73.     fname = nb;
  74.     if(sep-str >= sizeof(nb))
  75.         sep = &str[sizeof(nb)-1];
  76.     memcpy(fname, str, sep-str);
  77.     fname[sep-str] = '\0';
  78.     }
  79.     h = hknown = HandleByName(name, ops);
  80.  
  81.     if(fname != NULL)
  82.     p = PoolStreamOpen(fname, NULL, 0, ops);
  83.  
  84.     if((p || prefixch == ':') && h == NULL) {
  85.     h = HandleCreate(name, ops);
  86.     if(h == NULL) {
  87.         OOGLError(1, "Can't make handle for '%s'", str);
  88.         return NULL;
  89.     }
  90.     }
  91.     if(p && (((p->flags & (PF_ANY|PF_REREAD)) != PF_ANY) || hknown != NULL)) {
  92.     Handle *th = PoolIn(p);    /* Try reading one item. */
  93.     if(th) {        /* Read anything? */
  94.        h = th;        /* Return that if so */
  95.        h->whence = p;
  96.     }
  97.     }
  98.     if(hknown == NULL && prefixch == '<' && h != NULL && p && p->seekable)
  99.     h->permanent = 0;
  100.     if(hp && h && h->permanent) {
  101.     if(*hp && *hp != h)
  102.         HandlePDelete(hp);
  103.     *hp = h;
  104.     }
  105.     return h;
  106. }
  107.  
  108. char *
  109. PoolName(Pool *p)
  110. { return p ? p->poolname : NULL;
  111. }
  112.  
  113. Pool *
  114. PoolByName(char *fname)
  115. {
  116.     register Pool *p;
  117.  
  118.     for(p = AllPools; p != NULL; p = p->next)
  119.     if(strcmp(fname, p->poolname) == 0)
  120.         return p;
  121.     return NULL;
  122. }
  123.  
  124.  
  125. static
  126. void watchfd(int fd)
  127. {
  128.     if(fd < 0 || fd >= FD_SETSIZE || FD_ISSET(fd, &poolwatchfds))
  129.     return;
  130.  
  131.     FD_SET(fd, &poolwatchfds);
  132.     if(poolmaxfd <= fd)
  133.     poolmaxfd = fd+1;
  134. }
  135.  
  136. static
  137. void unwatchfd(int fd)
  138. {
  139.     register Pool *p;
  140.     register int i;
  141.  
  142.     if(fd < 0 || fd >= FD_SETSIZE)
  143.     return;
  144.  
  145.     if(FD_ISSET(fd, &poolwatchfds)) {
  146.     FD_CLR(fd, &poolwatchfds);
  147.     }
  148.     if(fd+1 >= poolmaxfd) {
  149.     for(i = poolmaxfd; --i >= 0 && !FD_ISSET(i, &poolwatchfds); )
  150.         ;
  151.     poolmaxfd = i+1;
  152.     }
  153.     if(FD_ISSET(fd, &poolreadyfds)) {
  154.     FD_CLR(fd, &poolreadyfds);
  155.     poolnready--;
  156.     }
  157. }
  158.  
  159. static Pool *
  160. newPool(char *name)
  161. {
  162.     register Pool *p;
  163.  
  164.     if((p = FreePools) != NULL)
  165.     FreePools = p->next;
  166.     else
  167.     p = OOGLNewE(Pool, "Pool");
  168.     bzero(p, sizeof(Pool));
  169.     p->poolname = strdup(name);
  170.     return p;
  171. }
  172.     
  173. Pool *
  174. PoolStreamTemp(char *name, FILE *f, int rw, HandleOps *ops)
  175. {
  176.     register Pool *p;
  177.     char dummy[12];
  178.  
  179.     if(name==NULL) sprintf(name=dummy, "_p%x", f);
  180.     p = newPool(name);
  181.     p->ops = ops;
  182.     p->type = P_STREAM;
  183.     if(f == NULL && name != NULL) {
  184.     f = fopen(name, rw ? (rw>1 ? "w+":"w") : "r");
  185.     if(f == NULL) {
  186.         OOGLError(0, "Can't open %s: %s", name, sperror());
  187.         OOGLFree(p);
  188.         return NULL;
  189.     }
  190.     }
  191.     p->inf = p->outf = f;
  192.     if(f) {
  193.     switch(rw) {
  194.         case 0: p->outf = NULL; break;
  195.         case 1: p->inf = NULL; break;
  196.         case 2: p->outf = fdopen(dup(fileno(f)), "w");
  197.     }
  198.     }
  199.     p->handles = NULL;
  200.     p->resyncing = NULL;
  201.     p->otype = PO_ALL;
  202.     p->next = NULL;
  203.     p->mode = rw;
  204.     p->seekable = (p->inf && tell(fileno(p->inf)) != -1 &&
  205.             !isatty(fileno(p->inf)));
  206.     p->softEOF = !p->seekable;
  207.     p->level = (p->outf && tell(fileno(p->outf)) != -1 &&
  208.             !isatty(fileno(p->outf)))
  209.         ? 0 : 1;
  210.     p->flags = PF_TEMP;
  211.     p->client_data = NULL;
  212.     return p;
  213. }
  214.  
  215. Pool *
  216. PoolStreamOpen(char *name, FILE *f, int rw, HandleOps *ops)
  217. {
  218.     register Pool *p;
  219.     struct stat st;
  220.  
  221.     p = PoolByName(name);
  222.  
  223.     if(p == NULL) {
  224.     p = newPool(name);
  225.     p->ops = ops;
  226.     p->type = P_STREAM;
  227.     p->inf = p->outf = NULL;
  228.     p->mode = rw;
  229.     p->handles = NULL;
  230.     p->resyncing = NULL;
  231.     p->otype = PO_ALL;
  232.     p->level = 0;
  233.     p->flags = 0;
  234.     p->next = AllPools;
  235.     p->client_data = NULL;
  236.     } else {
  237.     if(rw == 0 && p->mode == 0 && p->inf != NULL
  238.         && p->softEOF == 0
  239.         && (p->flags & PF_REREAD) == 0
  240.         && stat(name, &st) == 0
  241.         && st.st_mtime == p->inf_mtime) {
  242.         rewind(p->inf);
  243.         return p;
  244.     }
  245.  
  246.     /*
  247.      * Combine modes.  Allows e.g. adding write stream to read-only pool.
  248.      */
  249.     p->mode = ((p->mode+1) | (rw+1)) - 1;
  250.     if(p->inf && rw != 1) {
  251.         if(p->inf != stdin) fclose(p->inf);
  252.         p->inf = NULL;
  253.     }
  254.     }
  255.  
  256.     if(f == NULL || f == (FILE *)-1) {
  257.     if(rw != 1) {
  258.         if(strcmp(name, "-") == 0) {
  259.         p->inf = stdin;
  260.         } else {
  261.         int fd = open(name, O_RDONLY | O_NDELAY);
  262.         if(fd < 0 && errno == EOPNOTSUPP) {
  263.                 /* Maybe it's a UNIX-domain socket */
  264.             struct sockaddr_un sa;
  265.             sa.sun_family = AF_UNIX;
  266.             strncpy(sa.sun_path, name, sizeof(sa.sun_path));
  267.             fd = socket(AF_UNIX, SOCK_STREAM, 0);
  268.             if(connect(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
  269.             close(fd);
  270.             fd = -1;
  271.             }
  272.         }
  273.         if(fd < 0)
  274.             OOGLError(0, "Cannot open file \"%s\": %s", name, sperror());
  275.         else {
  276. #ifdef FNONBLK
  277.             fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) & ~(FNDELAY|FNONBLK));
  278. #else
  279.             fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) & ~FNDELAY);
  280. #endif
  281.             p->inf = fdopen(fd, "r");
  282.         }
  283.         }
  284.     }
  285.     if(rw > 0) {
  286.         if(strcmp(name, "-") == 0)
  287.         p->outf = stdout;
  288.         else if((p->outf = fopen(name, "w")) == NULL)
  289.         OOGLError(0, "Cannot create \"%s\": %s", name, sperror());
  290.     }
  291.     } else {
  292.     if(rw != 1)
  293.         p->inf = f;
  294.     if(rw > 0)
  295.         p->outf = (rw == 2) ? fdopen(dup(fileno(f)), "w") : f;
  296.     }
  297.  
  298.     if(p->inf == NULL && p->outf == NULL) {
  299.     PoolDelete(p);
  300.     return NULL;
  301.     }
  302.  
  303.     /* We're committed now. */
  304.     if(p->next == AllPools)
  305.     AllPools = p;
  306.     p->seekable = 0;
  307.     p->softEOF = 0;
  308.     if(p->inf != NULL) {
  309.     if(isatty(fileno(p->inf))) {
  310.         p->softEOF = 1;
  311.     } else if(tell(fileno(p->inf)) != -1) {
  312.         p->seekable = 1;
  313.     }
  314.     if(fstat(fileno(p->inf), &st) < 0 || (st.st_mode & S_IFMT) == S_IFIFO)
  315.         p->softEOF = 1;
  316.     p->inf_mtime = st.st_mtime;
  317.  
  318.     watchfd(fileno(p->inf));
  319.     }
  320.     if(p->level == 0 && p->outf &&
  321.         (tell(fileno(p->outf)) == -1 || isatty(fileno(p->outf))))
  322.     p->level = 1;
  323.     return p;
  324. }
  325.  
  326. int
  327. PoolIncLevel(Pool *p, int incr)
  328. {
  329.     return (p->level += incr);
  330. }
  331.  
  332. int
  333. PoolOType(Pool *p, int otype)
  334. {
  335.     return p->otype;
  336. }
  337.  
  338. void
  339. PoolSetOType(Pool *p, int otype)
  340. {
  341.     p->otype = otype;
  342. }
  343.  
  344. FILE *
  345. PoolInputFile(Pool *p)
  346. {
  347.     return (p && p->type == P_STREAM) ? p->inf : NULL;
  348. }
  349.  
  350. FILE *
  351. PoolOutputFile(Pool *p)
  352. {
  353.     return (p && p->type == P_STREAM) ? p->outf : NULL;
  354. }
  355.  
  356. void *
  357. PoolClientData(Pool *p)
  358. {
  359.     return (p ? p->client_data : NULL);
  360. }
  361.  
  362. void
  363. PoolSetClientData(Pool *p, void *data)
  364. {
  365.     p->client_data = data;
  366. }
  367.  
  368. void
  369. PoolDoReread(Pool *p)
  370. {
  371.     p->flags |= PF_REREAD;    /* Reread when asked */
  372. }
  373.  
  374. void PoolClose(register Pool *p)
  375. {
  376.     if(p->ops->close && !(p->flags & PF_CLOSING)) {
  377.     p->flags |= PF_CLOSING;
  378.     if((*p->ops->close)(p))
  379.         return;
  380.     }
  381.  
  382.     if(p->type == P_STREAM) {
  383.     if(p->inf != NULL) {
  384.         unwatchfd(fileno(p->inf));
  385.         if(p->inf != stdin) fclose(p->inf);
  386.         p->inf = NULL;
  387.     }
  388.     if(p->outf != NULL) {
  389.         if(p->outf != stdout) fclose(p->outf);
  390.         p->outf = NULL;
  391.     }
  392.     }
  393. }
  394.  
  395. void PoolDelete(Pool *p)
  396. {
  397.     register Pool **pp;
  398.     register Handle *h;
  399.  
  400.     if(p == NULL || p->flags & PF_DELETED) return;
  401.     p->flags |= PF_DELETED;
  402.  
  403.     if((p->flags & PF_TEMP) == 0) {
  404.     for(pp = &AllPools; *pp != NULL; pp = &(*pp)->next) {
  405.         if(*pp == p) {
  406.         *pp = p->next;
  407.         for(h = AllHandles; h != NULL; h = h->next)
  408.             if(h->whence == p)
  409.             h->whence = NULL;
  410.         break;
  411.         }
  412.     }
  413.     }
  414.  
  415.     OOGLFree(p->poolname);
  416.     p->next = FreePools;
  417.     FreePools = p;
  418. }
  419.  
  420. /*
  421.  * Marks a Pool as being awake.  Doesn't update nexttowake;
  422.  * so this should only be called where awaken_until() gets a chance to run.
  423.  */
  424. static void
  425. awaken(Pool *p)
  426. {
  427.     p->flags &= ~PF_ASLEEP;
  428.     timerclear(&p->awaken);
  429.     if(p->inf != NULL) {
  430.     watchfd(fileno(p->inf));
  431.     if(p->inf->_cnt > 0 && !FD_ISSET(fileno(p->inf), &poolreadyfds)) {
  432.        FD_SET(fileno(p->inf), &poolreadyfds);
  433.        poolnready++;
  434.     }
  435.     }
  436. }
  437.  
  438. static void
  439. awaken_until(struct timeval *until)
  440. {
  441.     register Pool *p;
  442.  
  443.     nexttowake.tv_sec = FOREVER;
  444.     for(p = AllPools; p; p = p->next) {
  445.     if(p->flags & PF_ASLEEP) {
  446.         if(timercmp(&p->awaken, until, <)) {
  447.         awaken(p);
  448.         } else if(p->inf != NULL && timercmp(&p->awaken, &nexttowake, <)) {
  449.         nexttowake = p->awaken;
  450.         }
  451.     }
  452.     }
  453. }
  454.  
  455. /*
  456.  * PoolInputFDs(fds, maxfd)
  457.  * supplies a list of file descriptors for select() to watch for input.
  458.  * Sets *fds to the set of pool input file descriptors
  459.  * Sets *maxfd to the max+1 file descriptor in fds.
  460.  * Returns max time to sleep in seconds; 0 if some Pools have input immediately
  461.  * available (so select() shouldn't block).
  462.  */
  463. float
  464. PoolInputFDs(fd_set *fds, int *maxfd)
  465. {
  466.     float timeleft = FOREVER;
  467.  
  468.     if(nexttowake.tv_sec != FOREVER) {
  469.     struct timeval now;
  470.     gettimeofday(&now, NULL);
  471.     if(timercmp(&nexttowake, &now, <))
  472.        awaken_until(&now);
  473.     timeleft = (nexttowake.tv_sec - now.tv_sec)
  474.             + .000001 * (nexttowake.tv_usec - now.tv_usec);
  475.     }
  476.  
  477.     *fds = poolwatchfds;
  478.     *maxfd = poolmaxfd;
  479.     return poolnready != 0 || timeleft < 0 ? 0 : timeleft;
  480. }
  481.  
  482. /*
  483.  * PoolInAll(fd_set *fds, int nfds)
  484.  * Read from all available pools, given a set of file descriptors
  485.  * which claim to have some input.  We also import from all those which
  486.  * already have buffered input.
  487.  * nfds is an advisory upper bound on the number of fd's in *fds;
  488.  * if the caller doesn't keep the return value from select(), just use
  489.  * FD_SETSIZE or other huge number.
  490.  * Each fd used is removed from *fds, and *nfds is decremented.
  491.  * The return value is 1 if anything was read from any pool, 0 otherwise.
  492.  */
  493. int
  494. PoolInAll(register fd_set *fds, int *nfds)
  495. {
  496.     register Pool *p, *nextp;
  497.     int got = 0;
  498.     struct timeval now;
  499.     int gotnow = 0;
  500.  
  501.     for(p = AllPools; p != NULL; p = nextp) {
  502.     nextp = p->next;    /* Grab it now, in case we PoolDelete(p) */
  503.     if(p->type != P_STREAM || p->inf == NULL)
  504.         continue;
  505.  
  506.     if(FD_ISSET(fileno(p->inf), &poolreadyfds)) {
  507.         FD_CLR(fileno(p->inf), &poolreadyfds);
  508.         poolnready--;
  509.         if(PoolIn(p))
  510.         got++;
  511.     } else if(FD_ISSET(fileno(p->inf), fds)) {
  512.         FD_CLR(fileno(p->inf), fds);
  513.         (*nfds)--;
  514.         if(PoolIn(p))
  515.         got++;
  516.     }
  517.     }
  518.     return got;
  519. }
  520.  
  521. /*
  522.  * Handle NULL or uninitialized times.
  523.  */
  524. static struct timeval *
  525. timeof(struct timeval *when)
  526. {
  527.    static struct timeval now;
  528.    if((when == NULL && (when = &now)) || !timerisset(when))
  529.     gettimeofday(when, NULL);
  530.    return when;
  531. }
  532.     
  533. static void
  534. addtime(struct timeval *base, double offset, struct timeval *result)
  535. {
  536.     double osec = floor(offset);
  537.     result->tv_sec = base->tv_sec + osec;
  538.     result->tv_usec = base->tv_usec + (int)((offset - osec)*1000000);
  539.     while(result->tv_usec >= 1000000) {
  540.     result->tv_sec++;
  541.     result->tv_usec -= 1000000;
  542.     }
  543. }
  544.  
  545. static void
  546. asleep(Pool *p, struct timeval *base, double offset)
  547. {
  548.     struct timeval until;
  549.     base = timeof(base);
  550.     if(p->inf != NULL) {
  551.     p->flags |= PF_ASLEEP;
  552.     addtime(base, offset, &until);
  553.     if(timercmp(&until, &nexttowake, <))
  554.         nexttowake = until;
  555.     unwatchfd(fileno(p->inf));
  556.     if(FD_ISSET(fileno(p->inf), &poolreadyfds)) {
  557.         FD_CLR(fileno(p->inf), &poolreadyfds);
  558.         poolnready--;
  559.     }
  560.     }
  561. }
  562.  
  563. void
  564. PoolSleepUntil(Pool *p, double until)
  565. {
  566.     asleep(p, &p->timebase, until);
  567. }
  568.  
  569. void
  570. PoolSleepFor(Pool *p, double naptime)
  571. {
  572.     asleep(p, NULL, naptime);
  573. }
  574.  
  575. void
  576. PoolSetTime(Pool *p, struct timeval *base, double time_at_base)
  577. {
  578.     base = timeof(base);
  579.     addtime(base, -time_at_base, &p->timebase);
  580. }
  581.  
  582. double
  583. PoolTimeAt(Pool *p, struct timeval *then)
  584. {
  585.     if(p->timebase.tv_sec == 0) timeof(&p->timebase);
  586.     then = timeof(then);
  587.     return then->tv_sec - p->timebase.tv_sec +
  588.         .000001*(then->tv_usec - p->timebase.tv_usec);
  589. }
  590.  
  591. void
  592. PoolAwaken(Pool *p)
  593. {
  594.     awaken(p);
  595.     if(timercmp(&p->awaken, &nexttowake, <=))
  596.     awaken_until(&nexttowake);
  597. }
  598.  
  599. static void
  600. poolresync(Pool *p, int (*resync)())
  601. { /* XXX implement this */
  602. }
  603.  
  604.  
  605. #define    CBRA    '{'
  606. #define    CKET    '}'
  607.  
  608. Handle *
  609. PoolIn(Pool *p)
  610. {
  611.     register int c = 0;
  612.     int fd;
  613.     Handle *h = NULL;
  614.     Ref *r = NULL;
  615.     int ok;
  616.  
  617.     if(p->type != P_STREAM)
  618.     return NULL;        /* Do shared memory here someday XXX */
  619.     if(p->inf == NULL || p->ops == NULL || p->ops->strmin == NULL)
  620.     return NULL;        /* No way to read */
  621.  
  622.     if((p->flags & PF_NOPREFETCH) ||
  623.         ((c = async_fnextc(p->inf, 0)) != NODATA && c != EOF)) {
  624.     /* Kludge.  The interface to TransStreamIn really needs to change. */
  625.  
  626.     if((*p->ops->strmin)(p, &h,
  627.             (strcmp(p->ops->prefix,"trans")==0) ? NULL : &r)) {
  628.  
  629.         /*
  630.          * Attach nameless objects to a handle named for the Pool.
  631.          * Putting this code here in PoolIn() ensures we just bind names to
  632.          * top-level objects, not those nested inside a hierarchy.
  633.          */
  634.         if(h == NULL && r != NULL) {
  635.         h = HandleAssign(p->poolname, p->ops, r);
  636.             /* Decrement reference count since we're handing
  637.              * ownership of the object to the Handle.
  638.              */
  639.         RefDecr(r);
  640.         }
  641.  
  642.  
  643.         /* Remember whether we've read (PF_ANY) at least one and
  644.          * (PF_REREAD) at least two objects from this pool.
  645.          * There'll be a nontrivial side effect of rereading a file
  646.          * containing multiple objects, so we actually do reread if asked.
  647.          */
  648.         p->flags |= (p->flags & PF_ANY) ? PF_REREAD : PF_ANY;
  649.     } else {
  650.         if(p->flags & PF_DELETED)
  651.         return NULL;
  652.         if(p->ops->resync) {
  653.         (*p->ops->resync)(p);
  654.         } else if(p->softEOF) {
  655.         rewind(p->inf);
  656.         } else if(p->inf != NULL) {    /* Careful lest already PoolClose()d */
  657.         if(FD_ISSET(fileno(p->inf), &poolreadyfds)) {
  658.             FD_CLR(fileno(p->inf), &poolreadyfds);
  659.             poolnready--;
  660.         }
  661.         PoolClose(p);
  662.         return NULL;
  663.         }
  664.     }
  665.     if(p->seekable && p->inf != NULL)
  666.         c = fnextc(p->inf, 0);    /* Notice EOF if appropriate */
  667.     }
  668.     if(c == EOF) {
  669.     if(p->softEOF) {
  670.         rewind(p->inf);
  671.     } else {
  672.         PoolClose(p);
  673.         return h;
  674.     }
  675.     }
  676.  
  677.     if(p->inf && !(p->flags & PF_ASLEEP)) {
  678.     /*
  679.      * Anything left in stdio buffer?  If so,
  680.      * remember to try reading next time without waiting for select().
  681.      */
  682.     if(p->inf->_cnt > 0) {
  683.         if(!FD_ISSET(fileno(p->inf), &poolreadyfds)) {
  684.         FD_SET(fileno(p->inf), &poolreadyfds);
  685.         poolnready++;
  686.         }
  687.     } else {
  688.         if(FD_ISSET(fileno(p->inf), &poolreadyfds)) {
  689.         FD_CLR(fileno(p->inf), &poolreadyfds);
  690.         poolnready--;
  691.         }
  692.     }
  693.     }
  694.     return h;
  695. }
  696.  
  697. /*
  698.  * Support routine for writing {handle, object} pairs to Pools.
  699.  * Checks the Pool's output type (PO_HANDLES/PO_DATA/PO_ALL).
  700.  * If appropriate, writes something to the Pool representing the given Handle.
  701.  * Returns nonzero if the associated object should also be written literally.
  702.  */
  703. int
  704. PoolStreamOutHandle(Pool *p, Handle *h, int havedata)
  705. {
  706.     if(p == NULL || p->outf == NULL)
  707.     return 0;
  708.  
  709.     if(h == NULL || p->otype&PO_DATA ||
  710.                 (p->otype&PO_HANDLES && havedata))
  711.     return havedata;
  712.  
  713.     if(h->whence != NULL && h->whence->seekable) {
  714.     fprintf(p->outf, " < \"");
  715.     if(strcmp(h->name, p->poolname) == 0) {
  716.         fprintf(p->outf, "%s\"\n", h->whence->poolname);
  717.     } else {
  718.         fprintf(p->outf, "%s:%s\"\n", h->whence->poolname, h->name);
  719.     }
  720.     } else {
  721.     fprintf(p->outf, ": \"%s\"\n", h->name);
  722.     }
  723.     return ((p->otype & (PO_DATA|PO_HANDLES)) == PO_ALL);
  724. }
  725.