/*      $NetBSD$ */

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <prop/proplib.h>

static int
xstrtoul(char *str, u_long *val)
{
       char                    *end;
       int                     base = 10;
       u_long                  v;

       if (str[0] == '0')
               switch (str[1]) {
               case 'x':
                       base = 16;
                       str += 2;
                       break;
               case 'd':
                       base = 10;
                       str += 2;
                       break;
               case 'o':
                       base = 8;
                       str += 2;
                       break;
               case 'b':
                       base = 2;
                       str += 2;
                       break;
               }

       v = strtoul(str, &end, base);
       if (*end != '\0' || str[0] == '\0')
               return (EINVAL);

       *val = v;
       return (0);
}

static prop_object_t
prop_object_internalize_from_file(const char *path)
{
       prop_object_t           po;

       /* XXX this dance is ugly, but we can't do better ATM */
       po = prop_dictionary_internalize_from_file(path);
       if (po == NULL) {
               po = prop_array_internalize_from_file(path);
               if (po == NULL)
                       errx(1, "could not internalize '%s'", path);
       }

       return (po);
}

#define OPTIONS                 "b:ehlo:sI:O:"

static void
usage(void)
{
       const char              *me = getprogname();

       printf("Usage: %s [options] file...\n", me);
       printf("       %s -e file0 file1...\n", me);
       printf("       %s -l\n", me);
       printf("-b size   \t Buffer size for -I\n");
       printf("-e        \t Pairwise compare plists\n");
       printf("-h        \t Print (this) help\n");
       printf("-l        \t Print available codecs\n");
       printf("-o file   \t Output file [stdout]\n");
       printf("-s        \t Silent operation\n");
       printf("-O format \t Output format\n");
       printf("-I format \t Input format when reading from stdin\n");
       exit(0);
}

int
main(int argc, char *argv[])
{
       u_char                  *buf;
       prop_parser_t           parser;
       prop_codec_t            codeco = NULL;
       prop_codec_t            codeci = NULL;
       prop_object_t           object;
       char                    *s;
       ssize_t                 len;
       int                     c, i, ret;
       int                     fdo = STDOUT_FILENO;
       int                     cmp = 0;
       u_long                  buflen = 8192;
       int                     silent = 0;

       codeci = codeco = prop_codec_lookup(NULL);
       if (codeco == NULL)
               errx(1, "could not find default codec");

       while ((c = getopt(argc, argv, OPTIONS)) != -1)
               switch (c) {
               case 'b': /* Buffer size for -I. */
                       if (xstrtoul(optarg, &buflen))
                               errx(1, "not a number '%s'", optarg);
                       if (buflen == 0)
                               errx(1, "buffer size must be nonzero");
                       break;

               case 'e': /* Compare plists. */
                       cmp = 1;
                       break;

               case 'h': /* Help. */
                       usage();
                       /* UNREACHED */

               case 'l': /* List available codecs */
                       printf("%s\n", prop_codec_list());
                       return (0);

               case 'o': /* Output file. */
                       fdo = open(optarg, O_WRONLY|O_CREAT|O_TRUNC, 0644);
                       if (fdo == -1)
                               errx(1, "could not open output '%s'", optarg);
                       break;

               case 's': /* Silent operation. */
                       silent = 1;
                       break;

               case 'I': /* Input format. */
                       codeci = prop_codec_lookup(optarg);
                       if (codeci == NULL)
                               errx(1, "could not find codec '%s'", optarg);
                       break;

               case 'O': /* Output format. */
                       codeco = prop_codec_lookup(optarg);
                       if (codeco == NULL)
                               errx(1, "could not find codec '%s'", optarg);
                       break;

               case '?':
                       errx(1, "uknown option -%c", optopt);
                       /* UNREACHED */

               case ':':
                       errx(1, "missing argument to -%c", optopt);
                       /* UNREACHED */
               }

       argc -= optind;
       argv += optind;

       if (cmp) {
               prop_object_t           po, pq;

               if (argc == 0 || (argc % 2) != 0)
                       errx(1, "can only compare even number of plists");

               for (i = 0; i < argc; i += 2) {
                       char            *one = argv[i];
                       char            *two = argv[i + 1];

                       po = prop_object_internalize_from_file(one);
                       pq = prop_object_internalize_from_file(two);

                       if (prop_object_equals(po, pq)) {
                               if (! silent)
                                       printf("%s == %s\n", one, two);
                       } else {
                               if (! silent)
                                       printf("%s != %s\n", one, two);
                               return (1);
                       }

                       prop_object_release(po);
                       prop_object_release(pq);
               }
       } else {
               prop_object_t           po;
               char                    *s;

               for (i = 0; i < argc; i++) {
                       po = prop_object_internalize_from_file(argv[i]);

                       s = prop_codec_externalize(codeco, po);
                       if (s == NULL)
                               errx(1, "could not externalize '%s'", argv[i]);

                       if (write(fdo, s, strlen(s)) == -1)
                               err(1, "could not write output");

                       free(s);
                       prop_object_release(po);
               }
       }

       /* If we were called to recode or compare files our job is done. */
       if (argc != 0)
               return (0);

       buf = malloc(buflen);
       if (buf == NULL)
               errx(1, "could not allocate input buffer");

       /* Otherwise we're supposed to read stdin. */
       ret = prop_parser_create(codeci, &parser);
       if (ret)
               errx(1, "could not create parser: %s", strerror(ret));

       while ((len = read(STDIN_FILENO, buf, buflen)) >= 0) {
               ret = prop_parser_exec(codeci, parser, buf, len);
               if (ret)
                       errx(1, "%s", strerror(ret));

               while ((object = prop_parser_yield(codeci, parser)) != NULL) {
                       s = prop_codec_externalize(codeco, object);
                       if (s == NULL)
                               errx(1, "could not externalize with codec");

                       if (write(fdo, s, strlen(s)) == -1)
                               err(1, "could not write output");

                       free(s);
                       prop_object_release(object);
               }

               if (len == 0)
                       break;
       }

       prop_parser_destroy(codeci, parser);
       return (0);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.