
/* 
 * $Copyright:	$
 * Copyright (c) 1984, 1985, 1986, 1987, 1988, 1989, 1990 
 * Sequent Computer Systems, Inc.   All rights reserved.
 *  
 * This software is furnished under a license and may be used
 * only in accordance with the terms of that license and with the
 * inclusion of the above copyright notice.   This software may not
 * be provided or otherwise made available to, or used by, any
 * other person.  No title to or ownership of the software is
 * hereby transferred.
 */

/*	Copyright (c) 1984 AT&T	*/
/*	  All Rights Reserved  	*/

/*	THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T	*/
/*	The copyright notice above does not evidence any   	*/
/*	actual or intended publication of such source code.	*/
#ident "$Header: types2.c 1.1 90/01/19 $@(#)types2.c	1.1 89/12/01"
/*
 * Types handling. Accesses to types tables nodes entries
 * DEBUG allows strong validity checking, but this is slow.
 */
#include "xs.h"
#include "names.h"
#include "stack.h"
#include "types.h"
#include "anal.h"
#include "mfile1.h"
#include "xdefs.h"

#define ENTRY	((TYPETAB *)(st_elem(ty_st,x.ty_level)))->ty_tab[x.ty_tab]\
               [x.ty_offset]

#define X(x, A, B)
#define Y(x, A, B)
#define Z(x, A)
#define W(x)

char *
ty_name(x)
  TYPEP x;
{
  Z(x,"ty_name_Z");
  return ENTRY.ty_sname;
}

char
ty_type(x)
  TYPEP x;
{
  Z(x,"ty_type_Z");
  return ENTRY.ty_stype;
}

TYPEP
ty_next(x)
  TYPEP x;
{
  Z(x,"ty_next_Z");
  return ENTRY.ty_snext;
}

TYPEP
at_cl(x)
  TYPEP x;
{
  Z(x,"at_cl_Z");
  X(x,NODE_ATTR, "at_cl_t");
  Y(x,ENTRY.t.at.at_scl_init, "at_cl");
  return ENTRY.t.at.at_scl;
}

TYPEP
at_ty(x)
  TYPEP x;
{
  Z(x,"at_ty_Z");
  X(x,NODE_ATTR, "at_ty_t");
  Y(x,ENTRY.t.at.at_sty_init, "at_ty");
  return ENTRY.t.at.at_sty;
}

long
at_off(x)
  TYPEP x;
{
  Z(x,"at_off_Z");
  X(x,NODE_ATTR, "at_off_t");
  Y(x,ENTRY.t.at.at_soff_init, "at_off");
  return ENTRY.t.at.at_soff;
}

int
at_len(x)
  TYPEP x;
{
  Z(x,"at_len_Z");
  X(x,NODE_ATTR, "at_len_t");
  Y(x,ENTRY.t.at.at_slen_init, "at_len");
  return ENTRY.t.at.at_slen;
}

TYPEP
id_at(x)
  TYPEP x;
{
  Z(x,"id_at_Z");
  X(x,NODE_IDENT, "id_at_t");
  Y(x,ENTRY.t.id.id_sat_init, "id_at");
  return ENTRY.t.id.id_sat;
}

TYPEP
id_de(x)
  TYPEP x;
{
  Z(x,"id_de_Z");
  X(x,NODE_IDENT, "id_de_t");
  Y(x,ENTRY.t.id.id_sde_init, "id_de");
  return ENTRY.t.id.id_sde;
}

int
id_flag(x)
  TYPEP x;
{
  Z(x,"id_flag_Z");
  X(x,NODE_IDENT, "id_flag_t");
  Y(x,ENTRY.t.id.id_sflag_init, "id_flag");
  return ENTRY.t.id.id_sflag;
}

TYPEP
id_re(x)
  TYPEP x;
{
  Z(x,"id_re_Z");
  X(x,NODE_IDENT, "id_re_t");
  Y(x,ENTRY.t.id.id_sre_init, "id_re");
  return ENTRY.t.id.id_sre;
}

char *
re_na(x)
  TYPEP x;
{
  Z(x,"re_na_Z");
  X(x,NODE_REPLACE, "re_na_t");
  Y(x,ENTRY.t.re.re_sna_init, "re_na");
  return ENTRY.t.re.re_sna;
}

long
re_off(x)
  TYPEP x;
{
  Z(x,"re_off_Z");
  X(x,NODE_REPLACE, "re_off_t");
  Y(x,ENTRY.t.re.re_soff_init, "re_off");
  return ENTRY.t.re.re_soff;
}

int
re_len(x)
  TYPEP x;
{
  Z(x,"relen_Z");
  X(x,NODE_REPLACE, "re_len_t");
  Y(x,ENTRY.t.re.re_slen_init, "re_len");
  return ENTRY.t.re.re_slen;
}

long
re_zero(x)
  TYPEP x;
{
  Z(x,"re_zero_Z");
  X(x,NODE_REPLACE, "re_zero_t");
  Y(x,ENTRY.t.re.re_szero_init, "re_zero");
  return ENTRY.t.re.re_szero;
}

char
re_flag(x)
  TYPEP x;
{
  Z(x,"re_flag_Z");
  X(x,NODE_REPLACE, "re_flag_t");
  Y(x,ENTRY.t.re.re_sflag_init, "re_flag");
  return ENTRY.t.re.re_sflag;
}

int
re_alen(x)
  TYPEP x;
{  
  Z(x,"re_alen_Z");
  X(x,NODE_REPLACE, "re_alen_t");
  Y(x,ENTRY.t.re.re_salen_init, "re_alen");
  return ENTRY.t.re.re_salen;
}

char *
re_si(x)
  TYPEP x;
{
  Z(x,"re_si_Z");
  X(x,NODE_REPLACE, "re_si_t");
  Y(x,ENTRY.t.re.re_ssi_init, "re_si");
  return ENTRY.t.re.re_ssi;
}

TYPEP
re_next(x)
  TYPEP x;
{
  Z(x,"re_next_Z");
  X(x,NODE_REPLACE, "re_next_t");
  Y(x,ENTRY.t.re.re_snext_init, "re_next");
  return ENTRY.t.re.re_snext;
}

int
re_nr(x)
  TYPEP x;
{
  Z(x,"re_nr_Z");
  X(x,NODE_REPLACE, "re_nr_t");
  Y(x,ENTRY.t.re.re_snr_init, "re_nr");
  return ENTRY.t.re.re_snr;
}

char
ty_flag(x)
  TYPEP x;
{
  Z(x,"ty_flag_Z");
  X(x,NODE_TYPE, "ty_flag_t");
  Y(x,ENTRY.t.ty.ty_sflag_init, "ty_flag");
  return ENTRY.t.ty.ty_sflag;
}

int
ty_sys(x)
  TYPEP x;
{
  Z(x,"ty_sys_Z");
  X(x,NODE_TYPE, "ty_sys_t");
  Y(x,ENTRY.t.ty.ty.ty_ssys_init, "ty_sys");
  return ENTRY.t.ty.ty.ty_ssys;
}

TYPEP
su_tl(x)
  TYPEP x;
{
  Z(x,"su_tl_Z");
  X(x,NODE_TYPE, "su_tl_t");
  Y(x,ENTRY.t.ty.ty.su.ssu_tl_init, "su_tl");
  return ENTRY.t.ty.ty.su.ssu_tl;
}

TYPEP
su_ctl(x)
  TYPEP x;
{
  Z(x,"su_ctl_Z");
  X(x,NODE_TYPE, "su_ctl_t");
  Y(x,ENTRY.t.ty.ty.su.ssu_ctl_init, "su_ctl");
  return ENTRY.t.ty.ty.su.ssu_ctl;
}

TYPEP
su_cdl(x)
  TYPEP x;
{
  Z(x,"su_cld_Z");
  X(x,NODE_TYPE, "su_cdl_t");
  Y(x,ENTRY.t.ty.ty.su.ssu_cdl_init, "su_cdl");
  return ENTRY.t.ty.ty.su.ssu_cdl;
}

char
su_fl(x)
  TYPEP x;
{
  Z(x,"su_fl_Z");
  X(x,NODE_TYPE, "su_fl_t");
  Y(x,ENTRY.t.ty.ty.su.ssu_fl_init, "su_fl");
  return ENTRY.t.ty.ty.su.ssu_fl;
}

TYPEP
td_ty(x)
  TYPEP x;
{
  Z(x,"td_ty_Z");
  X(x,NODE_TYPE, "td_ty_t");
  Y(x,ENTRY.t.ty.ty.td.std_ty_init, "td_ty");
  return ENTRY.t.ty.ty.td.std_ty;
}

TYPEP
td_de(x)
  TYPEP x;
{
  Z(x,"td_de_Z");
  X(x,NODE_TYPE, "td_de_t");
  Y(x,ENTRY.t.ty.ty.td.std_de_init, "td_de");
  return ENTRY.t.ty.ty.td.std_de;
}

int
cl_val(x)
  TYPEP x;
{
  Z(x,"cl_val_Z");
  X(x,NODE_CLASS, "cl_val_t");
  Y(x,ENTRY.t.cl.cl_sval_init, "cl_val");
  return ENTRY.t.cl.cl_sval;
}

TYPEP
tl_ty(x)
  TYPEP x;
{
  Z(x,"tl_ty_Z");
  X(x,NODE_T_DCL_LIST, "tl_ty_t");
  Y(x,ENTRY.t.tl.tl_sty_init, "tl_ty");
  return ENTRY.t.tl.tl_sty;
}

TYPEP
tl_dl(x)
  TYPEP x;
{
  Z(x,"tl_dl_Z");
  X(x,NODE_T_DCL_LIST, "tl_dl_t");
  Y(x,ENTRY.t.tl.tl_sdl_init, "tl_dl");
  return ENTRY.t.tl.tl_sdl;
}

TYPEP
tl_next(x)
  TYPEP x;
{
  Z(x,"tl_next_Z");
  X(x,NODE_T_DCL_LIST, "tl_next_t");
  Y(x,ENTRY.t.tl.tl_snext_init, "tl_next");
  return ENTRY.t.tl.tl_snext;
}

TYPEP
dl_de(x)
  TYPEP x;
{
  Z(x,"dl_de_Z");
  X(x,NODE_DECL_LIST, "dl_de_t");
  Y(x,ENTRY.t.dl.dl_sde_init, "dl_de");
  return ENTRY.t.dl.dl_sde;
}

TYPEP
dl_next(x)
  TYPEP x;
{
  Z(x,"dl_next_Z");
  X(x,NODE_DECL_LIST, "dl_next_t");
  Y(x,ENTRY.t.dl.dl_snext_init, "dl_next");
  return ENTRY.t.dl.dl_snext;
}

char
de_flag(x)
  TYPEP x;
{
  Z(x,"de_flag_Z");
  X(x,NODE_DECL, "de_flag_t");
  Y(x,ENTRY.t.de.de_sflag_init, "de_flag");
  return ENTRY.t.de.de_sflag;
}

char
de_fl(x)
  TYPEP x;
{
  Z(x,"de_fl_Z");
  X(x,NODE_DECL, "de_fl_t");
  Y(x,ENTRY.t.de.de_sfl_init, "de_fl");
  return ENTRY.t.de.de_sfl;
}

int
de_in_max(x)
  TYPEP x;
{
  Z(x,"de_in_max_Z");
  X(x,NODE_DECL, "de_in_max_t");
  Y(x,ENTRY.t.de.de_in_smax_init, "de_in_max");
  return ENTRY.t.de.de_in_smax;
}

int
de_in_cur(x)
  TYPEP x;
{
  Z(x,"de_in_cur_Z");
  X(x,NODE_DECL, "de_in_cur_t");
  Y(x,ENTRY.t.de.de_in_scur_init, "de_in_cur");
  return ENTRY.t.de.de_in_scur;
}

long
de_off(x)
  TYPEP x;
{
  Z(x,"de_off_Z");
  X(x,NODE_DECL, "de_off_t");
  Y(x,ENTRY.t.de.de_soff_init, "de_off");
  return ENTRY.t.de.de_soff;
}

int
de_len(x)
  TYPEP x;
{
  Z(x,"de_len_Z");
  X(x,NODE_DECL, "de_len_t");
  Y(x,ENTRY.t.de.de_slen_init, "de_len");
  return ENTRY.t.de.de_slen;
}

TYPEP
de_next(x)
  TYPEP x;
{
  Z(x,"de_next_Z");
  X(x,NODE_DECL, "de_next_t");
  Y(x,ENTRY.t.de.de_snext_init, "de_next");
  return ENTRY.t.de.de_snext;
}

TYPEP
de_ty(x)
  TYPEP x;
{
  Z(x,"de_ty_Z");
  X(x,NODE_DECL, "de_ty_t");
  Y(x,ENTRY.t.de.de_sty_init, "de_ty");
  return ENTRY.t.de.de_sty;
}

void
ty_name_new(x, y)
  TYPEP x;
  char *y;
{
  Z(x,"ty_name_z");
  ENTRY.ty_sname = y;
}

void
ty_type_new(x, y)
  TYPEP x;
  char y;
{
  Z(x,"ty_type_z");
  ENTRY.ty_stype = y;
}

void
ty_next_new(x, y)
  TYPEP x, y;
{
  Z(x,"ty_next_z");
  ENTRY.ty_snext = y;
}

void
at_cl_new(x, y)
  TYPEP x,y;
{
  Z(x,"at_cl_z");
  X(x,NODE_ATTR, "at_cl_T");
  W(ENTRY.t.at.at_scl_init = TRUE);
  ENTRY.t.at.at_scl = y;
}

void
at_ty_new(x, y)
  TYPEP x, y;
{
  Z(x,"at_ty_z");
  X(x,NODE_ATTR, "at_ty_T");
  W(ENTRY.t.at.at_sty_init = TRUE);
  ENTRY.t.at.at_sty = y;
}

void
at_off_new(x, y)
  TYPEP x;
  long y;
{
  Z(x,"at_off_z");
  X(x,NODE_ATTR, "at_off_T");
  W(ENTRY.t.at.at_soff_init = TRUE);
  ENTRY.t.at.at_soff = y;
}

void
at_len_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"at_len_z");
  X(x,NODE_ATTR, "at_len_T");
  W(ENTRY.t.at.at_slen_init = TRUE);
  ENTRY.t.at.at_slen = y;
}

void
id_at_new(x, y)
  TYPEP x, y;
{
  Z(x,"id_at_z");
  X(x,NODE_IDENT, "id_at_T");
  W(ENTRY.t.id.id_sat_init = TRUE);
  ENTRY.t.id.id_sat = y;
}

void
id_de_new(x, y)
  TYPEP x, y;
{
  Z(x,"id_de_z");
  X(x,NODE_IDENT, "id_de_T");
  W(ENTRY.t.id.id_sde_init = TRUE);
  ENTRY.t.id.id_sde = y;
}

void
id_flag_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"id_flag_z");
  X(x,NODE_IDENT, "id_flag_T");
  W(ENTRY.t.id.id_sflag_init = TRUE);
  ENTRY.t.id.id_sflag = y;
}

void
id_re_new(x, y)
  TYPEP x, y;
{
  Z(x,"id_re_z");
  X(x,NODE_IDENT, "id_re_T");
  W(ENTRY.t.id.id_sre_init = TRUE);
  ENTRY.t.id.id_sre = y;
}

void
re_na_new(x, y)
  TYPEP x;
  char *y;
{
  Z(x,"re_na_z");
  X(x,NODE_REPLACE, "re_na_T");
  W(ENTRY.t.re.re_sna_init = TRUE);
  ENTRY.t.re.re_sna = y;
}

void
re_off_new(x, y)
  TYPEP x;
  long y;
{
  Z(x,"re_off_z");
  X(x,NODE_REPLACE, "re_off_T");
  W(ENTRY.t.re.re_soff_init = TRUE);
  ENTRY.t.re.re_soff = y;
}

void
re_len_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"re_len_z");
  X(x,NODE_REPLACE, "re_len_T");
  W(ENTRY.t.re.re_slen_init = TRUE);
  ENTRY.t.re.re_slen = y;
}

void
re_zero_new(x, y)
  TYPEP x;
  long y;
{
  Z(x,"re_zero_z");
  X(x,NODE_REPLACE, "re_zero_T");
  W(ENTRY.t.re.re_szero_init = TRUE);
  ENTRY.t.re.re_szero = y;
}

void
re_flag_new(x, y)
  TYPEP x;
  char y;
{
  Z(x,"re_flag_z");
  X(x,NODE_REPLACE, "re_flag_T");
  W(ENTRY.t.re.re_sflag_init = TRUE);
  ENTRY.t.re.re_sflag = y;
}

void
re_alen_new(x, y)
  TYPEP x;
  int y;
{  
  Z(x,"re_alen_z");
  X(x,NODE_REPLACE, "re_alen_T");
  W(ENTRY.t.re.re_salen_init = TRUE);
  ENTRY.t.re.re_salen = y;
}

void
re_si_new(x, y)
  TYPEP x;
  char *y;
{
  Z(x,"re_si_z");
  X(x,NODE_REPLACE, "re_si_T");
  W(ENTRY.t.re.re_ssi_init = TRUE);
  ENTRY.t.re.re_ssi = y;
}

void
re_next_new(x, y)
  TYPEP x, y;
{
  Z(x,"re_next_z");
  X(x,NODE_REPLACE, "re_next_T");
  W(ENTRY.t.re.re_snext_init = TRUE);
  ENTRY.t.re.re_snext = y;
}

void
re_nr_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"re_nr_z");
  X(x,NODE_REPLACE, "re_nr_T");
  W(ENTRY.t.re.re_snr_init = TRUE);
  ENTRY.t.re.re_snr = y;
}

void
ty_flag_new(x, y)
  TYPEP x;
  char y;
{
  Z(x,"ty_flag_z");
  X(x,NODE_TYPE, "ty_flag_T");
  W(ENTRY.t.ty.ty_sflag_init = TRUE);
  ENTRY.t.ty.ty_sflag = y;
}

void
ty_sys_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"ty_sys_z");
  X(x,NODE_TYPE, "ty_sys_T");
  W(ENTRY.t.ty.ty.ty_ssys_init = TRUE);
  ENTRY.t.ty.ty.ty_ssys = y;
}

void
su_tl_new(x, y)
  TYPEP x, y;
{
  Z(x,"su_tl_z");
  X(x,NODE_TYPE, "su_tl_T");
  W(ENTRY.t.ty.ty.su.ssu_tl_init = TRUE);
  ENTRY.t.ty.ty.su.ssu_tl = y;
}

void
su_ctl_new(x, y)
  TYPEP x, y;
{
  Z(x,"su_ctl_z");
  X(x,NODE_TYPE, "su_ctl_T");
  W(ENTRY.t.ty.ty.su.ssu_ctl_init = TRUE);
  ENTRY.t.ty.ty.su.ssu_ctl = y;
}

void
su_cdl_new(x, y)
  TYPEP x, y;
{
  Z(x,"su_cdl_z");
  X(x,NODE_TYPE, "su_cdl_T");
  W(ENTRY.t.ty.ty.su.ssu_cdl_init = TRUE);
  ENTRY.t.ty.ty.su.ssu_cdl = y;
}

void
su_fl_new(x, y)
  TYPEP x;
  char y;
{
  Z(x,"su_fl_z");
  X(x,NODE_TYPE, "su_fl_T");
  W(ENTRY.t.ty.ty.su.ssu_fl_init = TRUE);
  ENTRY.t.ty.ty.su.ssu_fl = y;
}

void
td_ty_new(x, y)
  TYPEP x, y;
{
  Z(x,"td_ty_z");
  X(x,NODE_TYPE, "td_ty_T");
  W(ENTRY.t.ty.ty.td.std_ty_init = TRUE);
  ENTRY.t.ty.ty.td.std_ty = y;
}

void
td_de_new(x, y)
  TYPEP x, y;
{
  Z(x,"td_te_z");
  X(x,NODE_TYPE, "td_de_T");
  W(ENTRY.t.ty.ty.td.std_de_init = TRUE);
  ENTRY.t.ty.ty.td.std_de = y;
}

void
cl_val_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"cl_val_z");
  X(x,NODE_CLASS, "cl_val_T");
  W(ENTRY.t.cl.cl_sval_init = TRUE);
  ENTRY.t.cl.cl_sval = y;
}

void
tl_ty_new(x, y)
  TYPEP x, y;
{
  Z(x,"tl_ty_z");
  X(x,NODE_T_DCL_LIST, "tl_ty_T");
  W(ENTRY.t.tl.tl_sty_init = TRUE);
  ENTRY.t.tl.tl_sty = y;
}

void
tl_dl_new(x, y)
  TYPEP x, y;
{
  Z(x,"tl_dl_z");
  X(x,NODE_T_DCL_LIST, "tl_dl_T");
  W(ENTRY.t.tl.tl_sdl_init = TRUE);
  ENTRY.t.tl.tl_sdl = y;
}

void
tl_next_new(x, y)
  TYPEP x, y;
{
  Z(x,"tl_next_z");
  X(x,NODE_T_DCL_LIST, "tl_next_T");
  W(ENTRY.t.tl.tl_snext_init = TRUE);
  ENTRY.t.tl.tl_snext = y;
}

void
dl_de_new(x, y)
  TYPEP x, y;
{
  Z(x,"dl_de_z");
  X(x,NODE_DECL_LIST, "dl_de_T");
  W(ENTRY.t.dl.dl_sde_init = TRUE);
  ENTRY.t.dl.dl_sde = y;
}

void
dl_next_new(x, y)
  TYPEP x, y;
{
  Z(x,"dl_next_z");
  X(x,NODE_DECL_LIST, "dl_next_T");
  W(ENTRY.t.dl.dl_snext_init = TRUE);
  ENTRY.t.dl.dl_snext = y;
}

void
de_flag_new(x, y)
  TYPEP x;
  char y;
{
  Z(x,"de_flag_z");
  X(x,NODE_DECL, "de_flag_T");
  W(ENTRY.t.de.de_sflag_init = TRUE);
  ENTRY.t.de.de_sflag = y;
}

void
de_fl_new(x, y)
  TYPEP x;
  char y;
{
  Z(x,"de_fl_z");
  X(x,NODE_DECL, "de_fl_T");
  W(ENTRY.t.de.de_sfl_init = TRUE);
  ENTRY.t.de.de_sfl = y;
}

void
de_in_max_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"de_in_max_z");
  X(x,NODE_DECL, "de_in_max_T");
  W(ENTRY.t.de.de_in_smax_init = TRUE);
  ENTRY.t.de.de_in_smax = y;
}

void
de_in_cur_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"de_in_cur_z");
  X(x,NODE_DECL, "de_in_cur_T");
  W(ENTRY.t.de.de_in_scur_init = TRUE);
  ENTRY.t.de.de_in_scur = y;
}

void
de_off_new(x, y)
  TYPEP x;
  long y;
{
  Z(x,"de_off_z");
  X(x,NODE_DECL, "de_off_T");
  W(ENTRY.t.de.de_soff_init = TRUE);
  ENTRY.t.de.de_soff = y;
}

void
de_len_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"de_len_z");
  X(x,NODE_DECL, "de_len_T");
  W(ENTRY.t.de.de_slen_init = TRUE);
  ENTRY.t.de.de_slen = y;
}

void
de_next_new(x, y)
  TYPEP x, y;
{
  Z(x,"de_next_z");
  X(x,NODE_DECL, "de_next_T");
  W(ENTRY.t.de.de_snext_init = TRUE);
  ENTRY.t.de.de_snext = y;
}

void
de_ty_new(x, y)
  TYPEP x, y;
{
  Z(x,"de_ty_z");
  X(x,NODE_DECL, "de_ty_T");
  W(ENTRY.t.de.de_sty_init = TRUE);
  ENTRY.t.de.de_sty = y;
}

bool
is_null_type(x)
  TYPEP x;
{
  return (x.ty_level == -1);
}

long
ec_off(x)
  TYPEP x;
{
  Z(x,"ec_off_Z");
  X(x,NODE_CHAIN, "ec_off_t");
  Y(x,ENTRY.t.ec.ec_off_init, "ec_off");
  return ENTRY.t.ec.ec_off;
}

int
ec_len(x)
  TYPEP x;
{
  Z(x,"ec_len_Z");
  X(x,NODE_CHAIN, "ec_len_t");
  Y(x,ENTRY.t.ec.ec_len_init, "ec_len");
  return ENTRY.t.ec.ec_len;
}

long
ec_a_off(x)
  TYPEP x;
{
  Z(x,"ec_off_Z");
  X(x,NODE_CHAIN, "ec_a_off_t");
  Y(x,ENTRY.t.ec.ec_a_off_init, "ec_a_off");
  return ENTRY.t.ec.ec_a_off;
}

int
ec_a_len(x)
  TYPEP x;
{
  Z(x,"ec_a_len_Z");
  X(x,NODE_CHAIN, "ec_a_len_t");
  Y(x,ENTRY.t.ec.ec_a_len_init, "ec_a_len");
  return ENTRY.t.ec.ec_a_len;
}

TYPEP
ec_next(x)
  TYPEP x;
{
  Z(x,"ec_next_Z");
  X(x,NODE_CHAIN, "ec_next_t");
  Y(x,ENTRY.t.ec.ec_next_init, "ec_next");
  return ENTRY.t.ec.ec_next;
}

bool
ec_typedef(x)
  TYPEP x;
{
  Z(x,"ec_typedef_Z");
  X(x,NODE_CHAIN, "ec_typedef_t");
  Y(x,ENTRY.t.ec.ec_typedef_init, "ec_typedef");
  return ENTRY.t.ec.ec_typedef;
}

void
ec_off_new(x, y)
  TYPEP x;
  long y;
{
  Z(x,"ec_off_z");
  X(x,NODE_CHAIN, "ec_off_T");
  W(ENTRY.t.ec.ec_off_init = TRUE);
  ENTRY.t.ec.ec_off=y;
}

void
ec_a_off_new(x, y)
  TYPEP x;
  long y;
{
  Z(x,"ec_a_off_z");
  X(x,NODE_CHAIN, "ec_a_off_T");
  W(ENTRY.t.ec.ec_a_off_init = TRUE);
  ENTRY.t.ec.ec_a_off=y;
}

void
ec_a_len_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"ec_a_len_z");
  X(x,NODE_CHAIN, "ec_a_len_T");
  W(ENTRY.t.ec.ec_a_len_init = TRUE);
  ENTRY.t.ec.ec_a_len=y;
}

void
ec_len_new(x, y)
  TYPEP x;
  int y;
{
  Z(x,"ec_len_z");
  X(x,NODE_CHAIN, "ec_len_T");
  W(ENTRY.t.ec.ec_len_init = TRUE);
  ENTRY.t.ec.ec_len=y;
}

void
ec_next_new(x, y)
  TYPEP x, y;
{
  Z(x,"ec_next_z");
  X(x,NODE_CHAIN, "ec_next_T");
  W(ENTRY.t.ec.ec_next_init = TRUE);
  ENTRY.t.ec.ec_next=y;
}

void
ec_typedef_new(x, y)
  TYPEP x;
  bool y;
{
  Z(x,"ec_typedef_z");
  X(x,NODE_CHAIN, "ec_typedef_T");
  W(ENTRY.t.ec.ec_typedef_init = TRUE);
  ENTRY.t.ec.ec_typedef=y;
}

TYPEP
id_ec(x)
  TYPEP x;
{
  Z(x,"id_ec_Z");
  X(x,NODE_IDENT, "id_ec_t");
  Y(x,ENTRY.t.id.id_ec_init, "id_ec");
  return ENTRY.t.id.id_ec;
}

void
id_ec_new(x, y)
  TYPEP x, y;
{
  Z(x,"id_ec_z");
  X(x,NODE_IDENT, "id_ec_T");
  W(ENTRY.t.id.id_ec_init = TRUE);
  ENTRY.t.id.id_ec=y;
}
