git.pond.sub.org Git - empserver/blob - src/util/empdump.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2008, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                           Ken Stevens, Steve McClure
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  *  ---
  21  *
  22  *  See files README, COPYING and CREDITS in the root of the source
  23  *  tree for related information and legal notices.  It is expected
  24  *  that future projects/authors will amend these files as needed.
  25  *
  26  *  ---
  27  *
  28  *  empdump.c: Export/import Empire game state
  29  *
  30  *  Known contributors to this file:
  31  *     Markus Armbruster, 2008
  32  */
  33
  34 #include <config.h>
  35
  36 #include <ctype.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <limits.h>
  40 #include <stdarg.h>
  41 #include <stdio.h>
  42 #include <unistd.h>
  43 #include "file.h"
  44 #include "nat.h"
  45 #include "optlist.h"
  46 #include "prototypes.h"
  47 #include "version.h"
  48 #include "xdump.h"
  49
  50 static void dump_table(int, int);
  51
  52 int
  53 main(int argc, char *argv[])
  54 {
  55     char *config_file = NULL;
  56     char *import = NULL;
  57     int export = 0;
  58     int private = 0;
  59     int human = 1;
  60     int opt, i, lineno, type;
  61     FILE *impf;
  62     int dirty[EF_MAX];
  63
  64     while ((opt = getopt(argc, argv, "e:mtxhv")) != EOF) {
  65         switch (opt) {
  66         case 'e':
  67             config_file = optarg;
  68             break;
  69         case 'h':
  70             printf("Usage: %s [OPTION]... [DUMP-FILE]\n"
  71                    "  -e CONFIG-FILE  configuration file\n"
  72                    "                  (default %s)\n"
  73                    "  -m              use machine-readable format\n"
  74                    "  -t              test import, don't update game state\n"
  75                    "  -x              export to standard output\n"
  76                    "  -h              display this help and exit\n"
  77                    "  -v              display version information and exit\n",
  78                    argv[0], dflt_econfig);
  79             exit(0);
  80         case 'm':
  81             human = 0;
  82             break;
  83         case 't':
  84             private = EFF_PRIVATE;
  85             break;
  86         case 'x':
  87             export = 1;
  88             break;
  89         case 'v':
  90             printf("%s\n\n%s", version, legal);
  91             exit(0);
  92         default:
  93             fprintf(stderr, "Try -h for help.\n");
  94             exit(1);
  95         }
  96     }
  97
  98     if (argv[optind])
  99         import = argv[optind++];
 100
 101     if (import) {
 102         impf = fopen(import, "r");
 103         if (!impf) {
 104             fprintf(stderr, "Cant open %s for reading (%s)\n",
 105                     import, strerror(errno));
 106             exit(1);
 107         }
 108     } else
 109         private = EFF_PRIVATE;
 110
 111     /* read configuration & initialize */
 112     empfile_init();
 113     if (emp_config(config_file) < 0)
 114         exit(1);
 115     empfile_fixup();
 116     nsc_init();
 117     if (read_builtin_tables() < 0)
 118         exit(1);
 119     if (read_custom_tables() < 0)
 120         exit(1);
 121     if (chdir(gamedir)) {
 122         fprintf(stderr, "Can't chdir to %s (%s)\n",
 123                 gamedir, strerror(errno));
 124         exit(1);
 125     }
 126     global_init();
 127
 128     for (i = 0; i < EF_MAX; i++) {
 129         if (!EF_IS_GAME_STATE(i))
 130             continue;
 131         if (!ef_open(i, EFF_MEM | private))
 132             exit(1);
 133     }
 134
 135     /* import from IMPORT */
 136     memset(dirty, 0, sizeof(dirty));
 137     if (import) {
 138         lineno = 1;
 139         while ((type = xundump(impf, import, &lineno, EF_BAD)) >= 0)
 140             dirty[type] = 1;
 141         if (type == EF_BAD)
 142             exit(1);
 143     }
 144
 145     if (ef_verify() < 0)
 146         exit(1);
 147
 148     /* export to stdout */
 149     if (export) {
 150         for (i = 0; i < EF_MAX; i++) {
 151             if (!EF_IS_GAME_STATE(i))
 152                 continue;
 153             dump_table(i, human);
 154         }
 155     }
 156
 157     /* write out imported data */
 158     for (i = 0; i < EF_MAX; i++) {
 159         if (!EF_IS_GAME_STATE(i))
 160             continue;
 161         if (!private && dirty[i]) {
 162             if (!ef_close(i))
 163                 exit(1);
 164         }
 165     }
 166
 167     return 0;
 168 }
 169
 170 static void
 171 printf_wrapper(char *fmt, ...)
 172 {
 173     va_list ap;
 174
 175     va_start(ap, fmt);
 176     vprintf(fmt, ap);
 177     va_end(ap);
 178 }
 179
 180 static void
 181 dump_table(int type, int human)
 182 {
 183     struct xdstr xd;
 184     struct castr *ca;
 185     int i;
 186     void *p;
 187
 188     ca = ef_cadef(type);
 189     if (!ca)
 190         return;
 191
 192     xdinit(&xd, 0, human, printf_wrapper);
 193     xdhdr(&xd, ef_nameof(type), 0);
 194     xdcolhdr(&xd, ca);
 195     for (i = 0; (p = ef_ptr(type, i)); i++) {
 196         xdflds(&xd, ca, p);
 197         printf("\n");
 198     }
 199     xdftr(&xd, i);
 200 }