/*
 * Copyright (c) 2004, The Tendra Project <http://www.ten15.org/>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice unmodified, this list of conditions, and the following
 *    disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 *  		 Crown Copyright (c) 1997
 *
 *  This TenDRA(r) Computer Program is subject to Copyright
 *  owned by the United Kingdom Secretary of State for Defence
 *  acting through the Defence Evaluation and Research Agency
 *  (DERA).  It is made available to Recipients with a
 *  royalty-free licence for its use, reproduction, transfer
 *  to other parties and amendment for any purpose not excluding
 *  product development provided that any such use et cetera
 *  shall be deemed to be acceptance of the following conditions:-
 *
 *      (1) Its Recipients shall ensure that this Notice is
 *      reproduced upon any copies or amended versions of it;
 *
 *      (2) Any amended version of it shall be clearly marked to
 *      show both the nature of and the organisation responsible
 *      for the relevant amendment or amendments;
 *
 *      (3) Its onward transfer from a recipient to another
 *      party shall be deemed to be that party's acceptance of
 *      these conditions;
 *
 *      (4) DERA gives no warranty or assurance as to its
 *      quality or suitability for any purpose and DERA accepts
 *      no liability whatsoever in relation to any use to which
 *      it may be put.
 *
 * $TenDRA: tendra/src/utilities/calculus/read_def.h,v 1.7 2005/09/29 10:20:03 stefanf Exp $
 */

/*
 *    AUTOMATICALLY GENERATED FROM ALGEBRA disk (VERSION 1.1)
 *    BY calculus (VERSION 1.3)
 */

#ifndef READ_DEF_H_INCLUDED
#define	READ_DEF_H_INCLUDED

#include "disk.h"
#include "type_ops.h"

/* Disk reading function declarations */

#ifndef READ_disk_list_ptr_type
#define	READ_disk_list_ptr_type() READ_list_ptr_type()
#endif

#ifndef READ_list_ptr_type
static LIST (PTR (TYPE)) READ_list_ptr_type(void);
#endif

#ifndef READ_disk_string
#define	READ_disk_string() READ_string()
#endif

#ifndef READ_disk_int
#define	READ_disk_int() READ_int()
#endif

#ifndef READ_type
static TYPE READ_type(void);
#endif

#ifndef READ_zero_int
#define	READ_zero_int() READ_int()
#endif

#ifndef READ_PRIMITIVE_P
#define	READ_PRIMITIVE_P() READ_ptr_prim()
#endif

#ifndef READ_ptr_prim
static PTR (PRIMITIVE) READ_ptr_prim(void);
#endif

#ifndef READ_prim
static PRIMITIVE READ_prim(void);
#endif

#ifndef READ_CLASS_ID_P
#define	READ_CLASS_ID_P() READ_ptr_cid()
#endif

#ifndef READ_ptr_cid
static PTR (CLASS_ID) READ_ptr_cid(void);
#endif

#ifndef READ_cid
static CLASS_ID READ_cid(void);
#endif

#ifndef READ_name_string
#define	READ_name_string() READ_string()
#endif

#ifndef READ_IDENTITY_P
#define	READ_IDENTITY_P() READ_ptr_ident()
#endif

#ifndef READ_ptr_ident
static PTR (IDENTITY) READ_ptr_ident(void);
#endif

#ifndef READ_ident
static IDENTITY READ_ident(void);
#endif

#ifndef READ_TYPE_P
#define	READ_TYPE_P() READ_ptr_type()
#endif

#ifndef READ_ptr_type
static PTR (TYPE) READ_ptr_type(void);
#endif

#ifndef READ_ENUM_P
#define	READ_ENUM_P() READ_ptr_en()
#endif

#ifndef READ_ptr_en
static PTR (ENUM) READ_ptr_en(void);
#endif

#ifndef READ_en
static ENUM READ_en(void);
#endif

#ifndef READ_list_ptr_ec
static LIST (PTR (ECONST)) READ_list_ptr_ec(void);
#endif

#ifndef READ_list_ECONST_P
#define	READ_list_ECONST_P() READ_list_ptr_ec()
#endif

#ifndef READ_ECONST_P
#define	READ_ECONST_P() READ_ptr_ec()
#endif

#ifndef READ_ptr_ec
static PTR (ECONST) READ_ptr_ec(void);
#endif

#ifndef READ_ec
static ECONST READ_ec(void);
#endif

#ifndef READ_STRUCTURE_P
#define	READ_STRUCTURE_P() READ_ptr_str()
#endif

#ifndef READ_ptr_str
static PTR (STRUCTURE) READ_ptr_str(void);
#endif

#ifndef READ_str
static STRUCTURE READ_str(void);
#endif

#ifndef READ_list_ptr_cmp
static LIST (PTR (COMPONENT)) READ_list_ptr_cmp(void);
#endif

#ifndef READ_list_COMPONENT_P
#define	READ_list_COMPONENT_P() READ_list_ptr_cmp()
#endif

#ifndef READ_COMPONENT_P
#define	READ_COMPONENT_P() READ_ptr_cmp()
#endif

#ifndef READ_ptr_cmp
static PTR (COMPONENT) READ_ptr_cmp(void);
#endif

#ifndef READ_cmp
static COMPONENT READ_cmp(void);
#endif

#ifndef READ_UNION_P
#define	READ_UNION_P() READ_ptr_un()
#endif

#ifndef READ_ptr_un
static PTR (UNION) READ_ptr_un(void);
#endif

#ifndef READ_un
static UNION READ_un(void);
#endif

#ifndef READ_list_ptr_fld
static LIST (PTR (FIELD)) READ_list_ptr_fld(void);
#endif

#ifndef READ_list_FIELD_P
#define	READ_list_FIELD_P() READ_list_ptr_fld()
#endif

#ifndef READ_FIELD_P
#define	READ_FIELD_P() READ_ptr_fld()
#endif

#ifndef READ_ptr_fld
static PTR (FIELD) READ_ptr_fld(void);
#endif

#ifndef READ_fld
static FIELD READ_fld(void);
#endif

#ifndef READ_list_ptr_map
static LIST (PTR (MAP)) READ_list_ptr_map(void);
#endif

#ifndef READ_list_MAP_P
#define	READ_list_MAP_P() READ_list_ptr_map()
#endif

#ifndef READ_MAP_P
#define	READ_MAP_P() READ_ptr_map()
#endif

#ifndef READ_ptr_map
static PTR (MAP) READ_ptr_map(void);
#endif

#ifndef READ_map
static MAP READ_map(void);
#endif

#ifndef READ_list_ptr_arg
static LIST (PTR (ARGUMENT)) READ_list_ptr_arg(void);
#endif

#ifndef READ_list_ARGUMENT_P
#define	READ_list_ARGUMENT_P() READ_list_ptr_arg()
#endif

#ifndef READ_ARGUMENT_P
#define	READ_ARGUMENT_P() READ_ptr_arg()
#endif

#ifndef READ_ptr_arg
static PTR (ARGUMENT) READ_ptr_arg(void);
#endif

#ifndef READ_arg
static ARGUMENT READ_arg(void);
#endif


/* Disk reading routine for LIST (PTR (TYPE)) */

#ifndef READ_list_ptr_type

static LIST (PTR (TYPE))
READ_list_ptr_type(void)
{
	LIST (PTR (TYPE)) x_;
	x_ = NULL_list (PTR (TYPE));
	while (READ_BITS (1)) {
		PTR (TYPE) y_;
		LIST (PTR (TYPE)) z_;
		y_ = READ_ptr_type ();
		CONS_ptr (y_, NULL_list (PTR (TYPE)), z_);
		x_ = APPEND_list (x_, z_);
	}
	return (x_);
}

#endif


/* Disk reading routine for TYPE */

#ifndef READ_type

static TYPE
READ_type(void)
{
	TYPE x_;
	x_ = NULL_type;
	if (READ_BITS (1) == 1) {
		zero_int size;
		unsigned tag_ = READ_BITS (4);
		switch (tag_) {
		case type_primitive_tag : {
			PRIMITIVE_P prim;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_primitive (alias_);
				break;
			}
			NEW_ALIAS_type_primitive (x_, alias_);
			size = READ_zero_int ();
			prim = READ_PRIMITIVE_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_primitive_prim (x_), prim);
			break;
		}
		case type_ident_tag : {
			IDENTITY_P id;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_ident (alias_);
				break;
			}
			NEW_ALIAS_type_ident (x_, alias_);
			size = READ_zero_int ();
			id = READ_IDENTITY_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_ident_id (x_), id);
			break;
		}
		case type_enumeration_tag : {
			ENUM_P en;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_enumeration (alias_);
				break;
			}
			NEW_ALIAS_type_enumeration (x_, alias_);
			size = READ_zero_int ();
			en = READ_ENUM_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_enumeration_en (x_), en);
			break;
		}
		case type_structure_tag : {
			STRUCTURE_P struc;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_structure (alias_);
				break;
			}
			NEW_ALIAS_type_structure (x_, alias_);
			size = READ_zero_int ();
			struc = READ_STRUCTURE_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_structure_struc (x_), struc);
			break;
		}
		case type_onion_tag : {
			UNION_P un;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_onion (alias_);
				break;
			}
			NEW_ALIAS_type_onion (x_, alias_);
			size = READ_zero_int ();
			un = READ_UNION_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_onion_un (x_), un);
			break;
		}
		case type_ptr_tag : {
			TYPE_P sub;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_ptr (alias_);
				break;
			}
			NEW_ALIAS_type_ptr (x_, alias_);
			size = READ_zero_int ();
			sub = READ_TYPE_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_ptr_sub (x_), sub);
			break;
		}
		case type_list_tag : {
			TYPE_P sub;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_list (alias_);
				break;
			}
			NEW_ALIAS_type_list (x_, alias_);
			size = READ_zero_int ();
			sub = READ_TYPE_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_list_sub (x_), sub);
			break;
		}
		case type_stack_tag : {
			TYPE_P sub;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_stack (alias_);
				break;
			}
			NEW_ALIAS_type_stack (x_, alias_);
			size = READ_zero_int ();
			sub = READ_TYPE_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_stack_sub (x_), sub);
			break;
		}
		case type_vec_tag : {
			TYPE_P sub;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_vec (alias_);
				break;
			}
			NEW_ALIAS_type_vec (x_, alias_);
			size = READ_zero_int ();
			sub = READ_TYPE_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_vec_sub (x_), sub);
			break;
		}
		case type_vec_ptr_tag : {
			TYPE_P sub;
			unsigned alias_ = READ_ALIAS ();
			if (READ_BITS (1) == 0) {
				x_ = FIND_ALIAS_type_vec_ptr (alias_);
				break;
			}
			NEW_ALIAS_type_vec_ptr (x_, alias_);
			size = READ_zero_int ();
			sub = READ_TYPE_P ();
			COPY_int (type_size (x_), size);
			COPY_ptr (type_vec_ptr_sub (x_), sub);
			break;
		}
		case type_quote_tag : {
			string defn;
			size = READ_zero_int ();
			defn = READ_string ();
			MAKE_type_quote (size, defn, x_);
			break;
		}
		case type_undef_tag : {
			string name;
			size = READ_zero_int ();
			name = READ_string ();
			MAKE_type_undef (size, name, x_);
			break;
		}
		}
	}
	return (x_);
}

#endif


/* Disk reading routine for PTR (PRIMITIVE) */

#ifndef READ_ptr_prim

static PTR (PRIMITIVE)
READ_ptr_prim(void)
{
	PTR (PRIMITIVE) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (PRIMITIVE);
	} else {
		x_ = MAKE_ptr (SIZE_prim);
		COPY_prim (x_, READ_prim ());
	}
	return (x_);
}

#endif


/* Disk reading routine for PRIMITIVE */

#ifndef READ_prim

static PRIMITIVE
READ_prim(void)
{
	PRIMITIVE x_;
    x_.id = READ_CLASS_ID_P ();
    x_.defn = READ_string ();
	return (x_);
}

#endif


/* Disk reading routine for PTR (CLASS_ID) */

#ifndef READ_ptr_cid

static PTR (CLASS_ID)
READ_ptr_cid(void)
{
	PTR (CLASS_ID) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (CLASS_ID);
	} else {
		x_ = MAKE_ptr (SIZE_cid);
		COPY_cid (x_, READ_cid ());
	}
	return (x_);
}

#endif


/* Disk reading routine for CLASS_ID */

#ifndef READ_cid

static CLASS_ID
READ_cid(void)
{
	CLASS_ID x_;
    x_.name = READ_string ();
    x_.name_aux = READ_string ();
    x_.flag = READ_int ();
    x_.file = READ_name_string ();
    x_.line = READ_int ();
	return (x_);
}

#endif


/* Disk reading routine for PTR (IDENTITY) */

#ifndef READ_ptr_ident

static PTR (IDENTITY)
READ_ptr_ident(void)
{
	PTR (IDENTITY) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (IDENTITY);
	} else {
		x_ = MAKE_ptr (SIZE_ident);
		COPY_ident (x_, READ_ident ());
	}
	return (x_);
}

#endif


/* Disk reading routine for IDENTITY */

#ifndef READ_ident

static IDENTITY
READ_ident(void)
{
	IDENTITY x_;
    x_.id = READ_CLASS_ID_P ();
    x_.defn = READ_TYPE_P ();
	return (x_);
}

#endif


/* Disk reading routine for PTR (TYPE) */

#ifndef READ_ptr_type

static PTR (TYPE)
READ_ptr_type(void)
{
	PTR (TYPE) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (TYPE);
	} else {
		x_ = MAKE_ptr (SIZE_type);
		COPY_type (x_, READ_type ());
	}
	return (x_);
}

#endif


/* Disk reading routine for PTR (ENUM) */

#ifndef READ_ptr_en

static PTR (ENUM)
READ_ptr_en(void)
{
	PTR (ENUM) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (ENUM);
	} else {
		x_ = MAKE_ptr (SIZE_en);
		COPY_en (x_, READ_en ());
	}
	return (x_);
}

#endif


/* Disk reading routine for ENUM */

#ifndef READ_en

static ENUM
READ_en(void)
{
	ENUM x_;
    x_.id = READ_CLASS_ID_P ();
    x_.consts = READ_list_ECONST_P ();
    x_.order = READ_number ();
    x_.lists = READ_int ();
	return (x_);
}

#endif


/* Disk reading routine for LIST (PTR (ECONST)) */

#ifndef READ_list_ptr_ec

static LIST (PTR (ECONST))
READ_list_ptr_ec(void)
{
	LIST (PTR (ECONST)) x_;
	x_ = NULL_list (PTR (ECONST));
	while (READ_BITS (1)) {
		PTR (ECONST) y_;
		LIST (PTR (ECONST)) z_;
		y_ = READ_ptr_ec ();
		CONS_ptr (y_, NULL_list (PTR (ECONST)), z_);
		x_ = APPEND_list (x_, z_);
	}
	return (x_);
}

#endif


/* Disk reading routine for PTR (ECONST) */

#ifndef READ_ptr_ec

static PTR (ECONST)
READ_ptr_ec(void)
{
	PTR (ECONST) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (ECONST);
	} else {
		x_ = MAKE_ptr (SIZE_ec);
		COPY_ec (x_, READ_ec ());
	}
	return (x_);
}

#endif


/* Disk reading routine for ECONST */

#ifndef READ_ec

static ECONST
READ_ec(void)
{
	ECONST x_;
    x_.name = READ_string ();
    x_.value = READ_number ();
	return (x_);
}

#endif


/* Disk reading routine for PTR (STRUCTURE) */

#ifndef READ_ptr_str

static PTR (STRUCTURE)
READ_ptr_str(void)
{
	PTR (STRUCTURE) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (STRUCTURE);
	} else {
		x_ = MAKE_ptr (SIZE_str);
		COPY_str (x_, READ_str ());
	}
	return (x_);
}

#endif


/* Disk reading routine for STRUCTURE */

#ifndef READ_str

static STRUCTURE
READ_str(void)
{
	STRUCTURE x_;
    x_.id = READ_CLASS_ID_P ();
    x_.base = READ_STRUCTURE_P ();
    x_.defn = READ_list_COMPONENT_P ();
    x_.output = READ_zero_int ();
	return (x_);
}

#endif


/* Disk reading routine for LIST (PTR (COMPONENT)) */

#ifndef READ_list_ptr_cmp

static LIST (PTR (COMPONENT))
READ_list_ptr_cmp(void)
{
	LIST (PTR (COMPONENT)) x_;
	x_ = NULL_list (PTR (COMPONENT));
	while (READ_BITS (1)) {
		PTR (COMPONENT) y_;
		LIST (PTR (COMPONENT)) z_;
		y_ = READ_ptr_cmp ();
		CONS_ptr (y_, NULL_list (PTR (COMPONENT)), z_);
		x_ = APPEND_list (x_, z_);
	}
	return (x_);
}

#endif


/* Disk reading routine for PTR (COMPONENT) */

#ifndef READ_ptr_cmp

static PTR (COMPONENT)
READ_ptr_cmp(void)
{
	PTR (COMPONENT) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (COMPONENT);
	} else {
		x_ = MAKE_ptr (SIZE_cmp);
		COPY_cmp (x_, READ_cmp ());
	}
	return (x_);
}

#endif


/* Disk reading routine for COMPONENT */

#ifndef READ_cmp

static COMPONENT
READ_cmp(void)
{
	COMPONENT x_;
    x_.name = READ_string ();
    x_.type = READ_TYPE_P ();
    x_.value = READ_string ();
	return (x_);
}

#endif


/* Disk reading routine for PTR (UNION) */

#ifndef READ_ptr_un

static PTR (UNION)
READ_ptr_un(void)
{
	PTR (UNION) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (UNION);
	} else {
		x_ = MAKE_ptr (SIZE_un);
		COPY_un (x_, READ_un ());
	}
	return (x_);
}

#endif


/* Disk reading routine for UNION */

#ifndef READ_un

static UNION
READ_un(void)
{
	UNION x_;
    x_.id = READ_CLASS_ID_P ();
    x_.base = READ_UNION_P ();
    x_.s_defn = READ_list_COMPONENT_P ();
    x_.u_defn = READ_list_FIELD_P ();
    x_.map = READ_list_MAP_P ();
    x_.no_fields = READ_int ();
	return (x_);
}

#endif


/* Disk reading routine for LIST (PTR (FIELD)) */

#ifndef READ_list_ptr_fld

static LIST (PTR (FIELD))
READ_list_ptr_fld(void)
{
	LIST (PTR (FIELD)) x_;
	x_ = NULL_list (PTR (FIELD));
	while (READ_BITS (1)) {
		PTR (FIELD) y_;
		LIST (PTR (FIELD)) z_;
		y_ = READ_ptr_fld ();
		CONS_ptr (y_, NULL_list (PTR (FIELD)), z_);
		x_ = APPEND_list (x_, z_);
	}
	return (x_);
}

#endif


/* Disk reading routine for PTR (FIELD) */

#ifndef READ_ptr_fld

static PTR (FIELD)
READ_ptr_fld(void)
{
	PTR (FIELD) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (FIELD);
	} else {
		x_ = MAKE_ptr (SIZE_fld);
		COPY_fld (x_, READ_fld ());
	}
	return (x_);
}

#endif


/* Disk reading routine for FIELD */

#ifndef READ_fld

static FIELD
READ_fld(void)
{
	FIELD x_;
    x_.name = READ_string ();
    x_.tag = READ_int ();
    x_.flag = READ_int ();
    x_.set = READ_int ();
    x_.base = READ_FIELD_P ();
    x_.defn = READ_list_COMPONENT_P ();
	return (x_);
}

#endif


/* Disk reading routine for LIST (PTR (MAP)) */

#ifndef READ_list_ptr_map

static LIST (PTR (MAP))
READ_list_ptr_map(void)
{
	LIST (PTR (MAP)) x_;
	x_ = NULL_list (PTR (MAP));
	while (READ_BITS (1)) {
		PTR (MAP) y_;
		LIST (PTR (MAP)) z_;
		y_ = READ_ptr_map ();
		CONS_ptr (y_, NULL_list (PTR (MAP)), z_);
		x_ = APPEND_list (x_, z_);
	}
	return (x_);
}

#endif


/* Disk reading routine for PTR (MAP) */

#ifndef READ_ptr_map

static PTR (MAP)
READ_ptr_map(void)
{
	PTR (MAP) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (MAP);
	} else {
		x_ = MAKE_ptr (SIZE_map);
		COPY_map (x_, READ_map ());
	}
	return (x_);
}

#endif


/* Disk reading routine for MAP */

#ifndef READ_map

static MAP
READ_map(void)
{
	MAP x_;
    x_.name = READ_string ();
    x_.flag = READ_int ();
    x_.ret_type = READ_TYPE_P ();
    x_.args = READ_list_ARGUMENT_P ();
	return (x_);
}

#endif


/* Disk reading routine for LIST (PTR (ARGUMENT)) */

#ifndef READ_list_ptr_arg

static LIST (PTR (ARGUMENT))
READ_list_ptr_arg(void)
{
	LIST (PTR (ARGUMENT)) x_;
	x_ = NULL_list (PTR (ARGUMENT));
	while (READ_BITS (1)) {
		PTR (ARGUMENT) y_;
		LIST (PTR (ARGUMENT)) z_;
		y_ = READ_ptr_arg ();
		CONS_ptr (y_, NULL_list (PTR (ARGUMENT)), z_);
		x_ = APPEND_list (x_, z_);
	}
	return (x_);
}

#endif


/* Disk reading routine for PTR (ARGUMENT) */

#ifndef READ_ptr_arg

static PTR (ARGUMENT)
READ_ptr_arg(void)
{
	PTR (ARGUMENT) x_;
	if (READ_BITS (1) == 0) {
		x_ = NULL_ptr (ARGUMENT);
	} else {
		x_ = MAKE_ptr (SIZE_arg);
		COPY_arg (x_, READ_arg ());
	}
	return (x_);
}

#endif


/* Disk reading routine for ARGUMENT */

#ifndef READ_arg

static ARGUMENT
READ_arg(void)
{
	ARGUMENT x_;
    x_.name = READ_string ();
    x_.type = READ_TYPE_P ();
	return (x_);
}

#endif


#endif
