filter.c
changeset 1 5af08d964c9e
parent 0 7f37716d4f1e
child 2 57a1fcb0c75c
equal deleted inserted replaced
0:7f37716d4f1e 1:5af08d964c9e
     4 #include <sys/types.h>
     4 #include <sys/types.h>
     5 #include <sys/wait.h>
     5 #include <sys/wait.h>
     6 #include <unistd.h>
     6 #include <unistd.h>
     7 
     7 
     8 #include "dictre.h"
     8 #include "dictre.h"
       
     9 
       
    10 enum
       
    11 {
       
    12     SIZESTEP=100
       
    13 };
     9 
    14 
    10 extern struct Def defs[];
    15 extern struct Def defs[];
    11 extern int ndefs;
    16 extern int ndefs;
    12 extern int dont_touch[];
    17 extern int dont_touch[];
    13 extern int ndont_touch;
    18 extern int ndont_touch;
    30     char *out;
    35     char *out;
    31     int outsize;
    36     int outsize;
    32     int outrest;
    37     int outrest;
    33 
    38 
    34     out = 0;
    39     out = 0;
    35     outsize = 1000;
    40     outsize = SIZESTEP;
    36     outptr = 0;
    41     outptr = 0;
    37     more_memory((void **) &out, outsize);
    42     more_memory((void **) &out, outsize);
    38     outrest = 1000;
    43     outrest = SIZESTEP;
    39 
    44 
    40     maxfd = writeto;
    45     maxfd = writeto;
    41     if (readfrom > maxfd)
    46     if (readfrom > maxfd)
    42         maxfd = readfrom;
    47         maxfd = readfrom;
    43 
    48 
    64             }
    69             }
    65             outrest -= res;
    70             outrest -= res;
    66             outptr += res;
    71             outptr += res;
    67             if (outrest == 0)
    72             if (outrest == 0)
    68             {
    73             {
    69                 outrest = 1000;
    74                 outrest = SIZESTEP;
    70                 outsize += 1000;
    75                 outsize += SIZESTEP;
    71                 more_memory((void **) &out, outsize);
    76                 more_memory((void **) &out, outsize);
    72             }
    77             }
    73         }
    78         }
    74 
    79 
    75         if (FD_ISSET(writeto, &writeset))
    80         if (FD_ISSET(writeto, &writeset))
    76         {
    81         {
    77             int res;
    82             int res;
    78             res = write(writeto, def+defptr, 1);
    83             res = write(writeto, def+defptr, deflen - defptr);
    79             defptr++;
    84             defptr += res;
    80             if (defptr >= deflen)
    85             if (defptr >= deflen)
    81                 close(writeto);
    86                 close(writeto);
    82         }
    87         }
    83     } while(1);
    88     } while(1);
    84 
    89 
   166     {
   171     {
   167         char *newdef;
   172         char *newdef;
   168         int newdeflen;
   173         int newdeflen;
   169         if (!in_dont_touch(i))
   174         if (!in_dont_touch(i))
   170         {
   175         {
   171             newdef = filter(defs[i].d, defs[i].length,
   176             if (defs[i].length > 0)
   172                     filter_par, &newdeflen);
   177             {
   173             defs[i].length = newdeflen;
   178                 newdef = filter(defs[i].d, defs[i].length,
   174             defs[i].d = newdef;
   179                         filter_par, &newdeflen);
       
   180                 defs[i].length = newdeflen;
       
   181                 free(defs[i].d);
       
   182                 defs[i].d = newdef;
       
   183             }
   175         }
   184         }
   176     }
   185     }
   177 }
   186 }