7054e06e42
Make some progress on a couple of next minor release checklist
items, hopefully without introducing too many new bugs. This
is just the initial commit, and work continues.
Checklist items:
Savefiles compatible between Windows versions, whether 64-bit
or 32-bit in little-endian field format.
Selection of file formats:
historical (structlevel saves),
lendian (little-endian, fieldlevel saves),
and just for proof-of-concept, ascii fieldlevel saves
(the ascii is huge! 10x bigger than little-endian).
For the fieldlevel save, all complex data structures recursively
get broken down until until it is one of the simple types that
can't be broken down any further, and that gets when it gets
written to the output file.
New files needed for this build:
hand-coded:
include/sfprocs.h
src/sfbase.c - really a dispatcher to one of the
output/input format routines.
src/sflendian.c - little-endian output writer/reader.
src/sfascii.c - ascii text output writer/reader.
auto-coded (generated):
include/sfproto.h
src/sfdata.c
This is just one approach. I'm sure there are countless others
and they have different pros and cons.
For producing the auto-coded files a utility called
universal-ctags, that is actively maintained and evolving,
was used to do all the heavy-lifting of parsing the
NetHack C sources to tabulate the data fields, and store
them in an intermediate file called util/nethack.tags
(not required for building NetHack if you already have a
generated include/sfproto.h and src/sfdata.c)
util/readtags (also not required for building NetHack
itself) will decipher the nethack.tags file and produce
the functions that can deal with the NetHack struct data
fields.
You can obtain the source for universal-ctags by cloning it
from here:
https://github.com/universal-ctags/ctags.git
The combination universal-ctags + util/readtags has been
tried and tested under both Windows and Linux, so it is
not tied to a particular platform.
Note: util/readtags will work only with universal-ctags
output, so other ctags are unlikely to work as-is.
Universal-ctags can be build from source very easily
under Linux, or under Windows using visual studio.
1113 lines
25 KiB
C
1113 lines
25 KiB
C
/* NetHack 3.6 sfascii.c $NHDT-Date$ $NHDT-Branch$:$NHDT-Revision$ */
|
|
/* Copyright (c) Michael Allison, 2019. */
|
|
/* NetHack may be freely redistributed. See license for details. */
|
|
|
|
#include "hack.h"
|
|
#include "integer.h"
|
|
#include "sfprocs.h"
|
|
|
|
static void FDECL(put_savefield, (NHFILE *, char *, size_t));
|
|
char *FDECL(get_savefield, (NHFILE *, char *, size_t));
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
void FDECL(report_problem_ascii, (NHFILE *, const char *, const char *, const char *));
|
|
#endif
|
|
|
|
struct sf_procs ascii_sfo_procs = {
|
|
"-ascii",
|
|
{
|
|
ascii_sfo_aligntyp,
|
|
ascii_sfo_any,
|
|
ascii_sfo_bitfield,
|
|
ascii_sfo_boolean,
|
|
ascii_sfo_char,
|
|
ascii_sfo_genericptr,
|
|
ascii_sfo_int,
|
|
ascii_sfo_long,
|
|
ascii_sfo_schar,
|
|
ascii_sfo_short,
|
|
ascii_sfo_size_t,
|
|
ascii_sfo_time_t,
|
|
ascii_sfo_unsigned,
|
|
ascii_sfo_uchar,
|
|
ascii_sfo_uint,
|
|
ascii_sfo_ulong,
|
|
ascii_sfo_ushort,
|
|
ascii_sfo_xchar,
|
|
ascii_sfo_str,
|
|
ascii_sfo_addinfo,
|
|
}
|
|
};
|
|
|
|
struct sf_procs ascii_sfi_procs =
|
|
{
|
|
"-ascii",
|
|
{
|
|
ascii_sfi_aligntyp,
|
|
ascii_sfi_any,
|
|
ascii_sfi_bitfield,
|
|
ascii_sfi_boolean,
|
|
ascii_sfi_char,
|
|
ascii_sfi_genericptr,
|
|
ascii_sfi_int,
|
|
ascii_sfi_long,
|
|
ascii_sfi_schar,
|
|
ascii_sfi_short,
|
|
ascii_sfi_size_t,
|
|
ascii_sfi_time_t,
|
|
ascii_sfi_unsigned,
|
|
ascii_sfi_uchar,
|
|
ascii_sfi_uint,
|
|
ascii_sfi_ulong,
|
|
ascii_sfi_ushort,
|
|
ascii_sfi_xchar,
|
|
ascii_sfi_str,
|
|
ascii_sfi_addinfo,
|
|
}
|
|
};
|
|
|
|
static char linebuf[BUFSZ];
|
|
static char outbuf[BUFSZ];
|
|
|
|
/*
|
|
*----------------------------------------------------------------------------
|
|
* sfo_def_ routines
|
|
*
|
|
* Default output routines.
|
|
*
|
|
*----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
ascii_sfo_any(nhfp, d_any, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
union any *d_any;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
char *parent = "any";
|
|
|
|
Sprintf(outbuf, "%llx", (unsigned long long) d_any->a_void);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
|
|
Sprintf(outbuf, "%lu", d_any->a_ulong);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
|
|
Sprintf(outbuf, "%ld", d_any->a_long);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
|
|
Sprintf(outbuf, "%d", d_any->a_uint);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
|
|
Sprintf(outbuf, "%d", d_any->a_int);;
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
|
|
Sprintf(outbuf, "%hd", (short) d_any->a_char);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
|
|
#if 0
|
|
sfo_genericptr(nhfp, d_any->a_void, parent, "a_void", 1); /* (genericptr_t) */
|
|
sfo_genericptr(nhfp, d_any->a_obj, parent, "a_obj", 1); /* (struct obj *) */
|
|
sfo_genericptr(nhfp, d_any->a_monst, parent, "a_monst", 1); /* (struct monst *) */
|
|
sfo_int(nhfp, &d_any->a_int, parent, "a_int", 1); /* (int) */
|
|
sfo_char(nhfp, &d_any->a_char, parent, "a_char", 1); /* (char) */
|
|
sfo_schar(nhfp, &d_any->a_schar, parent, "a_schar", 1); /* (schar) */
|
|
sfo_uchar(nhfp, &d_any->a_uchar, parent, "a_uchar", 1); /* (uchar) */
|
|
sfo_uint(nhfp, &d_any->a_uint, parent, "a_uint", 1); /* (unsigned int) */
|
|
sfo_long(nhfp, &d_any->a_long, parent, "a_long", 1); /* (long) */
|
|
sfo_ulong(nhfp, &d_any->a_ulong, parent, "a_ulong", 1); /* (unsigned long) */
|
|
sfo_genericptr(nhfp, d_any->a_iptr, parent, "a_iptr", 1); /* (int *) */
|
|
sfo_genericptr(nhfp, d_any->a_lptr, parent, "a_lptr", 1); /* (long *) */
|
|
sfo_genericptr(nhfp, d_any->a_ulptr, parent, "a_ulptr", 1); /* (unsigned long *) */
|
|
sfo_genericptr(nhfp, d_any->a_uptr, parent, "a_uptr", 1); /* (unsigned *) */my
|
|
sfo_genericptr(nhfp, d_any->a_string, parent, "a_string", 1); /* (const char *) */
|
|
sfo_ulong(nhfp, &d_any->a_mask32, parent, "a_mask32", 1); /* (unsigned long) */
|
|
#endif
|
|
}
|
|
|
|
void
|
|
ascii_sfo_aligntyp(nhfp, d_aligntyp, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
aligntyp *d_aligntyp;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int itmp;
|
|
const char *parent = "aligntyp";
|
|
|
|
itmp = (int) *d_aligntyp;
|
|
Sprintf(outbuf, "%d", (short) itmp);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
}
|
|
|
|
void
|
|
ascii_sfo_bitfield(nhfp, d_bitfield, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
uint8_t *d_bitfield;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
const char *parent = "bitfield";
|
|
|
|
/* for bitfields, cnt is the number of bits, not an array */
|
|
Sprintf(outbuf, "%hu", (unsigned short) *d_bitfield);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
}
|
|
|
|
void
|
|
ascii_sfo_boolean(nhfp, d_boolean, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
boolean *d_boolean;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "boolean";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
if (nhfp->fpdebug)
|
|
fprintf(nhfp->fpdebug, "(%s)\n", (*d_boolean) ? "TRUE" : "FALSE");
|
|
Sprintf(outbuf, "%s", *d_boolean ? "true" : "false");
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_boolean++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_char(nhfp, d_char, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
char *d_char;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i = cnt;
|
|
const char *parent = "char";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
if (nhfp->fpdebug)
|
|
fprintf(nhfp->fpdebug, "(%s)\n", d_char ? d_char : "");
|
|
Sprintf(outbuf, "%hd", (short) *d_char);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_char++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_genericptr(nhfp, d_genericptr, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
genericptr_t *d_genericptr;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
unsigned long tmp;
|
|
char *byteptr = (char *) d_genericptr;
|
|
const char *parent = "genericptr";
|
|
|
|
/*
|
|
* sbrooms is an array of pointers to mkroom.
|
|
* That array dimension is MAX_SUBROOMS.
|
|
* Even though the pointers themselves won't
|
|
* be valid, we need to account for the existence
|
|
* of that array and perhaps zero or non-zero.
|
|
*/
|
|
for (i = 0; i < cnt; ++i) {
|
|
tmp = (*d_genericptr) ? 1UL : 0UL;
|
|
Sprintf(outbuf, "%08lu", tmp);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
if (cnt > 1) {
|
|
byteptr += sizeof(void *);
|
|
d_genericptr = (genericptr_t) byteptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_int(nhfp, d_int, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
int *d_int;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "int";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
Sprintf(outbuf, "%d", *d_int);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_int++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_long(nhfp, d_long, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
long *d_long;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "long";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
Sprintf(outbuf, "%ld", *d_long);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_long++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_schar(nhfp, d_schar, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
schar *d_schar;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i, itmp;
|
|
const char *parent = "schar";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
itmp = (int) *d_schar;
|
|
Sprintf(outbuf, "%d", itmp);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_schar++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_short(nhfp, d_short, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
short *d_short;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "short";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
Sprintf(outbuf, "%hd", *d_short);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_short++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_size_t(nhfp, d_size_t, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
size_t *d_size_t;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "size_t";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
unsigned long ul = (unsigned long) *d_size_t;
|
|
|
|
Sprintf(outbuf, "%lu", ul);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_size_t++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_time_t(nhfp, d_time_t, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
time_t *d_time_t;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
const char *parent = "time_t";
|
|
|
|
Sprintf(outbuf, "%s", yyyymmddhhmmss(*d_time_t));
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
}
|
|
|
|
void
|
|
ascii_sfo_unsigned(nhfp, d_unsigned, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned *d_unsigned;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
ascii_sfo_uint(nhfp, d_unsigned, myparent, myname, cnt);
|
|
}
|
|
|
|
void
|
|
ascii_sfo_uchar(nhfp, d_uchar, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned char *d_uchar;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "uchar";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
unsigned short us = (unsigned short) *d_uchar;
|
|
|
|
Sprintf(outbuf, "%hu", us);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_uchar++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_uint(nhfp, d_uint, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned int *d_uint;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "uint";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
Sprintf(outbuf, "%u", *d_uint);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_uint++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_ulong(nhfp, d_ulong, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned long *d_ulong;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "ulong";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
Sprintf(outbuf, "%lu", *d_ulong);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_ulong++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_ushort(nhfp, d_ushort, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned short *d_ushort;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "ushort";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
Sprintf(outbuf, "%hu", *d_ushort);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_ushort++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfo_xchar(nhfp, d_xchar, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
xchar *d_xchar;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "xchar";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
short tmp;
|
|
|
|
tmp = (short) *d_xchar;
|
|
Sprintf(outbuf, "%hu", tmp);
|
|
put_savefield(nhfp, outbuf, BUFSZ);
|
|
d_xchar++;
|
|
}
|
|
}
|
|
|
|
static char strbuf[BUFSZ * 4];
|
|
|
|
void
|
|
ascii_sfo_str(nhfp, d_str, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
char *d_str;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i, j, intval;
|
|
const char *parent = "str";
|
|
char sval[QBUFSZ], *src = d_str, *dest = strbuf;
|
|
|
|
/* cnt is the number of characters */
|
|
for (i = 0; i < cnt; ++i) {
|
|
if ((*src < 32) || (*src == '\\') || (*src > 128)) {
|
|
*dest++ = '\\';
|
|
intval = (int) *src++;
|
|
Sprintf(sval, "%03d", intval);
|
|
for (j = 0; j < 3; ++j)
|
|
*dest++ = sval[j];
|
|
} else {
|
|
*dest++ = *src++;
|
|
}
|
|
}
|
|
put_savefield(nhfp, strbuf, BUFSZ * 4);
|
|
}
|
|
|
|
void
|
|
ascii_sfo_addinfo(nhfp, parent, action, myname, index)
|
|
NHFILE *nhfp;
|
|
const char *parent, *action, *myname;
|
|
int index;
|
|
{
|
|
/* ignored */
|
|
}
|
|
|
|
|
|
static void
|
|
put_savefield(nhfp, outbuf, outbufsz)
|
|
NHFILE *nhfp;
|
|
char *outbuf;
|
|
size_t outbufsz;
|
|
{
|
|
nhfp->count++;
|
|
fprintf(nhfp->fpdef, "%07ld|%s\n", nhfp->count, outbuf);
|
|
}
|
|
|
|
/*
|
|
*----------------------------------------------------------------------------
|
|
* ascii_sfi_ routines called from functions in sfi_base.c
|
|
*----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
ascii_sfi_any(nhfp, d_any, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
union any *d_any;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
char *rstr;
|
|
long long tmp;
|
|
const char *parent = "any";
|
|
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
tmp = atoll(rstr);
|
|
d_any->a_void = (void *) tmp;
|
|
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
tmp = atoll(rstr);
|
|
d_any->a_ulong = (unsigned long) tmp;
|
|
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
d_any->a_long = atol(rstr);
|
|
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
tmp = atoll(rstr);
|
|
d_any->a_uint = (unsigned int) tmp;
|
|
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
d_any->a_int = atoi(rstr);
|
|
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
d_any->a_char = (char) atoi(rstr);
|
|
|
|
#if 0
|
|
sfi_genericptr(nhfp, d_any->a_void, parent, "a_void", 1);
|
|
sfi_genericptr(nhfp, d_any->a_obj, parent, "a_obj", 1);
|
|
sfi_genericptr(nhfp, d_any->a_monst, parent, "a_monst", 1);
|
|
sfi_int(nhfp, &d_any->a_int, parent, "a_int", 1);
|
|
sfi_char(nhfp, &d_any->a_char, parent, "a_char", 1);
|
|
sfi_schar(nhfp, &d_any->a_schar, parent, "a_schar", 1);
|
|
sfi_uchar(nhfp, &d_any->a_uchar, parent, "a_uchar", 1);
|
|
sfi_uint(nhfp, &d_any->a_uint, parent, "a_uint", 1);
|
|
sfi_long(nhfp, &d_any->a_long, parent, "a_long", 1);
|
|
sfi_ulong(nhfp, &d_any->a_ulong, parent, "a_ulong", 1);
|
|
sfi_genericptr(nhfp, d_any->a_iptr, parent, "a_iptr", 1);
|
|
sfi_genericptr(nhfp, d_any->a_lptr, parent, "a_lptr", 1);
|
|
sfi_genericptr(nhfp, d_any->a_ulptr, parent, "a_ulptr", 1);
|
|
sfi_genericptr(nhfp, d_any->a_uptr, parent, "a_uptr", 1);
|
|
sfi_genericptr(nhfp, d_any->a_string, parent, "a_string", 1);
|
|
sfi_ulong(nhfp, &d_any->a_mask32, parent, "a_mask32", 1);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
ascii_sfi_aligntyp(nhfp, d_aligntyp, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
aligntyp *d_aligntyp;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
char *rstr;
|
|
aligntyp tmp;
|
|
long long lltmp;
|
|
const char *parent = "aligntyp";
|
|
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
lltmp = atoll(rstr);
|
|
tmp = (aligntyp) lltmp;
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_aligntyp)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_aligntyp = tmp;
|
|
}
|
|
|
|
void
|
|
ascii_sfi_bitfield(nhfp, d_bitfield, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
uint8_t *d_bitfield;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
char *rstr;
|
|
uint8_t tmp;
|
|
const char *parent = "bitfield";
|
|
|
|
/* cnt is the number of bits in the bitfield, not an array dimension */
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
tmp = (uint8_t) atoi(rstr);
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_bitfield)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_bitfield = tmp;
|
|
}
|
|
|
|
void
|
|
ascii_sfi_boolean(nhfp, d_boolean, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
boolean *d_boolean;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
char *rstr;
|
|
int i;
|
|
const char *parent = "boolean";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (!strcmpi(rstr, "false") &&
|
|
!strcmpi(rstr, "true"))
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
if (!strcmpi(rstr, "false"))
|
|
*d_boolean = FALSE;
|
|
else
|
|
*d_boolean = TRUE;
|
|
d_boolean++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_char(nhfp, d_char, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
char *d_char;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
char *rstr;
|
|
int i;
|
|
char tmp;
|
|
const char *parent = "char";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
tmp = (char) atoi(rstr);
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_char)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_char = tmp;
|
|
d_char++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_genericptr(nhfp, d_genericptr, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
genericptr_t *d_genericptr;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
long long lltmp;
|
|
char *rstr;
|
|
const char *parent = "genericptr";
|
|
static char *glorkum = "glorkum";
|
|
char *byteptr = (char *) d_genericptr;
|
|
|
|
/*
|
|
* sbrooms is an array of pointers to mkroom.
|
|
* That array dimension is MAX_SUBROOMS.
|
|
* Even though the pointers themselves won't
|
|
* be valid, we need to account for the existence
|
|
* of that array.
|
|
*/
|
|
for (i = 0; i < cnt; ++i) {
|
|
/* these pointers can't actually be valid */
|
|
byteptr = (char *) d_genericptr;
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
lltmp = atoll(rstr);
|
|
*d_genericptr = lltmp ? (genericptr_t) glorkum : (genericptr_t) 0;
|
|
if (cnt > 1) {
|
|
byteptr += sizeof(void *);
|
|
d_genericptr = (genericptr_t) byteptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_int(nhfp, d_int, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
int *d_int;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i, tmp;
|
|
char *rstr;
|
|
long long lltmp;
|
|
const char *parent = "int";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
lltmp = atoll(rstr);
|
|
tmp = (int) lltmp;
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_int)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_int = tmp;
|
|
d_int++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_long(nhfp, d_long, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
long *d_long;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
long tmp;
|
|
long long lltmp;
|
|
char *rstr;
|
|
const char *parent = "long";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
lltmp = atoll(rstr);
|
|
tmp = (long) lltmp;
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_long)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_long = tmp;
|
|
d_long++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_schar(nhfp, d_schar, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
schar *d_schar;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
schar tmp;
|
|
char *rstr;
|
|
const char *parent = "schar";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
tmp = (schar) atoi(rstr);
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_schar)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_schar = tmp;
|
|
d_schar++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_short(nhfp, d_short, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
short *d_short;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
short tmp;
|
|
char *rstr;
|
|
const char *parent = "short";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
tmp = (short) atoi(rstr);
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_short)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_short = tmp;
|
|
d_short++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_size_t(nhfp, d_size_t, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
size_t *d_size_t;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
size_t tmp;
|
|
char *rstr;
|
|
const char *parent = "size_t";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
tmp = (size_t) atol(rstr);
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_size_t)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_size_t = tmp;
|
|
d_size_t++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_time_t(nhfp, d_time_t, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
time_t *d_time_t;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
time_t tmp;
|
|
char *rstr;
|
|
const char *parent = "time_t";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
tmp = time_from_yyyymmddhhmmss(rstr);
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_time_t)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_time_t = tmp;
|
|
d_time_t++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_unsigned(nhfp, d_unsigned, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned *d_unsigned;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
/* deferal */
|
|
ascii_sfi_uint(nhfp, d_unsigned, myparent, myname, cnt);
|
|
}
|
|
|
|
void
|
|
ascii_sfi_uchar(nhfp, d_uchar, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned char *d_uchar;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
uchar tmp;
|
|
int i, itmp;
|
|
char *rstr;
|
|
const char *parent = "uchar";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
itmp = atoi(rstr);
|
|
tmp = (char ) itmp;
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_uchar)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_uchar = tmp;
|
|
d_uchar++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_uint(nhfp, d_uint, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned int *d_uint;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
char *rstr;
|
|
unsigned int tmp;
|
|
long long lltmp;
|
|
const char *parent = "uint";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
lltmp = atoll(rstr);
|
|
tmp = (unsigned int) lltmp;
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_uint)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_uint = tmp;
|
|
d_uint++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_ulong(nhfp, d_ulong, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned long *d_ulong;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
unsigned long tmp;
|
|
long long lltmp;
|
|
char *rstr;
|
|
const char *parent = "ulong";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
lltmp = atoll(rstr);
|
|
tmp = (unsigned long) lltmp;
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_ulong)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_ulong = tmp;
|
|
d_ulong++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_ushort(nhfp, d_ushort, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
unsigned short *d_ushort;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
short tmp;
|
|
long long lltmp;
|
|
char *rstr;
|
|
const char *parent = "ushort";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
lltmp = atoll(rstr);
|
|
tmp = (unsigned short) lltmp;
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_ushort)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_ushort = tmp;
|
|
d_ushort++;
|
|
}
|
|
}
|
|
|
|
void
|
|
ascii_sfi_xchar(nhfp, d_xchar, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
xchar *d_xchar;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
xchar tmp;
|
|
int i, itmp;
|
|
char *rstr;
|
|
const char *parent = "xchar";
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
rstr = get_savefield(nhfp, linebuf, BUFSZ);
|
|
itmp = atoi(rstr);
|
|
tmp = (xchar) itmp;
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel && tmp != *d_xchar)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else
|
|
#endif
|
|
*d_xchar = tmp;
|
|
d_xchar++;
|
|
}
|
|
}
|
|
|
|
static char strbuf[BUFSZ * 4];
|
|
|
|
void
|
|
ascii_sfi_str(nhfp, d_str, myparent, myname, cnt)
|
|
NHFILE *nhfp;
|
|
char *d_str;
|
|
const char *myparent;
|
|
const char *myname;
|
|
int cnt;
|
|
{
|
|
int i, j, sval;
|
|
char n[4], *rstr;
|
|
const char *parent = "str";
|
|
char *src, *dest;
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
boolean match;
|
|
char testbuf[BUFSZ];
|
|
#endif
|
|
|
|
/* cnt is the length of the string */
|
|
rstr = get_savefield(nhfp, strbuf, BUFSZ * 4);
|
|
src = rstr;
|
|
dest =
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
testbuf;
|
|
#else
|
|
d_str;
|
|
#endif
|
|
|
|
for (i = 0; i < cnt; ++i) {
|
|
if (*src == '\\') {
|
|
src++;
|
|
for (j = 0; j < 4; ++j) {
|
|
if (j < 3)
|
|
n[j] = *src++;
|
|
else
|
|
n[j] = '\0';
|
|
}
|
|
sval = atoi(n);
|
|
*dest++ = (char) sval;
|
|
} else
|
|
*dest++ = *src++;
|
|
}
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
if (nhfp->structlevel) {
|
|
src = testbuf;
|
|
dest = d_str;
|
|
match = TRUE;
|
|
for (i = 0; i < cnt; ++i) {
|
|
if (*src++ != *dest++)
|
|
match = FALSE;
|
|
}
|
|
if (!match)
|
|
report_problem_ascii(nhfp, myparent, myname, parent);
|
|
else {
|
|
src = testbuf;
|
|
dest = d_str;
|
|
for (i = 0; i < cnt; ++i)
|
|
*dest++ = *src++;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void
|
|
ascii_sfi_addinfo(nhfp, myparent, action, myname, index)
|
|
NHFILE *nhfp;
|
|
const char *myparent, *action, *myname;
|
|
int index;
|
|
{
|
|
/* not doing anything here */
|
|
}
|
|
|
|
char *
|
|
get_savefield(nhfp, inbuf, inbufsz)
|
|
NHFILE *nhfp;
|
|
char *inbuf;
|
|
size_t inbufsz;
|
|
{
|
|
boolean rv = TRUE; /* assume successful parse */
|
|
char *ep, *sep;
|
|
|
|
if (fgets(inbuf, (int) inbufsz, nhfp->fpdef)) {
|
|
nhfp->count++;
|
|
ep = index(inbuf, '\n');
|
|
if (!ep) { /* newline missing */
|
|
if (strlen(inbuf) < (inbufsz - 2)) {
|
|
/* likely the last line of file is just
|
|
missing a newline; process it anyway */
|
|
ep = eos(inbuf);
|
|
}
|
|
}
|
|
if (ep)
|
|
*ep = '\0'; /* remove newline */
|
|
sep = index(inbuf, '|');
|
|
if (sep)
|
|
sep++;
|
|
|
|
return sep;
|
|
}
|
|
inbuf[0] = '\0';
|
|
nhfp->eof = TRUE;
|
|
return inbuf;
|
|
}
|
|
|
|
#ifdef SAVEFILE_DEBUGGING
|
|
void
|
|
report_problem_ascii(nhfp, s1, s2, s3)
|
|
NHFILE *nhfp;
|
|
const char *s1, *s2, *s3;
|
|
{
|
|
fprintf(nhfp->fpdebug, "faulty value preservation "
|
|
"(%ld, %s, %s, %s)\n", nhfp->count, s1, s2, s3);
|
|
}
|
|
#endif
|
|
|
|
|