Return to opt.c CVS log

Up to [Research Unix] / researchv10dc / cmd / post

Annotation of researchv10dc/cmd/post/opt.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Query optimization module
                      3:  */
                      4: 
                      5: #include <malloc.h>
                      6: #include <string.h>
                      7: 
                      8: typedef struct {
                      9:        char    *tag;
                     10:        short   count;
                     11:        short   copy[512];
                     12: } opt_t;
                     13: 
                     14: extern char    *pq_open();
                     15: 
                     16: char *
                     17: opt_open(argv)
                     18: char   *argv[];
                     19: {
                     20:        opt_t   *opt = (opt_t *) malloc(sizeof (opt_t));
                     21: 
                     22:        if ((opt->tag = pq_open(argv)) == 0) {
                     23:                free((char *) opt);
                     24:                return 0;
                     25:        }
                     26:        opt->count = -1;
                     27:        return (char *) opt;
                     28: }
                     29: 
                     30: opt_close(opt)
                     31: opt_t  *opt;
                     32: {
                     33:        int rv = pq_close(opt->tag);
                     34:        free((char *) opt);
                     35:        return rv;
                     36: }
                     37: 
                     38: opt_read(opt, argv)
                     39: register opt_t *opt;
                     40: register char  *argv[];
                     41: {
                     42:        register int    rv, i;
                     43: 
                     44:        if ((rv = pq_read(opt->tag, argv)) > 0)
                     45:                for (i = opt->count; i >= 0; i--)
                     46:                        argv[i] = argv[opt->copy[i]];
                     47:        return rv;
                     48: }
                     49: 
                     50: opt_write(opt, argv)
                     51: register opt_t *opt;
                     52: register char  *argv[];
                     53: {
                     54:        register int    i, j, k = 0;
                     55:        char    *vec[512];
                     56: 
                     57:        for (i = 0; argv[i]; i++) {
                     58:                for (j = 0; j < k; j++)
                     59:                        if (eqattr(argv[i], vec[j])) {
                     60:                                if (!strchr(vec[j], '='))
                     61:                                        vec[j] = argv[i];
                     62:                                break;
                     63:                        }
                     64:                if (j == k)
                     65:                        vec[k++] = argv[i];
                     66:                opt->copy[i] = j;
                     67:        }
                     68:        opt->copy[i] = k;
                     69:        opt->count = i;
                     70:        vec[k] = 0;
                     71:        return pq_write(opt->tag, vec);
                     72: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.