Geografic-Information-System/lib/vector/diglib/plus_struct.c

/*
 ****************************************************************************
 *
 * MODULE:       Vector library 
 *              
 * AUTHOR(S):    Dave Gerdes, CERL.
 *               Update to GRASS 5.7 Radim Blazek.
 *
 * PURPOSE:      Lower level functions for reading/writing/manipulating vectors.
 *
 * COPYRIGHT:    (C) 2001 by the GRASS Development Team
 *
 *               This program is free software under the GNU General Public
 *              License (>=v2). Read the file COPYING that comes with GRASS
 *              for details.
 *
 *****************************************************************************/
#include <grass/config.h>
#include <sys/types.h>
#include <string.h>
#include <grass/gis.h>
#include <grass/vector.h>

/*
 * Routines for reading and writing Dig+ structures.
 * return 0 on success, -1 on failure of whatever kind
 * if you dont want it written out, then dont call these routines
 * ie  check for deleted status before calling a write routine
 * in as much as it would be nice to hide that code in here,
 * this is a library routine and we chose to make it dependent on
 * as few external files as possible 
 */

/*  These routines assume ptr->alloc_lines  is valid 
 *   Make sure it is initialized before calling 
 */

/*
 *  Internally, my default variables for lines/areas/nodes/isles  are type
 *  plus_t  which is typedefed as short.  This limits the current version
 *  to no more than 32K lines, nodes etc. (excluding points)
 *  All in the name of future expansion, I have converted these values to 
 *  longs in the dig_plus data file.
 *
 *  NOTE: 3.10 changes plus_t to  ints.
 *    This assumes that any reasonable machine will use 4 bytes to
 *    store an int.  The mapdev code is not guaranteed to work if
 *    plus_t is changed to a type that is larger than an int.
 */

int dig_Rd_P_node(struct Plus_head *Plus, int n, struct gvfile * fp)
{
    int cnt, n_edges;
    struct P_node *ptr;

    G_debug(3, "dig_Rd_P_node()");


    if (0 >= dig__fread_port_P(&cnt, 1, fp))
	return (-1);

    if (cnt == 0) {		/* dead */
	G_debug(3, "    node is dead");
	Plus->Node[n] = NULL;
	return 0;
    }

    ptr = dig_alloc_node();
    ptr->n_lines = cnt;

    if (dig_node_alloc_line(ptr, ptr->n_lines) == -1)
	return -1;

    if (ptr->n_lines) {
	if (0 >= dig__fread_port_P(ptr->lines, ptr->n_lines, fp))
	    return (-1);
	if (0 >= dig__fread_port_F(ptr->angles, ptr->n_lines, fp))
	    return (-1);
    }

    if (Plus->with_z)
	if (0 >= dig__fread_port_P(&n_edges, 1, fp))	/* reserved for edges */
	    return (-1);

    /* here will be edges */

    if (0 >= dig__fread_port_D(&(ptr->x), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_D(&(ptr->y), 1, fp))
	return (-1);

    if (Plus->with_z) {
	if (0 >= dig__fread_port_D(&(ptr->z), 1, fp))
	    return (-1);
    }
    else
	ptr->z = 0;


    Plus->Node[n] = ptr;

    return (0);
}

int dig_Wr_P_node(struct Plus_head *Plus, int n, struct gvfile * fp)
{
    int i, n_edges = 0;
    struct P_node *ptr;

    G_debug(3, "dig_Wr_P_node()");
    ptr = Plus->Node[n];

    /* If NULL i.e. dead write just 0 instead of number of lines */
    if (ptr == NULL) {
	G_debug(3, "    node is dead -> write 0 only");
	i = 0;
	if (0 >= dig__fwrite_port_P(&i, 1, fp))
	    return (-1);
	return 0;
    }

    if (0 >= dig__fwrite_port_P(&(ptr->n_lines), 1, fp))
	return (-1);

    if (ptr->n_lines) {
	if (0 >= dig__fwrite_port_P(ptr->lines, ptr->n_lines, fp))
	    return (-1);
	if (0 >= dig__fwrite_port_F(ptr->angles, ptr->n_lines, fp))
	    return (-1);
    }

    if (Plus->with_z)
	if (0 >= dig__fwrite_port_P(&n_edges, 1, fp))	/* reserved for edges */
	    return (-1);

    /* here will be edges */

    if (0 >= dig__fwrite_port_D(&(ptr->x), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->y), 1, fp))
	return (-1);

    if (Plus->with_z)
	if (0 >= dig__fwrite_port_D(&(ptr->z), 1, fp))
	    return (-1);

    return (0);
}

int dig_Rd_P_line(struct Plus_head *Plus, int n, struct gvfile * fp)
{
    int n_edges, vol;
    char tp;
    struct P_line *ptr;
    struct P_node *Node;

    G_debug(3, "dig_Rd_P_line()");

    if (0 >= dig__fread_port_C(&tp, 1, fp))
	return (-1);

    if (tp == 0) {		/* dead */
	G_debug(3, "    line is dead");
	Plus->Line[n] = NULL;
	return 0;
    }

    ptr = dig_alloc_line();

    /* type */
    ptr->type = dig_type_from_store(tp);
    G_debug(5, "    line type  %d -> %d", tp, ptr->type);

    /* offset */
    if (0 >= dig__fread_port_O(&(ptr->offset), 1, fp, Plus->off_t_size))
	return (-1);

    /* First node */
    if (ptr->type & (GV_POINTS | GV_LINES | GV_KERNEL))
	if (0 >= dig__fread_port_P(&(ptr->N1), 1, fp))
	    return -1;

    /* Second node, for points/centroids not needed */
    if (ptr->type & (GV_LINE | GV_BOUNDARY)) {
	if (0 >= dig__fread_port_P(&(ptr->N2), 1, fp))
	    return -1;
    }
    else if (ptr->type & (GV_POINTS | GV_KERNEL))
	ptr->N2 = ptr->N1;

    /* left area for boundary, area for centroid */
    if (ptr->type & (GV_BOUNDARY | GV_CENTROID))
	if (0 >= dig__fread_port_P(&(ptr->left), 1, fp))
	    return -1;

    /* right area */
    if (ptr->type & GV_BOUNDARY)
	if (0 >= dig__fread_port_P(&(ptr->right), 1, fp))
	    return -1;

    if ((ptr->type & GV_FACE) && Plus->with_z) {	/* reserved for face edges */
	if (0 >= dig__fread_port_I(&n_edges, 1, fp))
	    return -1;

	/* here will be list of edges */

	/* left / right volume */
	if (0 >= dig__fread_port_P(&vol, 1, fp))
	    return -1;
	if (0 >= dig__fread_port_P(&vol, 1, fp))
	    return -1;
    }

    if ((ptr->type & GV_KERNEL) && Plus->with_z)	/* reserved for kernel (volume number) */
	if (0 >= dig__fread_port_P(&vol, 1, fp))
	    return -1;

    /* Bounding box */
    if (ptr->type & (GV_LINE | GV_BOUNDARY | GV_FACE)) {
	if (0 >= dig__fread_port_D(&(ptr->N), 1, fp))
	    return -1;
	if (0 >= dig__fread_port_D(&(ptr->S), 1, fp))
	    return -1;
	if (0 >= dig__fread_port_D(&(ptr->E), 1, fp))
	    return -1;
	if (0 >= dig__fread_port_D(&(ptr->W), 1, fp))
	    return -1;

	if (Plus->with_z) {
	    if (0 >= dig__fread_port_D(&(ptr->T), 1, fp))
		return -1;
	    if (0 >= dig__fread_port_D(&(ptr->B), 1, fp))
		return -1;
	}
	else {
	    ptr->T = 0.0;
	    ptr->B = 0.0;
	}
    }
    else {
	Node = Plus->Node[ptr->N1];
	ptr->N = Node->y;
	ptr->S = Node->y;
	ptr->E = Node->x;
	ptr->W = Node->x;
	ptr->T = Node->z;
	ptr->B = Node->z;
    }

    Plus->Line[n] = ptr;
    return (0);
}

int dig_Wr_P_line(struct Plus_head *Plus, int n, struct gvfile * fp)
{
    int n_edges = 0, vol = 0;
    char ch;
    struct P_line *ptr;

    G_debug(4, "dig_Wr_P_line() line = %d", n);

    ptr = Plus->Line[n];

    /* If NULL i.e. dead write just 0 instead of type */
    if (ptr == NULL) {
	G_debug(3, "    line is dead -> write 0 only");
	ch = 0;
	if (0 >= dig__fwrite_port_C(&ch, 1, fp))
	    return (-1);
	return 0;
    }

    /* type */
    ch = (char)dig_type_to_store(ptr->type);
    G_debug(5, "    line type  %d -> %d", ptr->type, ch);
    if (0 >= dig__fwrite_port_C(&ch, 1, fp))
	return (-1);

    /* offset */
    if (0 >= dig__fwrite_port_O(&(ptr->offset), 1, fp, Plus->off_t_size))
	return (-1);

    /* First node */
    if (ptr->type & (GV_POINTS | GV_LINES | GV_KERNEL))
	if (0 >= dig__fwrite_port_P(&(ptr->N1), 1, fp))
	    return (-1);

    /* Second node, for points/centroids not needed */
    if (ptr->type & (GV_LINE | GV_BOUNDARY))
	if (0 >= dig__fwrite_port_P(&(ptr->N2), 1, fp))
	    return (-1);

    /* left area for boundary, area for centroid */
    if (ptr->type & (GV_BOUNDARY | GV_CENTROID))
	if (0 >= dig__fwrite_port_P(&(ptr->left), 1, fp))
	    return (-1);

    /* right area */
    if (ptr->type & GV_BOUNDARY)
	if (0 >= dig__fwrite_port_P(&(ptr->right), 1, fp))
	    return (-1);

    if ((ptr->type & GV_FACE) && Plus->with_z) {	/* reserved for face */
	if (0 >= dig__fwrite_port_I(&n_edges, 1, fp))
	    return (-1);

	/* here will be list of edges */

	/* left / right volume */
	if (0 >= dig__fwrite_port_P(&vol, 1, fp))
	    return (-1);
	if (0 >= dig__fwrite_port_P(&vol, 1, fp))
	    return (-1);
    }

    if ((ptr->type & GV_KERNEL) && Plus->with_z)	/* reserved for kernel (volume number) */
	if (0 >= dig__fwrite_port_P(&vol, 1, fp))
	    return (-1);

    /* Bounding box */
    if (ptr->type & (GV_LINE | GV_BOUNDARY | GV_FACE)) {
	if (0 >= dig__fwrite_port_D(&(ptr->N), 1, fp))
	    return (-1);
	if (0 >= dig__fwrite_port_D(&(ptr->S), 1, fp))
	    return (-1);
	if (0 >= dig__fwrite_port_D(&(ptr->E), 1, fp))
	    return (-1);
	if (0 >= dig__fwrite_port_D(&(ptr->W), 1, fp))
	    return (-1);

	if (Plus->with_z) {
	    if (0 >= dig__fwrite_port_D(&(ptr->T), 1, fp))
		return (-1);
	    if (0 >= dig__fwrite_port_D(&(ptr->B), 1, fp))
		return (-1);
	}
    }

    return (0);
}

int dig_Rd_P_area(struct Plus_head *Plus, int n, struct gvfile * fp)
{
    int cnt;
    struct P_area *ptr;

#ifdef GDEBUG
    G_debug(3, "dig_Rd_P_area(): n = %d", n);
#endif

    if (0 >= dig__fread_port_P(&cnt, 1, fp))
	return (-1);

    if (cnt == 0) {		/* dead */
	Plus->Area[n] = NULL;
	return 0;
    }

    ptr = dig_alloc_area();

    /* lines */
    ptr->n_lines = cnt;

    if (dig_area_alloc_line(ptr, ptr->n_lines) == -1)
	return -1;

    if (ptr->n_lines)
	if (0 >= dig__fread_port_P(ptr->lines, ptr->n_lines, fp))
	    return -1;

    /* isles */
    if (0 >= dig__fread_port_P(&(ptr->n_isles), 1, fp))
	return -1;

    if (dig_area_alloc_isle(ptr, ptr->n_isles) == -1)
	return -1;

    if (ptr->n_isles)
	if (0 >= dig__fread_port_P(ptr->isles, ptr->n_isles, fp))
	    return -1;

    /* centroid */
    if (0 >= dig__fread_port_P(&(ptr->centroid), 1, fp))
	return -1;

    if (0 >= dig__fread_port_D(&(ptr->N), 1, fp))
	return -1;
    if (0 >= dig__fread_port_D(&(ptr->S), 1, fp))
	return -1;
    if (0 >= dig__fread_port_D(&(ptr->E), 1, fp))
	return -1;
    if (0 >= dig__fread_port_D(&(ptr->W), 1, fp))
	return -1;

    if (Plus->with_z) {
	if (0 >= dig__fread_port_D(&(ptr->T), 1, fp))
	    return -1;
	if (0 >= dig__fread_port_D(&(ptr->B), 1, fp))
	    return -1;
    }
    else {
	ptr->T = 0.0;
	ptr->B = 0.0;
    }

    Plus->Area[n] = ptr;

    return (0);
}

int dig_Wr_P_area(struct Plus_head *Plus, int n, struct gvfile * fp)
{
    int i;
    struct P_area *ptr;

    ptr = Plus->Area[n];

    /* If NULL i.e. dead write just 0 instead of number of lines */
    if (ptr == NULL) {
	i = 0;
	if (0 >= dig__fwrite_port_P(&i, 1, fp))
	    return (-1);
	return 0;
    }

    /* lines */
    if (0 >= dig__fwrite_port_P(&(ptr->n_lines), 1, fp))
	return (-1);

    if (ptr->n_lines)
	if (0 >= dig__fwrite_port_P(ptr->lines, ptr->n_lines, fp))
	    return -1;

    /* isles */
    if (0 >= dig__fwrite_port_P(&(ptr->n_isles), 1, fp))
	return (-1);

    if (ptr->n_isles)
	if (0 >= dig__fwrite_port_P(ptr->isles, ptr->n_isles, fp))
	    return -1;

    /* centroid */
    if (0 >= dig__fwrite_port_P(&(ptr->centroid), 1, fp))
	return (-1);

    if (0 >= dig__fwrite_port_D(&(ptr->N), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->S), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->E), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->W), 1, fp))
	return (-1);

    if (Plus->with_z) {
	if (0 >= dig__fwrite_port_D(&(ptr->T), 1, fp))
	    return (-1);
	if (0 >= dig__fwrite_port_D(&(ptr->B), 1, fp))
	    return (-1);
    }

    return (0);
}

int dig_Rd_P_isle(struct Plus_head *Plus, int n, struct gvfile * fp)
{
    int cnt;
    struct P_isle *ptr;

#ifdef GDEBUG
    G_debug(3, "dig_Rd_P_isle()");
#endif

    if (0 >= dig__fread_port_P(&cnt, 1, fp))
	return (-1);

    if (cnt == 0) {		/* dead */
	Plus->Isle[n] = NULL;
	return 0;
    }

    ptr = dig_alloc_isle();

    /* lines */
    ptr->n_lines = cnt;

    if (dig_isle_alloc_line(ptr, ptr->n_lines) == -1)
	return -1;

    if (ptr->n_lines)
	if (0 >= dig__fread_port_P(ptr->lines, ptr->n_lines, fp))
	    return -1;

    /* area */
    if (0 >= dig__fread_port_P(&(ptr->area), 1, fp))
	return -1;

    if (0 >= dig__fread_port_D(&(ptr->N), 1, fp))
	return -1;
    if (0 >= dig__fread_port_D(&(ptr->S), 1, fp))
	return -1;
    if (0 >= dig__fread_port_D(&(ptr->E), 1, fp))
	return -1;
    if (0 >= dig__fread_port_D(&(ptr->W), 1, fp))
	return -1;

    if (Plus->with_z) {
	if (0 >= dig__fread_port_D(&(ptr->T), 1, fp))
	    return -1;
	if (0 >= dig__fread_port_D(&(ptr->B), 1, fp))
	    return -1;
    }
    else {
	ptr->T = 0.0;
	ptr->B = 0.0;
    }

    Plus->Isle[n] = ptr;

    return (0);
}

int dig_Wr_P_isle(struct Plus_head *Plus, int n, struct gvfile * fp)
{
    int i;
    struct P_isle *ptr;

    ptr = Plus->Isle[n];

    /* If NULL i.e. dead write just 0 instead of number of lines */
    if (ptr == NULL) {
	i = 0;
	if (0 >= dig__fwrite_port_P(&i, 1, fp))
	    return (-1);
	return 0;
    }

    /* lines */
    if (0 >= dig__fwrite_port_P(&(ptr->n_lines), 1, fp))
	return (-1);

    if (ptr->n_lines)
	if (0 >= dig__fwrite_port_P(ptr->lines, ptr->n_lines, fp))
	    return -1;

    /* area */
    if (0 >= dig__fwrite_port_P(&(ptr->area), 1, fp))
	return (-1);

    if (0 >= dig__fwrite_port_D(&(ptr->N), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->S), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->E), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->W), 1, fp))
	return (-1);

    if (Plus->with_z) {
	if (0 >= dig__fwrite_port_D(&(ptr->T), 1, fp))
	    return (-1);
	if (0 >= dig__fwrite_port_D(&(ptr->B), 1, fp))
	    return (-1);
    }

    return (0);
}

/*!
  \brief Read Plus_head from file

  \param fp pointer to gvfile structure
  \param[in,out] ptr pointer to Plus_head structure

  \return -1 error
  \return  0 OK 
*/
int dig_Rd_Plus_head(struct gvfile * fp, struct Plus_head *ptr)
{
    unsigned char buf[5];
    int byte_order;

    dig_rewind(fp);

    /* bytes 1 - 5 */
    if (0 >= dig__fread_port_C(buf, 5, fp))
	return (-1);
    ptr->Version_Major = buf[0];
    ptr->Version_Minor = buf[1];
    ptr->Back_Major = buf[2];
    ptr->Back_Minor = buf[3];
    byte_order = buf[4];

    G_debug(2,
	    "Topo header: file version %d.%d , supported from GRASS version %d.%d",
	    ptr->Version_Major, ptr->Version_Minor, ptr->Back_Major,
	    ptr->Back_Minor);

    G_debug(2, "  byte order %d", byte_order);

    /* check version numbers */
    if (ptr->Version_Major > GV_TOPO_VER_MAJOR ||
	ptr->Version_Minor > GV_TOPO_VER_MINOR) {
	/* The file was created by GRASS library with higher version than this one */

	if (ptr->Back_Major > GV_TOPO_VER_MAJOR ||
	    ptr->Back_Minor > GV_TOPO_VER_MINOR) {
	    /* This version of GRASS lib is lower than the oldest which can read this format */
	    G_fatal_error
		("Topology format version %d.%d is not supported by this release."
		 " Try to rebuild topology or upgrade GRASS.",
		 ptr->Version_Major, ptr->Version_Minor);
	    return (-1);
	}

	G_warning
	    ("Your GRASS version does not fully support topology format %d.%d of the vector."
	     " Consider to rebuild topology or upgrade GRASS.",
	     ptr->Version_Major, ptr->Version_Minor);
    }

    /* init Port_info structure and set as default */
    dig_init_portable(&(ptr->port), byte_order);
    dig_set_cur_port(&(ptr->port));

    /* bytes 6 - 9 : header size */
    if (0 >= dig__fread_port_L(&(ptr->head_size), 1, fp))
	return (-1);
    G_debug(2, "  header size %ld", ptr->head_size);

    /* determine required offset size from header size */
    /* this is not safe in case new fields get added in later versions */
    /* better: add a new field with off_t_size after byte_order? */
    if (ptr->head_size >= 142 + 32) /* keep in sync with dig_Wr_Plus_head() */
	ptr->off_t_size = 8;
    else
	ptr->off_t_size = 4;

    if (sizeof(off_t) < ptr->off_t_size) {
	G_warning("Vector exceeds supported file size limit");
	return (-1);
    }

    G_debug(1, "topo off_t size = %d", ptr->off_t_size);

    /* byte 10 : dimension 2D or 3D */
    if (0 >= dig__fread_port_C(buf, 1, fp))
	return (-1);
    ptr->with_z = buf[0];
    G_debug(2, "  with_z %d", ptr->with_z);

    /* bytes 11 - 58 : bound box */
    if (0 >= dig__fread_port_D(&(ptr->box.N), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_D(&(ptr->box.S), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_D(&(ptr->box.E), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_D(&(ptr->box.W), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_D(&(ptr->box.T), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_D(&(ptr->box.B), 1, fp))
	return (-1);

    /* bytes 59 - 86 : number of structures */
    if (0 >= dig__fread_port_P(&(ptr->n_nodes), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_edges), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_lines), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_areas), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_isles), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_volumes), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_holes), 1, fp))
	return (-1);

    /* bytes 87 - 110 : number of line types */
    if (0 >= dig__fread_port_P(&(ptr->n_plines), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_llines), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_blines), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_clines), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_flines), 1, fp))
	return (-1);
    if (0 >= dig__fread_port_P(&(ptr->n_klines), 1, fp))
	return (-1);

    /* bytes 111 - 138 : Offset */
    if (0 >= dig__fread_port_O(&(ptr->Node_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fread_port_O(&(ptr->Edge_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fread_port_O(&(ptr->Line_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fread_port_O(&(ptr->Area_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fread_port_O(&(ptr->Isle_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fread_port_O(&(ptr->Volume_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fread_port_O(&(ptr->Hole_offset), 1, fp, ptr->off_t_size))
	return (-1);

    /* bytes 139 - 142 : Coor size and time */
    if (0 >= dig__fread_port_O(&(ptr->coor_size), 1, fp, ptr->off_t_size))
	return (-1);

    G_debug(2, "  coor size %ld", ptr->coor_size);

    dig_fseek(fp, ptr->head_size, SEEK_SET);

    return (0);
}

int dig_Wr_Plus_head(struct gvfile * fp, struct Plus_head *ptr)
{
    unsigned char buf[10];
    long length = 142;

    dig_rewind(fp);
    dig_set_cur_port(&(ptr->port));

    /* bytes 1 - 5 */
    buf[0] = GV_TOPO_VER_MAJOR;
    buf[1] = GV_TOPO_VER_MINOR;
    buf[2] = GV_TOPO_EARLIEST_MAJOR;
    buf[3] = GV_TOPO_EARLIEST_MINOR;
    buf[4] = ptr->port.byte_order;
    if (0 >= dig__fwrite_port_C(buf, 5, fp))
	return (-1);

    /* determine required offset size from coor file size */
    if (ptr->coor_size > (off_t)PORT_LONG_MAX) {
	/* can only happen when sizeof(off_t) == 8 */
	ptr->off_t_size = 8;
    }
    else
	ptr->off_t_size = 4;

    /* add a new field with off_t_size after byte_order? */

    /* adjust header size for large files */
    if (ptr->off_t_size == 8) {
	/* 7 offset values and coor file size: add 8 * 4 */
	length += 32;
    }

    /* bytes 6 - 9 : header size */
    if (0 >= dig__fwrite_port_L(&length, 1, fp))
	return (0);

    /* byte 10 : dimension 2D or 3D */
    buf[0] = ptr->with_z;
    if (0 >= dig__fwrite_port_C(buf, 1, fp))
	return (0);

    /* bytes 11 - 58 : bound box */
    if (0 >= dig__fwrite_port_D(&(ptr->box.N), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->box.S), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->box.E), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->box.W), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->box.T), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_D(&(ptr->box.B), 1, fp))
	return (-1);

    /* bytes 59 - 86 : number of structures */
    if (0 >= dig__fwrite_port_P(&(ptr->n_nodes), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_edges), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_lines), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_areas), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_isles), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_volumes), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_holes), 1, fp))
	return (-1);

    /* bytes 87 - 110 : number of line types */
    if (0 >= dig__fwrite_port_P(&(ptr->n_plines), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_llines), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_blines), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_clines), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_flines), 1, fp))
	return (-1);
    if (0 >= dig__fwrite_port_P(&(ptr->n_klines), 1, fp))
	return (-1);

    /* bytes 111 - 138 : Offset */
    if (0 >= dig__fwrite_port_O(&(ptr->Node_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fwrite_port_O(&(ptr->Edge_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fwrite_port_O(&(ptr->Line_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fwrite_port_O(&(ptr->Area_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fwrite_port_O(&(ptr->Isle_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fwrite_port_O(&(ptr->Volume_offset), 1, fp, ptr->off_t_size))
	return (-1);
    if (0 >= dig__fwrite_port_O(&(ptr->Hole_offset), 1, fp, ptr->off_t_size))
	return (-1);

    /* bytes 139 - 142 : Coor size and time */
    if (0 >= dig__fwrite_port_O(&(ptr->coor_size), 1, fp, ptr->off_t_size))
	return (-1);

    G_debug(2, "topo body offset %ld", dig_ftell(fp));

    return (0);
}