1152 lines
27 KiB
C
1152 lines
27 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"
|
|
|
|
#ifdef MACOSX
|
|
extern long long FDECL(atoll, (const char *));
|
|
#endif
|
|
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt UNUSED;
|
|
{
|
|
const char *parent = "any";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt UNUSED;
|
|
{
|
|
int itmp;
|
|
const char *parent = "aligntyp";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt UNUSED;
|
|
{
|
|
const char *parent = "bitfield";
|
|
|
|
nhUse(parent);
|
|
/* 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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "boolean";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i = cnt;
|
|
const char *parent = "char";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
unsigned long tmp;
|
|
char *byteptr = (char *) d_genericptr;
|
|
const char *parent = "genericptr";
|
|
|
|
nhUse(parent);
|
|
/*
|
|
* 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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "int";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "long";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i, itmp;
|
|
const char *parent = "schar";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "short";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "size_t";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt UNUSED;
|
|
{
|
|
const char *parent = "time_t";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "uchar";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "uint";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "ulong";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "ushort";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
const char *parent = "xchar";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i, j, intval;
|
|
const char *parent = "str";
|
|
char sval[QBUFSZ], *src = d_str, *dest = strbuf;
|
|
|
|
nhUse(parent);
|
|
/* cnt is the number of characters */
|
|
for (i = 0; i < cnt; ++i) {
|
|
if ((*src < 32) || (*src == '\\') || (*src > 127)) {
|
|
*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, indx)
|
|
NHFILE *nhfp UNUSED;
|
|
const char *parent UNUSED, *action UNUSED, *myname UNUSED;
|
|
int indx UNUSED;
|
|
{
|
|
/* ignored */
|
|
}
|
|
|
|
|
|
static void
|
|
put_savefield(nhfp, obuf, outbufsz)
|
|
NHFILE *nhfp;
|
|
char *obuf;
|
|
size_t outbufsz UNUSED;
|
|
{
|
|
nhfp->count++;
|
|
fprintf(nhfp->fpdef, "%07ld|%s\n", nhfp->count, obuf);
|
|
}
|
|
|
|
/*
|
|
*----------------------------------------------------------------------------
|
|
* 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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt UNUSED;
|
|
{
|
|
char *rstr;
|
|
long long tmp;
|
|
const char *parent = "any";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt UNUSED;
|
|
{
|
|
char *rstr;
|
|
aligntyp tmp;
|
|
long long lltmp;
|
|
const char *parent = "aligntyp";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt UNUSED;
|
|
{
|
|
char *rstr;
|
|
uint8_t tmp;
|
|
const char *parent = "bitfield";
|
|
|
|
nhUse(parent);
|
|
/* 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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
char *rstr;
|
|
int i;
|
|
const char *parent = "boolean";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
char *rstr;
|
|
int i;
|
|
char tmp;
|
|
const char *parent = "char";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
long long lltmp;
|
|
char *rstr;
|
|
const char *parent = "genericptr";
|
|
static const char *glorkum = "glorkum";
|
|
char *byteptr = (char *) d_genericptr;
|
|
|
|
nhUse(parent);
|
|
/*
|
|
* 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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i, tmp;
|
|
char *rstr;
|
|
long long lltmp;
|
|
const char *parent = "int";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
long tmp;
|
|
long long lltmp;
|
|
char *rstr;
|
|
const char *parent = "long";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
schar tmp;
|
|
char *rstr;
|
|
const char *parent = "schar";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
short tmp;
|
|
char *rstr;
|
|
const char *parent = "short";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
size_t tmp;
|
|
char *rstr;
|
|
const char *parent = "size_t";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt UNUSED;
|
|
{
|
|
int i;
|
|
time_t tmp;
|
|
char *rstr;
|
|
const char *parent = "time_t";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
uchar tmp;
|
|
int i, itmp;
|
|
char *rstr;
|
|
const char *parent = "uchar";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
char *rstr;
|
|
unsigned int tmp;
|
|
long long lltmp;
|
|
const char *parent = "uint";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
unsigned long tmp;
|
|
long long lltmp;
|
|
char *rstr;
|
|
const char *parent = "ulong";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
int i;
|
|
short tmp;
|
|
long long lltmp;
|
|
char *rstr;
|
|
const char *parent = "ushort";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
int cnt;
|
|
{
|
|
xchar tmp;
|
|
int i, itmp;
|
|
char *rstr;
|
|
const char *parent = "xchar";
|
|
|
|
nhUse(parent);
|
|
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 UNUSED;
|
|
const char *myname UNUSED;
|
|
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
|
|
|
|
nhUse(parent);
|
|
/* 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, indx)
|
|
NHFILE *nhfp UNUSED;
|
|
const char *myparent UNUSED, *action UNUSED, *myname UNUSED;
|
|
int indx UNUSED;
|
|
{
|
|
/* not doing anything here */
|
|
}
|
|
|
|
char *
|
|
get_savefield(nhfp, inbuf, inbufsz)
|
|
NHFILE *nhfp;
|
|
char *inbuf;
|
|
size_t inbufsz;
|
|
{
|
|
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
|
|
|
|
|