/* * Copyright (c) 2003, The Tendra Project * 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, 1998 * * 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/producers/common/c_class.alg,v 1.18 2005/11/07 18:42:37 stefanf Exp $ */ /* * AUTOMATICALLY GENERATED FROM ALGEBRA c_class (VERSION 1.1) * BY calculus (VERSION 1.3) */ #ifndef EXP_OPS_H_INCLUDED #define EXP_OPS_H_INCLUDED /* Operations for union EXP */ #define TAG_exp(P) (CHECK_NULL (P)->ag_tag) /* Operations for component type of union EXP */ #define exp_type(P) (CHECK_NULL (P) + 1) /* Operations for field set identifier_etc of union EXP */ #define exp_identifier_etc_tag 4u #define IS_exp_identifier_etc(P) ((unsigned) (CHECK_NULL (P)->ag_tag - 0) < 4u) #define exp_identifier_etc_id(P) (CHECK_TAG_ETC ((P), 0, 4) + 2) #define exp_identifier_etc_qual(P) (CHECK_TAG_ETC ((P), 0, 4) + 3) #define MAKE_exp_identifier_etc(tag, type_, id_, qual_, c_class_exp)\ {\ c_class *x489_ = GEN_c_class ( 4, TYPEID_exp );\ x489_->ag_tag = (tag);\ COPY_type (x489_ + 1, (type_));\ COPY_id (x489_ + 2, (id_));\ COPY_qual (x489_ + 3, (qual_));\ (c_class_exp) = CHECK_TAG_ETC (x489_, 0, 4);\ } #define MODIFY_exp_identifier_etc(tag, c_class_exp)\ {\ c_class *x490_ = CHECK_TAG_ETC ((c_class_exp), 0, 4);\ x490_->ag_tag = (tag);\ (void) CHECK_TAG_ETC (x490_, 0, 4);\ } #define DECONS_exp_identifier_etc(type_, id_, qual_, c_class_exp)\ {\ c_class *x491_ = CHECK_TAG_ETC ((c_class_exp), 0, 4);\ (type_) = DEREF_type (x491_ + 1);\ (id_) = DEREF_id (x491_ + 2);\ (qual_) = DEREF_qual (x491_ + 3);\ } #define DESTROY_exp_identifier_etc(destroyer_, type_, id_, qual_, c_class_exp)\ {\ c_class *x492_ = CHECK_TAG_ETC ((c_class_exp), 0, 4);\ (type_) = DEREF_type (x492_ + 1);\ (id_) = DEREF_id (x492_ + 2);\ (qual_) = DEREF_qual (x492_ + 3);\ (destroyer_) (x492_, 4u);\ } /* Operations for field identifier of union EXP */ #define exp_identifier_tag 0u #define IS_exp_identifier(P) (CHECK_NULL (P)->ag_tag == 0) #define exp_identifier_id(P) (CHECK_TAG ((P), 0) + 2) #define exp_identifier_qual(P) (CHECK_TAG ((P), 0) + 3) #define MAKE_exp_identifier(type_, id_, qual_, c_class_exp)\ {\ c_class *x493_ = GEN_c_class ( 4, TYPEID_exp );\ x493_->ag_tag = 0;\ COPY_type (x493_ + 1, (type_));\ COPY_id (x493_ + 2, (id_));\ COPY_qual (x493_ + 3, (qual_));\ (c_class_exp) = x493_;\ } #define DECONS_exp_identifier(type_, id_, qual_, c_class_exp)\ {\ c_class *x494_ = CHECK_TAG ((c_class_exp), 0);\ (type_) = DEREF_type (x494_ + 1);\ (id_) = DEREF_id (x494_ + 2);\ (qual_) = DEREF_qual (x494_ + 3);\ } #define DESTROY_exp_identifier(destroyer_, type_, id_, qual_, c_class_exp)\ {\ c_class *x495_ = CHECK_TAG ((c_class_exp), 0);\ (type_) = DEREF_type (x495_ + 1);\ (id_) = DEREF_id (x495_ + 2);\ (qual_) = DEREF_qual (x495_ + 3);\ (destroyer_) (x495_, 4u);\ } /* Operations for field member of union EXP */ #define exp_member_tag 1u #define IS_exp_member(P) (CHECK_NULL (P)->ag_tag == 1) #define exp_member_id(P) (CHECK_TAG ((P), 1) + 2) #define exp_member_qual(P) (CHECK_TAG ((P), 1) + 3) #define MAKE_exp_member(type_, id_, qual_, c_class_exp)\ {\ c_class *x496_ = GEN_c_class ( 4, TYPEID_exp );\ x496_->ag_tag = 1;\ COPY_type (x496_ + 1, (type_));\ COPY_id (x496_ + 2, (id_));\ COPY_qual (x496_ + 3, (qual_));\ (c_class_exp) = x496_;\ } #define DECONS_exp_member(type_, id_, qual_, c_class_exp)\ {\ c_class *x497_ = CHECK_TAG ((c_class_exp), 1);\ (type_) = DEREF_type (x497_ + 1);\ (id_) = DEREF_id (x497_ + 2);\ (qual_) = DEREF_qual (x497_ + 3);\ } #define DESTROY_exp_member(destroyer_, type_, id_, qual_, c_class_exp)\ {\ c_class *x498_ = CHECK_TAG ((c_class_exp), 1);\ (type_) = DEREF_type (x498_ + 1);\ (id_) = DEREF_id (x498_ + 2);\ (qual_) = DEREF_qual (x498_ + 3);\ (destroyer_) (x498_, 4u);\ } /* Operations for field ambiguous of union EXP */ #define exp_ambiguous_tag 2u #define IS_exp_ambiguous(P) (CHECK_NULL (P)->ag_tag == 2) #define exp_ambiguous_id(P) (CHECK_TAG ((P), 2) + 2) #define exp_ambiguous_qual(P) (CHECK_TAG ((P), 2) + 3) #define MAKE_exp_ambiguous(type_, id_, qual_, c_class_exp)\ {\ c_class *x499_ = GEN_c_class ( 4, TYPEID_exp );\ x499_->ag_tag = 2;\ COPY_type (x499_ + 1, (type_));\ COPY_id (x499_ + 2, (id_));\ COPY_qual (x499_ + 3, (qual_));\ (c_class_exp) = x499_;\ } #define DECONS_exp_ambiguous(type_, id_, qual_, c_class_exp)\ {\ c_class *x500_ = CHECK_TAG ((c_class_exp), 2);\ (type_) = DEREF_type (x500_ + 1);\ (id_) = DEREF_id (x500_ + 2);\ (qual_) = DEREF_qual (x500_ + 3);\ } #define DESTROY_exp_ambiguous(destroyer_, type_, id_, qual_, c_class_exp)\ {\ c_class *x501_ = CHECK_TAG ((c_class_exp), 2);\ (type_) = DEREF_type (x501_ + 1);\ (id_) = DEREF_id (x501_ + 2);\ (qual_) = DEREF_qual (x501_ + 3);\ (destroyer_) (x501_, 4u);\ } /* Operations for field undeclared of union EXP */ #define exp_undeclared_tag 3u #define IS_exp_undeclared(P) (CHECK_NULL (P)->ag_tag == 3) #define exp_undeclared_id(P) (CHECK_TAG ((P), 3) + 2) #define exp_undeclared_qual(P) (CHECK_TAG ((P), 3) + 3) #define MAKE_exp_undeclared(type_, id_, qual_, c_class_exp)\ {\ c_class *x502_ = GEN_c_class ( 4, TYPEID_exp );\ x502_->ag_tag = 3;\ COPY_type (x502_ + 1, (type_));\ COPY_id (x502_ + 2, (id_));\ COPY_qual (x502_ + 3, (qual_));\ (c_class_exp) = x502_;\ } #define DECONS_exp_undeclared(type_, id_, qual_, c_class_exp)\ {\ c_class *x503_ = CHECK_TAG ((c_class_exp), 3);\ (type_) = DEREF_type (x503_ + 1);\ (id_) = DEREF_id (x503_ + 2);\ (qual_) = DEREF_qual (x503_ + 3);\ } #define DESTROY_exp_undeclared(destroyer_, type_, id_, qual_, c_class_exp)\ {\ c_class *x504_ = CHECK_TAG ((c_class_exp), 3);\ (type_) = DEREF_type (x504_ + 1);\ (id_) = DEREF_id (x504_ + 2);\ (qual_) = DEREF_qual (x504_ + 3);\ (destroyer_) (x504_, 4u);\ } /* Operations for field int_lit of union EXP */ #define exp_int_lit_tag 4u #define IS_exp_int_lit(P) (CHECK_NULL (P)->ag_tag == 4) #define exp_int_lit_nat(P) (CHECK_TAG ((P), 4) + 2) #define exp_int_lit_etag(P) (CHECK_TAG ((P), 4) + 3) #define MAKE_exp_int_lit(type_, nat_, etag_, c_class_exp)\ {\ c_class *x505_ = GEN_c_class ( 4, TYPEID_exp );\ x505_->ag_tag = 4;\ COPY_type (x505_ + 1, (type_));\ COPY_nat (x505_ + 2, (nat_));\ COPY_unsigned (x505_ + 3, (etag_));\ (c_class_exp) = x505_;\ } #define DECONS_exp_int_lit(type_, nat_, etag_, c_class_exp)\ {\ c_class *x506_ = CHECK_TAG ((c_class_exp), 4);\ (type_) = DEREF_type (x506_ + 1);\ (nat_) = DEREF_nat (x506_ + 2);\ (etag_) = DEREF_unsigned (x506_ + 3);\ } #define DESTROY_exp_int_lit(destroyer_, type_, nat_, etag_, c_class_exp)\ {\ c_class *x507_ = CHECK_TAG ((c_class_exp), 4);\ (type_) = DEREF_type (x507_ + 1);\ (nat_) = DEREF_nat (x507_ + 2);\ (etag_) = DEREF_unsigned (x507_ + 3);\ (destroyer_) (x507_, 4u);\ } /* Operations for field float_lit of union EXP */ #define exp_float_lit_tag 5u #define IS_exp_float_lit(P) (CHECK_NULL (P)->ag_tag == 5) #define exp_float_lit_flt(P) (CHECK_TAG ((P), 5) + 2) #define MAKE_exp_float_lit(type_, flt_, c_class_exp)\ {\ c_class *x508_ = GEN_c_class ( 3, TYPEID_exp );\ x508_->ag_tag = 5;\ COPY_type (x508_ + 1, (type_));\ COPY_flt (x508_ + 2, (flt_));\ (c_class_exp) = x508_;\ } #define DECONS_exp_float_lit(type_, flt_, c_class_exp)\ {\ c_class *x509_ = CHECK_TAG ((c_class_exp), 5);\ (type_) = DEREF_type (x509_ + 1);\ (flt_) = DEREF_flt (x509_ + 2);\ } #define DESTROY_exp_float_lit(destroyer_, type_, flt_, c_class_exp)\ {\ c_class *x510_ = CHECK_TAG ((c_class_exp), 5);\ (type_) = DEREF_type (x510_ + 1);\ (flt_) = DEREF_flt (x510_ + 2);\ (destroyer_) (x510_, 3u);\ } /* Operations for field char_lit of union EXP */ #define exp_char_lit_tag 6u #define IS_exp_char_lit(P) (CHECK_NULL (P)->ag_tag == 6) #define exp_char_lit_str(P) (CHECK_TAG ((P), 6) + 2) #define exp_char_lit_digit(P) (CHECK_TAG ((P), 6) + 3) #define MAKE_exp_char_lit(type_, str_, digit_, c_class_exp)\ {\ c_class *x511_ = GEN_c_class ( 4, TYPEID_exp );\ x511_->ag_tag = 6;\ COPY_type (x511_ + 1, (type_));\ COPY_str (x511_ + 2, (str_));\ COPY_int (x511_ + 3, (digit_));\ (c_class_exp) = x511_;\ } #define DECONS_exp_char_lit(type_, str_, digit_, c_class_exp)\ {\ c_class *x512_ = CHECK_TAG ((c_class_exp), 6);\ (type_) = DEREF_type (x512_ + 1);\ (str_) = DEREF_str (x512_ + 2);\ (digit_) = DEREF_int (x512_ + 3);\ } #define DESTROY_exp_char_lit(destroyer_, type_, str_, digit_, c_class_exp)\ {\ c_class *x513_ = CHECK_TAG ((c_class_exp), 6);\ (type_) = DEREF_type (x513_ + 1);\ (str_) = DEREF_str (x513_ + 2);\ (digit_) = DEREF_int (x513_ + 3);\ (destroyer_) (x513_, 4u);\ } /* Operations for field string_lit of union EXP */ #define exp_string_lit_tag 7u #define IS_exp_string_lit(P) (CHECK_NULL (P)->ag_tag == 7) #define exp_string_lit_str(P) (CHECK_TAG ((P), 7) + 2) #define MAKE_exp_string_lit(type_, str_, c_class_exp)\ {\ c_class *x514_ = GEN_c_class ( 3, TYPEID_exp );\ x514_->ag_tag = 7;\ COPY_type (x514_ + 1, (type_));\ COPY_str (x514_ + 2, (str_));\ (c_class_exp) = x514_;\ } #define DECONS_exp_string_lit(type_, str_, c_class_exp)\ {\ c_class *x515_ = CHECK_TAG ((c_class_exp), 7);\ (type_) = DEREF_type (x515_ + 1);\ (str_) = DEREF_str (x515_ + 2);\ } #define DESTROY_exp_string_lit(destroyer_, type_, str_, c_class_exp)\ {\ c_class *x516_ = CHECK_TAG ((c_class_exp), 7);\ (type_) = DEREF_type (x516_ + 1);\ (str_) = DEREF_str (x516_ + 2);\ (destroyer_) (x516_, 3u);\ } /* Operations for field value of union EXP */ #define exp_value_tag 8u #define IS_exp_value(P) (CHECK_NULL (P)->ag_tag == 8) #define MAKE_exp_value(type_, c_class_exp)\ {\ c_class *x517_ = GEN_c_class ( 2, TYPEID_exp );\ x517_->ag_tag = 8;\ COPY_type (x517_ + 1, (type_));\ (c_class_exp) = x517_;\ } #define DECONS_exp_value(type_, c_class_exp)\ {\ c_class *x518_ = CHECK_TAG ((c_class_exp), 8);\ (type_) = DEREF_type (x518_ + 1);\ } #define DESTROY_exp_value(destroyer_, type_, c_class_exp)\ {\ c_class *x519_ = CHECK_TAG ((c_class_exp), 8);\ (type_) = DEREF_type (x519_ + 1);\ (destroyer_) (x519_, 2u);\ } /* Operations for field set null_etc of union EXP */ #define exp_null_etc_tag 11u #define IS_exp_null_etc(P) ((unsigned) (CHECK_NULL (P)->ag_tag - 9) < 2u) #define exp_null_etc_ptr_const(P) (CHECK_TAG_ETC ((P), 9, 11) + 2) #define MAKE_exp_null_etc(tag, type_, c_class_exp)\ {\ c_class *x520_ = GEN_c_class ( 3, TYPEID_exp );\ x520_->ag_tag = (tag);\ COPY_type (x520_ + 1, (type_));\ COPY_int (x520_ + 2, 0);\ (c_class_exp) = CHECK_TAG_ETC (x520_, 9, 11);\ } #define MODIFY_exp_null_etc(tag, c_class_exp)\ {\ c_class *x521_ = CHECK_TAG_ETC ((c_class_exp), 9, 11);\ x521_->ag_tag = (tag);\ (void) CHECK_TAG_ETC (x521_, 9, 11);\ } #define DECONS_exp_null_etc(type_, ptr_const_, c_class_exp)\ {\ c_class *x522_ = CHECK_TAG_ETC ((c_class_exp), 9, 11);\ (type_) = DEREF_type (x522_ + 1);\ (ptr_const_) = DEREF_int (x522_ + 2);\ } #define DESTROY_exp_null_etc(destroyer_, type_, ptr_const_, c_class_exp)\ {\ c_class *x523_ = CHECK_TAG_ETC ((c_class_exp), 9, 11);\ (type_) = DEREF_type (x523_ + 1);\ (ptr_const_) = DEREF_int (x523_ + 2);\ (destroyer_) (x523_, 3u);\ } /* Operations for field null of union EXP */ #define exp_null_tag 9u #define IS_exp_null(P) (CHECK_NULL (P)->ag_tag == 9) #define exp_null_ptr_const(P) (CHECK_TAG ((P), 9) + 2) #define MAKE_exp_null(type_, c_class_exp)\ {\ c_class *x524_ = GEN_c_class ( 3, TYPEID_exp );\ x524_->ag_tag = 9;\ COPY_type (x524_ + 1, (type_));\ COPY_int (x524_ + 2, 0);\ (c_class_exp) = x524_;\ } #define DECONS_exp_null(type_, ptr_const_, c_class_exp)\ {\ c_class *x525_ = CHECK_TAG ((c_class_exp), 9);\ (type_) = DEREF_type (x525_ + 1);\ (ptr_const_) = DEREF_int (x525_ + 2);\ } #define DESTROY_exp_null(destroyer_, type_, ptr_const_, c_class_exp)\ {\ c_class *x526_ = CHECK_TAG ((c_class_exp), 9);\ (type_) = DEREF_type (x526_ + 1);\ (ptr_const_) = DEREF_int (x526_ + 2);\ (destroyer_) (x526_, 3u);\ } /* Operations for field zero of union EXP */ #define exp_zero_tag 10u #define IS_exp_zero(P) (CHECK_NULL (P)->ag_tag == 10) #define exp_zero_ptr_const(P) (CHECK_TAG ((P), 10) + 2) #define MAKE_exp_zero(type_, c_class_exp)\ {\ c_class *x527_ = GEN_c_class ( 3, TYPEID_exp );\ x527_->ag_tag = 10;\ COPY_type (x527_ + 1, (type_));\ COPY_int (x527_ + 2, 0);\ (c_class_exp) = x527_;\ } #define DECONS_exp_zero(type_, ptr_const_, c_class_exp)\ {\ c_class *x528_ = CHECK_TAG ((c_class_exp), 10);\ (type_) = DEREF_type (x528_ + 1);\ (ptr_const_) = DEREF_int (x528_ + 2);\ } #define DESTROY_exp_zero(destroyer_, type_, ptr_const_, c_class_exp)\ {\ c_class *x529_ = CHECK_TAG ((c_class_exp), 10);\ (type_) = DEREF_type (x529_ + 1);\ (ptr_const_) = DEREF_int (x529_ + 2);\ (destroyer_) (x529_, 3u);\ } /* Operations for field set paren_etc of union EXP */ #define exp_paren_etc_tag 13u #define IS_exp_paren_etc(P) ((unsigned) (CHECK_NULL (P)->ag_tag - 11) < 2u) #define exp_paren_etc_arg(P) (CHECK_TAG_ETC ((P), 11, 13) + 2) #define MAKE_exp_paren_etc(tag, type_, arg_, c_class_exp)\ {\ c_class *x530_ = GEN_c_class ( 3, TYPEID_exp );\ x530_->ag_tag = (tag);\ COPY_type (x530_ + 1, (type_));\ COPY_exp (x530_ + 2, (arg_));\ (c_class_exp) = CHECK_TAG_ETC (x530_, 11, 13);\ } #define MODIFY_exp_paren_etc(tag, c_class_exp)\ {\ c_class *x531_ = CHECK_TAG_ETC ((c_class_exp), 11, 13);\ x531_->ag_tag = (tag);\ (void) CHECK_TAG_ETC (x531_, 11, 13);\ } #define DECONS_exp_paren_etc(type_, arg_, c_class_exp)\ {\ c_class *x532_ = CHECK_TAG_ETC ((c_class_exp), 11, 13);\ (type_) = DEREF_type (x532_ + 1);\ (arg_) = DEREF_exp (x532_ + 2);\ } #define DESTROY_exp_paren_etc(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x533_ = CHECK_TAG_ETC ((c_class_exp), 11, 13);\ (type_) = DEREF_type (x533_ + 1);\ (arg_) = DEREF_exp (x533_ + 2);\ (destroyer_) (x533_, 3u);\ } /* Operations for field paren of union EXP */ #define exp_paren_tag 11u #define IS_exp_paren(P) (CHECK_NULL (P)->ag_tag == 11) #define exp_paren_arg(P) (CHECK_TAG ((P), 11) + 2) #define MAKE_exp_paren(type_, arg_, c_class_exp)\ {\ c_class *x534_ = GEN_c_class ( 3, TYPEID_exp );\ x534_->ag_tag = 11;\ COPY_type (x534_ + 1, (type_));\ COPY_exp (x534_ + 2, (arg_));\ (c_class_exp) = x534_;\ } #define DECONS_exp_paren(type_, arg_, c_class_exp)\ {\ c_class *x535_ = CHECK_TAG ((c_class_exp), 11);\ (type_) = DEREF_type (x535_ + 1);\ (arg_) = DEREF_exp (x535_ + 2);\ } #define DESTROY_exp_paren(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x536_ = CHECK_TAG ((c_class_exp), 11);\ (type_) = DEREF_type (x536_ + 1);\ (arg_) = DEREF_exp (x536_ + 2);\ (destroyer_) (x536_, 3u);\ } /* Operations for field copy of union EXP */ #define exp_copy_tag 12u #define IS_exp_copy(P) (CHECK_NULL (P)->ag_tag == 12) #define exp_copy_arg(P) (CHECK_TAG ((P), 12) + 2) #define MAKE_exp_copy(type_, arg_, c_class_exp)\ {\ c_class *x537_ = GEN_c_class ( 3, TYPEID_exp );\ x537_->ag_tag = 12;\ COPY_type (x537_ + 1, (type_));\ COPY_exp (x537_ + 2, (arg_));\ (c_class_exp) = x537_;\ } #define DECONS_exp_copy(type_, arg_, c_class_exp)\ {\ c_class *x538_ = CHECK_TAG ((c_class_exp), 12);\ (type_) = DEREF_type (x538_ + 1);\ (arg_) = DEREF_exp (x538_ + 2);\ } #define DESTROY_exp_copy(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x539_ = CHECK_TAG ((c_class_exp), 12);\ (type_) = DEREF_type (x539_ + 1);\ (arg_) = DEREF_exp (x539_ + 2);\ (destroyer_) (x539_, 3u);\ } /* Operations for field assign of union EXP */ #define exp_assign_tag 13u #define IS_exp_assign(P) (CHECK_NULL (P)->ag_tag == 13) #define exp_assign_ref(P) (CHECK_TAG ((P), 13) + 2) #define exp_assign_arg(P) (CHECK_TAG ((P), 13) + 3) #define MAKE_exp_assign(type_, ref_, arg_, c_class_exp)\ {\ c_class *x540_ = GEN_c_class ( 4, TYPEID_exp );\ x540_->ag_tag = 13;\ COPY_type (x540_ + 1, (type_));\ COPY_exp (x540_ + 2, (ref_));\ COPY_exp (x540_ + 3, (arg_));\ (c_class_exp) = x540_;\ } #define DECONS_exp_assign(type_, ref_, arg_, c_class_exp)\ {\ c_class *x541_ = CHECK_TAG ((c_class_exp), 13);\ (type_) = DEREF_type (x541_ + 1);\ (ref_) = DEREF_exp (x541_ + 2);\ (arg_) = DEREF_exp (x541_ + 3);\ } #define DESTROY_exp_assign(destroyer_, type_, ref_, arg_, c_class_exp)\ {\ c_class *x542_ = CHECK_TAG ((c_class_exp), 13);\ (type_) = DEREF_type (x542_ + 1);\ (ref_) = DEREF_exp (x542_ + 2);\ (arg_) = DEREF_exp (x542_ + 3);\ (destroyer_) (x542_, 4u);\ } /* Operations for field init of union EXP */ #define exp_init_tag 14u #define IS_exp_init(P) (CHECK_NULL (P)->ag_tag == 14) #define exp_init_id(P) (CHECK_TAG ((P), 14) + 2) #define exp_init_arg(P) (CHECK_TAG ((P), 14) + 3) #define MAKE_exp_init(type_, id_, arg_, c_class_exp)\ {\ c_class *x543_ = GEN_c_class ( 4, TYPEID_exp );\ x543_->ag_tag = 14;\ COPY_type (x543_ + 1, (type_));\ COPY_id (x543_ + 2, (id_));\ COPY_exp (x543_ + 3, (arg_));\ (c_class_exp) = x543_;\ } #define DECONS_exp_init(type_, id_, arg_, c_class_exp)\ {\ c_class *x544_ = CHECK_TAG ((c_class_exp), 14);\ (type_) = DEREF_type (x544_ + 1);\ (id_) = DEREF_id (x544_ + 2);\ (arg_) = DEREF_exp (x544_ + 3);\ } #define DESTROY_exp_init(destroyer_, type_, id_, arg_, c_class_exp)\ {\ c_class *x545_ = CHECK_TAG ((c_class_exp), 14);\ (type_) = DEREF_type (x545_ + 1);\ (id_) = DEREF_id (x545_ + 2);\ (arg_) = DEREF_exp (x545_ + 3);\ (destroyer_) (x545_, 4u);\ } /* Operations for field preinc of union EXP */ #define exp_preinc_tag 15u #define IS_exp_preinc(P) (CHECK_NULL (P)->ag_tag == 15) #define exp_preinc_ref(P) (CHECK_TAG ((P), 15) + 2) #define exp_preinc_op(P) (CHECK_TAG ((P), 15) + 3) #define exp_preinc_becomes(P) (CHECK_TAG ((P), 15) + 4) #define MAKE_exp_preinc(type_, ref_, op_, becomes_, c_class_exp)\ {\ c_class *x546_ = GEN_c_class ( 5, TYPEID_exp );\ x546_->ag_tag = 15;\ COPY_type (x546_ + 1, (type_));\ COPY_exp (x546_ + 2, (ref_));\ COPY_exp (x546_ + 3, (op_));\ COPY_int (x546_ + 4, (becomes_));\ (c_class_exp) = x546_;\ } #define DECONS_exp_preinc(type_, ref_, op_, becomes_, c_class_exp)\ {\ c_class *x547_ = CHECK_TAG ((c_class_exp), 15);\ (type_) = DEREF_type (x547_ + 1);\ (ref_) = DEREF_exp (x547_ + 2);\ (op_) = DEREF_exp (x547_ + 3);\ (becomes_) = DEREF_int (x547_ + 4);\ } #define DESTROY_exp_preinc(destroyer_, type_, ref_, op_, becomes_, c_class_exp)\ {\ c_class *x548_ = CHECK_TAG ((c_class_exp), 15);\ (type_) = DEREF_type (x548_ + 1);\ (ref_) = DEREF_exp (x548_ + 2);\ (op_) = DEREF_exp (x548_ + 3);\ (becomes_) = DEREF_int (x548_ + 4);\ (destroyer_) (x548_, 5u);\ } /* Operations for field postinc of union EXP */ #define exp_postinc_tag 16u #define IS_exp_postinc(P) (CHECK_NULL (P)->ag_tag == 16) #define exp_postinc_ref(P) (CHECK_TAG ((P), 16) + 2) #define exp_postinc_value(P) (CHECK_TAG ((P), 16) + 3) #define exp_postinc_op(P) (CHECK_TAG ((P), 16) + 4) #define MAKE_exp_postinc(type_, ref_, value_, op_, c_class_exp)\ {\ c_class *x549_ = GEN_c_class ( 5, TYPEID_exp );\ x549_->ag_tag = 16;\ COPY_type (x549_ + 1, (type_));\ COPY_exp (x549_ + 2, (ref_));\ COPY_exp (x549_ + 3, (value_));\ COPY_exp (x549_ + 4, (op_));\ (c_class_exp) = x549_;\ } #define DECONS_exp_postinc(type_, ref_, value_, op_, c_class_exp)\ {\ c_class *x550_ = CHECK_TAG ((c_class_exp), 16);\ (type_) = DEREF_type (x550_ + 1);\ (ref_) = DEREF_exp (x550_ + 2);\ (value_) = DEREF_exp (x550_ + 3);\ (op_) = DEREF_exp (x550_ + 4);\ } #define DESTROY_exp_postinc(destroyer_, type_, ref_, value_, op_, c_class_exp)\ {\ c_class *x551_ = CHECK_TAG ((c_class_exp), 16);\ (type_) = DEREF_type (x551_ + 1);\ (ref_) = DEREF_exp (x551_ + 2);\ (value_) = DEREF_exp (x551_ + 3);\ (op_) = DEREF_exp (x551_ + 4);\ (destroyer_) (x551_, 5u);\ } /* Operations for field indir of union EXP */ #define exp_indir_tag 17u #define IS_exp_indir(P) (CHECK_NULL (P)->ag_tag == 17) #define exp_indir_ptr(P) (CHECK_TAG ((P), 17) + 2) #define exp_indir_index(P) (CHECK_TAG ((P), 17) + 3) #define MAKE_exp_indir(type_, ptr_, c_class_exp)\ {\ c_class *x552_ = GEN_c_class ( 4, TYPEID_exp );\ x552_->ag_tag = 17;\ COPY_type (x552_ + 1, (type_));\ COPY_exp (x552_ + 2, (ptr_));\ COPY_int (x552_ + 3, 0);\ (c_class_exp) = x552_;\ } #define DECONS_exp_indir(type_, ptr_, index_, c_class_exp)\ {\ c_class *x553_ = CHECK_TAG ((c_class_exp), 17);\ (type_) = DEREF_type (x553_ + 1);\ (ptr_) = DEREF_exp (x553_ + 2);\ (index_) = DEREF_int (x553_ + 3);\ } #define DESTROY_exp_indir(destroyer_, type_, ptr_, index_, c_class_exp)\ {\ c_class *x554_ = CHECK_TAG ((c_class_exp), 17);\ (type_) = DEREF_type (x554_ + 1);\ (ptr_) = DEREF_exp (x554_ + 2);\ (index_) = DEREF_int (x554_ + 3);\ (destroyer_) (x554_, 4u);\ } /* Operations for field contents of union EXP */ #define exp_contents_tag 18u #define IS_exp_contents(P) (CHECK_NULL (P)->ag_tag == 18) #define exp_contents_ptr(P) (CHECK_TAG ((P), 18) + 2) #define MAKE_exp_contents(type_, ptr_, c_class_exp)\ {\ c_class *x555_ = GEN_c_class ( 3, TYPEID_exp );\ x555_->ag_tag = 18;\ COPY_type (x555_ + 1, (type_));\ COPY_exp (x555_ + 2, (ptr_));\ (c_class_exp) = x555_;\ } #define DECONS_exp_contents(type_, ptr_, c_class_exp)\ {\ c_class *x556_ = CHECK_TAG ((c_class_exp), 18);\ (type_) = DEREF_type (x556_ + 1);\ (ptr_) = DEREF_exp (x556_ + 2);\ } #define DESTROY_exp_contents(destroyer_, type_, ptr_, c_class_exp)\ {\ c_class *x557_ = CHECK_TAG ((c_class_exp), 18);\ (type_) = DEREF_type (x557_ + 1);\ (ptr_) = DEREF_exp (x557_ + 2);\ (destroyer_) (x557_, 3u);\ } /* Operations for field address of union EXP */ #define exp_address_tag 19u #define IS_exp_address(P) (CHECK_NULL (P)->ag_tag == 19) #define exp_address_arg(P) (CHECK_TAG ((P), 19) + 2) #define MAKE_exp_address(type_, arg_, c_class_exp)\ {\ c_class *x558_ = GEN_c_class ( 3, TYPEID_exp );\ x558_->ag_tag = 19;\ COPY_type (x558_ + 1, (type_));\ COPY_exp (x558_ + 2, (arg_));\ (c_class_exp) = x558_;\ } #define DECONS_exp_address(type_, arg_, c_class_exp)\ {\ c_class *x559_ = CHECK_TAG ((c_class_exp), 19);\ (type_) = DEREF_type (x559_ + 1);\ (arg_) = DEREF_exp (x559_ + 2);\ } #define DESTROY_exp_address(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x560_ = CHECK_TAG ((c_class_exp), 19);\ (type_) = DEREF_type (x560_ + 1);\ (arg_) = DEREF_exp (x560_ + 2);\ (destroyer_) (x560_, 3u);\ } /* Operations for field address_mem of union EXP */ #define exp_address_mem_tag 20u #define IS_exp_address_mem(P) (CHECK_NULL (P)->ag_tag == 20) #define exp_address_mem_arg(P) (CHECK_TAG ((P), 20) + 2) #define exp_address_mem_paren(P) (CHECK_TAG ((P), 20) + 3) #define MAKE_exp_address_mem(type_, arg_, paren_, c_class_exp)\ {\ c_class *x561_ = GEN_c_class ( 4, TYPEID_exp );\ x561_->ag_tag = 20;\ COPY_type (x561_ + 1, (type_));\ COPY_exp (x561_ + 2, (arg_));\ COPY_int (x561_ + 3, (paren_));\ (c_class_exp) = x561_;\ } #define DECONS_exp_address_mem(type_, arg_, paren_, c_class_exp)\ {\ c_class *x562_ = CHECK_TAG ((c_class_exp), 20);\ (type_) = DEREF_type (x562_ + 1);\ (arg_) = DEREF_exp (x562_ + 2);\ (paren_) = DEREF_int (x562_ + 3);\ } #define DESTROY_exp_address_mem(destroyer_, type_, arg_, paren_, c_class_exp)\ {\ c_class *x563_ = CHECK_TAG ((c_class_exp), 20);\ (type_) = DEREF_type (x563_ + 1);\ (arg_) = DEREF_exp (x563_ + 2);\ (paren_) = DEREF_int (x563_ + 3);\ (destroyer_) (x563_, 4u);\ } /* Operations for field func of union EXP */ #define exp_func_tag 21u #define IS_exp_func(P) (CHECK_NULL (P)->ag_tag == 21) #define exp_func_fn(P) (CHECK_TAG ((P), 21) + 2) #define exp_func_args(P) (CHECK_TAG ((P), 21) + 3) #define exp_func_extra(P) (CHECK_TAG ((P), 21) + 4) #define MAKE_exp_func(type_, fn_, args_, c_class_exp)\ {\ c_class *x564_ = GEN_c_class ( 5, TYPEID_exp );\ x564_->ag_tag = 21;\ COPY_type (x564_ + 1, (type_));\ COPY_exp (x564_ + 2, (fn_));\ COPY_list (x564_ + 3, (args_));\ COPY_unsigned (x564_ + 4, 0);\ (c_class_exp) = x564_;\ } #define DECONS_exp_func(type_, fn_, args_, extra_, c_class_exp)\ {\ c_class *x565_ = CHECK_TAG ((c_class_exp), 21);\ (type_) = DEREF_type (x565_ + 1);\ (fn_) = DEREF_exp (x565_ + 2);\ (args_) = DEREF_list (x565_ + 3);\ (extra_) = DEREF_unsigned (x565_ + 4);\ } #define DESTROY_exp_func(destroyer_, type_, fn_, args_, extra_, c_class_exp)\ {\ c_class *x566_ = CHECK_TAG ((c_class_exp), 21);\ (type_) = DEREF_type (x566_ + 1);\ (fn_) = DEREF_exp (x566_ + 2);\ (args_) = DEREF_list (x566_ + 3);\ (extra_) = DEREF_unsigned (x566_ + 4);\ (destroyer_) (x566_, 5u);\ } /* Operations for field func_id of union EXP */ #define exp_func_id_tag 22u #define IS_exp_func_id(P) (CHECK_NULL (P)->ag_tag == 22) #define exp_func_id_id(P) (CHECK_TAG ((P), 22) + 2) #define exp_func_id_args(P) (CHECK_TAG ((P), 22) + 3) #define exp_func_id_virt(P) (CHECK_TAG ((P), 22) + 4) #define exp_func_id_extra(P) (CHECK_TAG ((P), 22) + 5) #define MAKE_exp_func_id(type_, id_, args_, virt_, c_class_exp)\ {\ c_class *x567_ = GEN_c_class ( 6, TYPEID_exp );\ x567_->ag_tag = 22;\ COPY_type (x567_ + 1, (type_));\ COPY_id (x567_ + 2, (id_));\ COPY_list (x567_ + 3, (args_));\ COPY_exp (x567_ + 4, (virt_));\ COPY_unsigned (x567_ + 5, 0);\ (c_class_exp) = x567_;\ } #define DECONS_exp_func_id(type_, id_, args_, virt_, extra_, c_class_exp)\ {\ c_class *x568_ = CHECK_TAG ((c_class_exp), 22);\ (type_) = DEREF_type (x568_ + 1);\ (id_) = DEREF_id (x568_ + 2);\ (args_) = DEREF_list (x568_ + 3);\ (virt_) = DEREF_exp (x568_ + 4);\ (extra_) = DEREF_unsigned (x568_ + 5);\ } #define DESTROY_exp_func_id(destroyer_, type_, id_, args_, virt_, extra_, c_class_exp)\ {\ c_class *x569_ = CHECK_TAG ((c_class_exp), 22);\ (type_) = DEREF_type (x569_ + 1);\ (id_) = DEREF_id (x569_ + 2);\ (args_) = DEREF_list (x569_ + 3);\ (virt_) = DEREF_exp (x569_ + 4);\ (extra_) = DEREF_unsigned (x569_ + 5);\ (destroyer_) (x569_, 6u);\ } /* Operations for field call of union EXP */ #define exp_call_tag 23u #define IS_exp_call(P) (CHECK_NULL (P)->ag_tag == 23) #define exp_call_ptr(P) (CHECK_TAG ((P), 23) + 2) #define exp_call_arg(P) (CHECK_TAG ((P), 23) + 3) #define exp_call_base(P) (CHECK_TAG ((P), 23) + 4) #define MAKE_exp_call(type_, ptr_, arg_, base_, c_class_exp)\ {\ c_class *x570_ = GEN_c_class ( 5, TYPEID_exp );\ x570_->ag_tag = 23;\ COPY_type (x570_ + 1, (type_));\ COPY_exp (x570_ + 2, (ptr_));\ COPY_exp (x570_ + 3, (arg_));\ COPY_graph (x570_ + 4, (base_));\ (c_class_exp) = x570_;\ } #define DECONS_exp_call(type_, ptr_, arg_, base_, c_class_exp)\ {\ c_class *x571_ = CHECK_TAG ((c_class_exp), 23);\ (type_) = DEREF_type (x571_ + 1);\ (ptr_) = DEREF_exp (x571_ + 2);\ (arg_) = DEREF_exp (x571_ + 3);\ (base_) = DEREF_graph (x571_ + 4);\ } #define DESTROY_exp_call(destroyer_, type_, ptr_, arg_, base_, c_class_exp)\ {\ c_class *x572_ = CHECK_TAG ((c_class_exp), 23);\ (type_) = DEREF_type (x572_ + 1);\ (ptr_) = DEREF_exp (x572_ + 2);\ (arg_) = DEREF_exp (x572_ + 3);\ (base_) = DEREF_graph (x572_ + 4);\ (destroyer_) (x572_, 5u);\ } /* Operations for field set negate_etc of union EXP */ #define exp_negate_etc_tag 28u #define IS_exp_negate_etc(P) ((unsigned) (CHECK_NULL (P)->ag_tag - 24) < 4u) #define exp_negate_etc_arg(P) (CHECK_TAG_ETC ((P), 24, 28) + 2) #define MAKE_exp_negate_etc(tag, type_, arg_, c_class_exp)\ {\ c_class *x573_ = GEN_c_class ( 3, TYPEID_exp );\ x573_->ag_tag = (tag);\ COPY_type (x573_ + 1, (type_));\ COPY_exp (x573_ + 2, (arg_));\ (c_class_exp) = CHECK_TAG_ETC (x573_, 24, 28);\ } #define MODIFY_exp_negate_etc(tag, c_class_exp)\ {\ c_class *x574_ = CHECK_TAG_ETC ((c_class_exp), 24, 28);\ x574_->ag_tag = (tag);\ (void) CHECK_TAG_ETC (x574_, 24, 28);\ } #define DECONS_exp_negate_etc(type_, arg_, c_class_exp)\ {\ c_class *x575_ = CHECK_TAG_ETC ((c_class_exp), 24, 28);\ (type_) = DEREF_type (x575_ + 1);\ (arg_) = DEREF_exp (x575_ + 2);\ } #define DESTROY_exp_negate_etc(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x576_ = CHECK_TAG_ETC ((c_class_exp), 24, 28);\ (type_) = DEREF_type (x576_ + 1);\ (arg_) = DEREF_exp (x576_ + 2);\ (destroyer_) (x576_, 3u);\ } /* Operations for field negate of union EXP */ #define exp_negate_tag 24u #define IS_exp_negate(P) (CHECK_NULL (P)->ag_tag == 24) #define exp_negate_arg(P) (CHECK_TAG ((P), 24) + 2) #define MAKE_exp_negate(type_, arg_, c_class_exp)\ {\ c_class *x577_ = GEN_c_class ( 3, TYPEID_exp );\ x577_->ag_tag = 24;\ COPY_type (x577_ + 1, (type_));\ COPY_exp (x577_ + 2, (arg_));\ (c_class_exp) = x577_;\ } #define DECONS_exp_negate(type_, arg_, c_class_exp)\ {\ c_class *x578_ = CHECK_TAG ((c_class_exp), 24);\ (type_) = DEREF_type (x578_ + 1);\ (arg_) = DEREF_exp (x578_ + 2);\ } #define DESTROY_exp_negate(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x579_ = CHECK_TAG ((c_class_exp), 24);\ (type_) = DEREF_type (x579_ + 1);\ (arg_) = DEREF_exp (x579_ + 2);\ (destroyer_) (x579_, 3u);\ } /* Operations for field compl of union EXP */ #define exp_compl_tag 25u #define IS_exp_compl(P) (CHECK_NULL (P)->ag_tag == 25) #define exp_compl_arg(P) (CHECK_TAG ((P), 25) + 2) #define MAKE_exp_compl(type_, arg_, c_class_exp)\ {\ c_class *x580_ = GEN_c_class ( 3, TYPEID_exp );\ x580_->ag_tag = 25;\ COPY_type (x580_ + 1, (type_));\ COPY_exp (x580_ + 2, (arg_));\ (c_class_exp) = x580_;\ } #define DECONS_exp_compl(type_, arg_, c_class_exp)\ {\ c_class *x581_ = CHECK_TAG ((c_class_exp), 25);\ (type_) = DEREF_type (x581_ + 1);\ (arg_) = DEREF_exp (x581_ + 2);\ } #define DESTROY_exp_compl(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x582_ = CHECK_TAG ((c_class_exp), 25);\ (type_) = DEREF_type (x582_ + 1);\ (arg_) = DEREF_exp (x582_ + 2);\ (destroyer_) (x582_, 3u);\ } /* Operations for field not of union EXP */ #define exp_not_tag 26u #define IS_exp_not(P) (CHECK_NULL (P)->ag_tag == 26) #define exp_not_arg(P) (CHECK_TAG ((P), 26) + 2) #define MAKE_exp_not(type_, arg_, c_class_exp)\ {\ c_class *x583_ = GEN_c_class ( 3, TYPEID_exp );\ x583_->ag_tag = 26;\ COPY_type (x583_ + 1, (type_));\ COPY_exp (x583_ + 2, (arg_));\ (c_class_exp) = x583_;\ } #define DECONS_exp_not(type_, arg_, c_class_exp)\ {\ c_class *x584_ = CHECK_TAG ((c_class_exp), 26);\ (type_) = DEREF_type (x584_ + 1);\ (arg_) = DEREF_exp (x584_ + 2);\ } #define DESTROY_exp_not(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x585_ = CHECK_TAG ((c_class_exp), 26);\ (type_) = DEREF_type (x585_ + 1);\ (arg_) = DEREF_exp (x585_ + 2);\ (destroyer_) (x585_, 3u);\ } /* Operations for field abs of union EXP */ #define exp_abs_tag 27u #define IS_exp_abs(P) (CHECK_NULL (P)->ag_tag == 27) #define exp_abs_arg(P) (CHECK_TAG ((P), 27) + 2) #define MAKE_exp_abs(type_, arg_, c_class_exp)\ {\ c_class *x586_ = GEN_c_class ( 3, TYPEID_exp );\ x586_->ag_tag = 27;\ COPY_type (x586_ + 1, (type_));\ COPY_exp (x586_ + 2, (arg_));\ (c_class_exp) = x586_;\ } #define DECONS_exp_abs(type_, arg_, c_class_exp)\ {\ c_class *x587_ = CHECK_TAG ((c_class_exp), 27);\ (type_) = DEREF_type (x587_ + 1);\ (arg_) = DEREF_exp (x587_ + 2);\ } #define DESTROY_exp_abs(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x588_ = CHECK_TAG ((c_class_exp), 27);\ (type_) = DEREF_type (x588_ + 1);\ (arg_) = DEREF_exp (x588_ + 2);\ (destroyer_) (x588_, 3u);\ } /* Operations for field set plus_etc of union EXP */ #define exp_plus_etc_tag 42u #define IS_exp_plus_etc(P) ((unsigned) (CHECK_NULL (P)->ag_tag - 28) < 14u) #define exp_plus_etc_arg1(P) (CHECK_TAG_ETC ((P), 28, 42) + 2) #define exp_plus_etc_arg2(P) (CHECK_TAG_ETC ((P), 28, 42) + 3) #define MAKE_exp_plus_etc(tag, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x589_ = GEN_c_class ( 4, TYPEID_exp );\ x589_->ag_tag = (tag);\ COPY_type (x589_ + 1, (type_));\ COPY_exp (x589_ + 2, (arg1_));\ COPY_exp (x589_ + 3, (arg2_));\ (c_class_exp) = CHECK_TAG_ETC (x589_, 28, 42);\ } #define MODIFY_exp_plus_etc(tag, c_class_exp)\ {\ c_class *x590_ = CHECK_TAG_ETC ((c_class_exp), 28, 42);\ x590_->ag_tag = (tag);\ (void) CHECK_TAG_ETC (x590_, 28, 42);\ } #define DECONS_exp_plus_etc(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x591_ = CHECK_TAG_ETC ((c_class_exp), 28, 42);\ (type_) = DEREF_type (x591_ + 1);\ (arg1_) = DEREF_exp (x591_ + 2);\ (arg2_) = DEREF_exp (x591_ + 3);\ } #define DESTROY_exp_plus_etc(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x592_ = CHECK_TAG_ETC ((c_class_exp), 28, 42);\ (type_) = DEREF_type (x592_ + 1);\ (arg1_) = DEREF_exp (x592_ + 2);\ (arg2_) = DEREF_exp (x592_ + 3);\ (destroyer_) (x592_, 4u);\ } /* Operations for field plus of union EXP */ #define exp_plus_tag 28u #define IS_exp_plus(P) (CHECK_NULL (P)->ag_tag == 28) #define exp_plus_arg1(P) (CHECK_TAG ((P), 28) + 2) #define exp_plus_arg2(P) (CHECK_TAG ((P), 28) + 3) #define MAKE_exp_plus(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x593_ = GEN_c_class ( 4, TYPEID_exp );\ x593_->ag_tag = 28;\ COPY_type (x593_ + 1, (type_));\ COPY_exp (x593_ + 2, (arg1_));\ COPY_exp (x593_ + 3, (arg2_));\ (c_class_exp) = x593_;\ } #define DECONS_exp_plus(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x594_ = CHECK_TAG ((c_class_exp), 28);\ (type_) = DEREF_type (x594_ + 1);\ (arg1_) = DEREF_exp (x594_ + 2);\ (arg2_) = DEREF_exp (x594_ + 3);\ } #define DESTROY_exp_plus(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x595_ = CHECK_TAG ((c_class_exp), 28);\ (type_) = DEREF_type (x595_ + 1);\ (arg1_) = DEREF_exp (x595_ + 2);\ (arg2_) = DEREF_exp (x595_ + 3);\ (destroyer_) (x595_, 4u);\ } /* Operations for field minus of union EXP */ #define exp_minus_tag 29u #define IS_exp_minus(P) (CHECK_NULL (P)->ag_tag == 29) #define exp_minus_arg1(P) (CHECK_TAG ((P), 29) + 2) #define exp_minus_arg2(P) (CHECK_TAG ((P), 29) + 3) #define MAKE_exp_minus(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x596_ = GEN_c_class ( 4, TYPEID_exp );\ x596_->ag_tag = 29;\ COPY_type (x596_ + 1, (type_));\ COPY_exp (x596_ + 2, (arg1_));\ COPY_exp (x596_ + 3, (arg2_));\ (c_class_exp) = x596_;\ } #define DECONS_exp_minus(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x597_ = CHECK_TAG ((c_class_exp), 29);\ (type_) = DEREF_type (x597_ + 1);\ (arg1_) = DEREF_exp (x597_ + 2);\ (arg2_) = DEREF_exp (x597_ + 3);\ } #define DESTROY_exp_minus(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x598_ = CHECK_TAG ((c_class_exp), 29);\ (type_) = DEREF_type (x598_ + 1);\ (arg1_) = DEREF_exp (x598_ + 2);\ (arg2_) = DEREF_exp (x598_ + 3);\ (destroyer_) (x598_, 4u);\ } /* Operations for field mult of union EXP */ #define exp_mult_tag 30u #define IS_exp_mult(P) (CHECK_NULL (P)->ag_tag == 30) #define exp_mult_arg1(P) (CHECK_TAG ((P), 30) + 2) #define exp_mult_arg2(P) (CHECK_TAG ((P), 30) + 3) #define MAKE_exp_mult(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x599_ = GEN_c_class ( 4, TYPEID_exp );\ x599_->ag_tag = 30;\ COPY_type (x599_ + 1, (type_));\ COPY_exp (x599_ + 2, (arg1_));\ COPY_exp (x599_ + 3, (arg2_));\ (c_class_exp) = x599_;\ } #define DECONS_exp_mult(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x600_ = CHECK_TAG ((c_class_exp), 30);\ (type_) = DEREF_type (x600_ + 1);\ (arg1_) = DEREF_exp (x600_ + 2);\ (arg2_) = DEREF_exp (x600_ + 3);\ } #define DESTROY_exp_mult(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x601_ = CHECK_TAG ((c_class_exp), 30);\ (type_) = DEREF_type (x601_ + 1);\ (arg1_) = DEREF_exp (x601_ + 2);\ (arg2_) = DEREF_exp (x601_ + 3);\ (destroyer_) (x601_, 4u);\ } /* Operations for field div of union EXP */ #define exp_div_tag 31u #define IS_exp_div(P) (CHECK_NULL (P)->ag_tag == 31) #define exp_div_arg1(P) (CHECK_TAG ((P), 31) + 2) #define exp_div_arg2(P) (CHECK_TAG ((P), 31) + 3) #define MAKE_exp_div(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x602_ = GEN_c_class ( 4, TYPEID_exp );\ x602_->ag_tag = 31;\ COPY_type (x602_ + 1, (type_));\ COPY_exp (x602_ + 2, (arg1_));\ COPY_exp (x602_ + 3, (arg2_));\ (c_class_exp) = x602_;\ } #define DECONS_exp_div(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x603_ = CHECK_TAG ((c_class_exp), 31);\ (type_) = DEREF_type (x603_ + 1);\ (arg1_) = DEREF_exp (x603_ + 2);\ (arg2_) = DEREF_exp (x603_ + 3);\ } #define DESTROY_exp_div(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x604_ = CHECK_TAG ((c_class_exp), 31);\ (type_) = DEREF_type (x604_ + 1);\ (arg1_) = DEREF_exp (x604_ + 2);\ (arg2_) = DEREF_exp (x604_ + 3);\ (destroyer_) (x604_, 4u);\ } /* Operations for field rem of union EXP */ #define exp_rem_tag 32u #define IS_exp_rem(P) (CHECK_NULL (P)->ag_tag == 32) #define exp_rem_arg1(P) (CHECK_TAG ((P), 32) + 2) #define exp_rem_arg2(P) (CHECK_TAG ((P), 32) + 3) #define MAKE_exp_rem(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x605_ = GEN_c_class ( 4, TYPEID_exp );\ x605_->ag_tag = 32;\ COPY_type (x605_ + 1, (type_));\ COPY_exp (x605_ + 2, (arg1_));\ COPY_exp (x605_ + 3, (arg2_));\ (c_class_exp) = x605_;\ } #define DECONS_exp_rem(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x606_ = CHECK_TAG ((c_class_exp), 32);\ (type_) = DEREF_type (x606_ + 1);\ (arg1_) = DEREF_exp (x606_ + 2);\ (arg2_) = DEREF_exp (x606_ + 3);\ } #define DESTROY_exp_rem(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x607_ = CHECK_TAG ((c_class_exp), 32);\ (type_) = DEREF_type (x607_ + 1);\ (arg1_) = DEREF_exp (x607_ + 2);\ (arg2_) = DEREF_exp (x607_ + 3);\ (destroyer_) (x607_, 4u);\ } /* Operations for field and of union EXP */ #define exp_and_tag 33u #define IS_exp_and(P) (CHECK_NULL (P)->ag_tag == 33) #define exp_and_arg1(P) (CHECK_TAG ((P), 33) + 2) #define exp_and_arg2(P) (CHECK_TAG ((P), 33) + 3) #define MAKE_exp_and(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x608_ = GEN_c_class ( 4, TYPEID_exp );\ x608_->ag_tag = 33;\ COPY_type (x608_ + 1, (type_));\ COPY_exp (x608_ + 2, (arg1_));\ COPY_exp (x608_ + 3, (arg2_));\ (c_class_exp) = x608_;\ } #define DECONS_exp_and(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x609_ = CHECK_TAG ((c_class_exp), 33);\ (type_) = DEREF_type (x609_ + 1);\ (arg1_) = DEREF_exp (x609_ + 2);\ (arg2_) = DEREF_exp (x609_ + 3);\ } #define DESTROY_exp_and(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x610_ = CHECK_TAG ((c_class_exp), 33);\ (type_) = DEREF_type (x610_ + 1);\ (arg1_) = DEREF_exp (x610_ + 2);\ (arg2_) = DEREF_exp (x610_ + 3);\ (destroyer_) (x610_, 4u);\ } /* Operations for field or of union EXP */ #define exp_or_tag 34u #define IS_exp_or(P) (CHECK_NULL (P)->ag_tag == 34) #define exp_or_arg1(P) (CHECK_TAG ((P), 34) + 2) #define exp_or_arg2(P) (CHECK_TAG ((P), 34) + 3) #define MAKE_exp_or(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x611_ = GEN_c_class ( 4, TYPEID_exp );\ x611_->ag_tag = 34;\ COPY_type (x611_ + 1, (type_));\ COPY_exp (x611_ + 2, (arg1_));\ COPY_exp (x611_ + 3, (arg2_));\ (c_class_exp) = x611_;\ } #define DECONS_exp_or(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x612_ = CHECK_TAG ((c_class_exp), 34);\ (type_) = DEREF_type (x612_ + 1);\ (arg1_) = DEREF_exp (x612_ + 2);\ (arg2_) = DEREF_exp (x612_ + 3);\ } #define DESTROY_exp_or(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x613_ = CHECK_TAG ((c_class_exp), 34);\ (type_) = DEREF_type (x613_ + 1);\ (arg1_) = DEREF_exp (x613_ + 2);\ (arg2_) = DEREF_exp (x613_ + 3);\ (destroyer_) (x613_, 4u);\ } /* Operations for field xor of union EXP */ #define exp_xor_tag 35u #define IS_exp_xor(P) (CHECK_NULL (P)->ag_tag == 35) #define exp_xor_arg1(P) (CHECK_TAG ((P), 35) + 2) #define exp_xor_arg2(P) (CHECK_TAG ((P), 35) + 3) #define MAKE_exp_xor(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x614_ = GEN_c_class ( 4, TYPEID_exp );\ x614_->ag_tag = 35;\ COPY_type (x614_ + 1, (type_));\ COPY_exp (x614_ + 2, (arg1_));\ COPY_exp (x614_ + 3, (arg2_));\ (c_class_exp) = x614_;\ } #define DECONS_exp_xor(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x615_ = CHECK_TAG ((c_class_exp), 35);\ (type_) = DEREF_type (x615_ + 1);\ (arg1_) = DEREF_exp (x615_ + 2);\ (arg2_) = DEREF_exp (x615_ + 3);\ } #define DESTROY_exp_xor(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x616_ = CHECK_TAG ((c_class_exp), 35);\ (type_) = DEREF_type (x616_ + 1);\ (arg1_) = DEREF_exp (x616_ + 2);\ (arg2_) = DEREF_exp (x616_ + 3);\ (destroyer_) (x616_, 4u);\ } /* Operations for field log_and of union EXP */ #define exp_log_and_tag 36u #define IS_exp_log_and(P) (CHECK_NULL (P)->ag_tag == 36) #define exp_log_and_arg1(P) (CHECK_TAG ((P), 36) + 2) #define exp_log_and_arg2(P) (CHECK_TAG ((P), 36) + 3) #define MAKE_exp_log_and(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x617_ = GEN_c_class ( 4, TYPEID_exp );\ x617_->ag_tag = 36;\ COPY_type (x617_ + 1, (type_));\ COPY_exp (x617_ + 2, (arg1_));\ COPY_exp (x617_ + 3, (arg2_));\ (c_class_exp) = x617_;\ } #define DECONS_exp_log_and(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x618_ = CHECK_TAG ((c_class_exp), 36);\ (type_) = DEREF_type (x618_ + 1);\ (arg1_) = DEREF_exp (x618_ + 2);\ (arg2_) = DEREF_exp (x618_ + 3);\ } #define DESTROY_exp_log_and(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x619_ = CHECK_TAG ((c_class_exp), 36);\ (type_) = DEREF_type (x619_ + 1);\ (arg1_) = DEREF_exp (x619_ + 2);\ (arg2_) = DEREF_exp (x619_ + 3);\ (destroyer_) (x619_, 4u);\ } /* Operations for field log_or of union EXP */ #define exp_log_or_tag 37u #define IS_exp_log_or(P) (CHECK_NULL (P)->ag_tag == 37) #define exp_log_or_arg1(P) (CHECK_TAG ((P), 37) + 2) #define exp_log_or_arg2(P) (CHECK_TAG ((P), 37) + 3) #define MAKE_exp_log_or(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x620_ = GEN_c_class ( 4, TYPEID_exp );\ x620_->ag_tag = 37;\ COPY_type (x620_ + 1, (type_));\ COPY_exp (x620_ + 2, (arg1_));\ COPY_exp (x620_ + 3, (arg2_));\ (c_class_exp) = x620_;\ } #define DECONS_exp_log_or(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x621_ = CHECK_TAG ((c_class_exp), 37);\ (type_) = DEREF_type (x621_ + 1);\ (arg1_) = DEREF_exp (x621_ + 2);\ (arg2_) = DEREF_exp (x621_ + 3);\ } #define DESTROY_exp_log_or(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x622_ = CHECK_TAG ((c_class_exp), 37);\ (type_) = DEREF_type (x622_ + 1);\ (arg1_) = DEREF_exp (x622_ + 2);\ (arg2_) = DEREF_exp (x622_ + 3);\ (destroyer_) (x622_, 4u);\ } /* Operations for field lshift of union EXP */ #define exp_lshift_tag 38u #define IS_exp_lshift(P) (CHECK_NULL (P)->ag_tag == 38) #define exp_lshift_arg1(P) (CHECK_TAG ((P), 38) + 2) #define exp_lshift_arg2(P) (CHECK_TAG ((P), 38) + 3) #define MAKE_exp_lshift(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x623_ = GEN_c_class ( 4, TYPEID_exp );\ x623_->ag_tag = 38;\ COPY_type (x623_ + 1, (type_));\ COPY_exp (x623_ + 2, (arg1_));\ COPY_exp (x623_ + 3, (arg2_));\ (c_class_exp) = x623_;\ } #define DECONS_exp_lshift(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x624_ = CHECK_TAG ((c_class_exp), 38);\ (type_) = DEREF_type (x624_ + 1);\ (arg1_) = DEREF_exp (x624_ + 2);\ (arg2_) = DEREF_exp (x624_ + 3);\ } #define DESTROY_exp_lshift(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x625_ = CHECK_TAG ((c_class_exp), 38);\ (type_) = DEREF_type (x625_ + 1);\ (arg1_) = DEREF_exp (x625_ + 2);\ (arg2_) = DEREF_exp (x625_ + 3);\ (destroyer_) (x625_, 4u);\ } /* Operations for field rshift of union EXP */ #define exp_rshift_tag 39u #define IS_exp_rshift(P) (CHECK_NULL (P)->ag_tag == 39) #define exp_rshift_arg1(P) (CHECK_TAG ((P), 39) + 2) #define exp_rshift_arg2(P) (CHECK_TAG ((P), 39) + 3) #define MAKE_exp_rshift(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x626_ = GEN_c_class ( 4, TYPEID_exp );\ x626_->ag_tag = 39;\ COPY_type (x626_ + 1, (type_));\ COPY_exp (x626_ + 2, (arg1_));\ COPY_exp (x626_ + 3, (arg2_));\ (c_class_exp) = x626_;\ } #define DECONS_exp_rshift(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x627_ = CHECK_TAG ((c_class_exp), 39);\ (type_) = DEREF_type (x627_ + 1);\ (arg1_) = DEREF_exp (x627_ + 2);\ (arg2_) = DEREF_exp (x627_ + 3);\ } #define DESTROY_exp_rshift(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x628_ = CHECK_TAG ((c_class_exp), 39);\ (type_) = DEREF_type (x628_ + 1);\ (arg1_) = DEREF_exp (x628_ + 2);\ (arg2_) = DEREF_exp (x628_ + 3);\ (destroyer_) (x628_, 4u);\ } /* Operations for field max of union EXP */ #define exp_max_tag 40u #define IS_exp_max(P) (CHECK_NULL (P)->ag_tag == 40) #define exp_max_arg1(P) (CHECK_TAG ((P), 40) + 2) #define exp_max_arg2(P) (CHECK_TAG ((P), 40) + 3) #define MAKE_exp_max(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x629_ = GEN_c_class ( 4, TYPEID_exp );\ x629_->ag_tag = 40;\ COPY_type (x629_ + 1, (type_));\ COPY_exp (x629_ + 2, (arg1_));\ COPY_exp (x629_ + 3, (arg2_));\ (c_class_exp) = x629_;\ } #define DECONS_exp_max(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x630_ = CHECK_TAG ((c_class_exp), 40);\ (type_) = DEREF_type (x630_ + 1);\ (arg1_) = DEREF_exp (x630_ + 2);\ (arg2_) = DEREF_exp (x630_ + 3);\ } #define DESTROY_exp_max(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x631_ = CHECK_TAG ((c_class_exp), 40);\ (type_) = DEREF_type (x631_ + 1);\ (arg1_) = DEREF_exp (x631_ + 2);\ (arg2_) = DEREF_exp (x631_ + 3);\ (destroyer_) (x631_, 4u);\ } /* Operations for field min of union EXP */ #define exp_min_tag 41u #define IS_exp_min(P) (CHECK_NULL (P)->ag_tag == 41) #define exp_min_arg1(P) (CHECK_TAG ((P), 41) + 2) #define exp_min_arg2(P) (CHECK_TAG ((P), 41) + 3) #define MAKE_exp_min(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x632_ = GEN_c_class ( 4, TYPEID_exp );\ x632_->ag_tag = 41;\ COPY_type (x632_ + 1, (type_));\ COPY_exp (x632_ + 2, (arg1_));\ COPY_exp (x632_ + 3, (arg2_));\ (c_class_exp) = x632_;\ } #define DECONS_exp_min(type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x633_ = CHECK_TAG ((c_class_exp), 41);\ (type_) = DEREF_type (x633_ + 1);\ (arg1_) = DEREF_exp (x633_ + 2);\ (arg2_) = DEREF_exp (x633_ + 3);\ } #define DESTROY_exp_min(destroyer_, type_, arg1_, arg2_, c_class_exp)\ {\ c_class *x634_ = CHECK_TAG ((c_class_exp), 41);\ (type_) = DEREF_type (x634_ + 1);\ (arg1_) = DEREF_exp (x634_ + 2);\ (arg2_) = DEREF_exp (x634_ + 3);\ (destroyer_) (x634_, 4u);\ } /* Operations for field test of union EXP */ #define exp_test_tag 42u #define IS_exp_test(P) (CHECK_NULL (P)->ag_tag == 42) #define exp_test_tst(P) (CHECK_TAG ((P), 42) + 2) #define exp_test_arg(P) (CHECK_TAG ((P), 42) + 3) #define MAKE_exp_test(type_, tst_, arg_, c_class_exp)\ {\ c_class *x635_ = GEN_c_class ( 4, TYPEID_exp );\ x635_->ag_tag = 42;\ COPY_type (x635_ + 1, (type_));\ COPY_ntest (x635_ + 2, (tst_));\ COPY_exp (x635_ + 3, (arg_));\ (c_class_exp) = x635_;\ } #define DECONS_exp_test(type_, tst_, arg_, c_class_exp)\ {\ c_class *x636_ = CHECK_TAG ((c_class_exp), 42);\ (type_) = DEREF_type (x636_ + 1);\ (tst_) = DEREF_ntest (x636_ + 2);\ (arg_) = DEREF_exp (x636_ + 3);\ } #define DESTROY_exp_test(destroyer_, type_, tst_, arg_, c_class_exp)\ {\ c_class *x637_ = CHECK_TAG ((c_class_exp), 42);\ (type_) = DEREF_type (x637_ + 1);\ (tst_) = DEREF_ntest (x637_ + 2);\ (arg_) = DEREF_exp (x637_ + 3);\ (destroyer_) (x637_, 4u);\ } /* Operations for field compare of union EXP */ #define exp_compare_tag 43u #define IS_exp_compare(P) (CHECK_NULL (P)->ag_tag == 43) #define exp_compare_tst(P) (CHECK_TAG ((P), 43) + 2) #define exp_compare_arg1(P) (CHECK_TAG ((P), 43) + 3) #define exp_compare_arg2(P) (CHECK_TAG ((P), 43) + 4) #define MAKE_exp_compare(type_, tst_, arg1_, arg2_, c_class_exp)\ {\ c_class *x638_ = GEN_c_class ( 5, TYPEID_exp );\ x638_->ag_tag = 43;\ COPY_type (x638_ + 1, (type_));\ COPY_ntest (x638_ + 2, (tst_));\ COPY_exp (x638_ + 3, (arg1_));\ COPY_exp (x638_ + 4, (arg2_));\ (c_class_exp) = x638_;\ } #define DECONS_exp_compare(type_, tst_, arg1_, arg2_, c_class_exp)\ {\ c_class *x639_ = CHECK_TAG ((c_class_exp), 43);\ (type_) = DEREF_type (x639_ + 1);\ (tst_) = DEREF_ntest (x639_ + 2);\ (arg1_) = DEREF_exp (x639_ + 3);\ (arg2_) = DEREF_exp (x639_ + 4);\ } #define DESTROY_exp_compare(destroyer_, type_, tst_, arg1_, arg2_, c_class_exp)\ {\ c_class *x640_ = CHECK_TAG ((c_class_exp), 43);\ (type_) = DEREF_type (x640_ + 1);\ (tst_) = DEREF_ntest (x640_ + 2);\ (arg1_) = DEREF_exp (x640_ + 3);\ (arg2_) = DEREF_exp (x640_ + 4);\ (destroyer_) (x640_, 5u);\ } /* Operations for field cast of union EXP */ #define exp_cast_tag 44u #define IS_exp_cast(P) (CHECK_NULL (P)->ag_tag == 44) #define exp_cast_conv(P) (CHECK_TAG ((P), 44) + 2) #define exp_cast_arg(P) (CHECK_TAG ((P), 44) + 3) #define MAKE_exp_cast(type_, conv_, arg_, c_class_exp)\ {\ c_class *x641_ = GEN_c_class ( 4, TYPEID_exp );\ x641_->ag_tag = 44;\ COPY_type (x641_ + 1, (type_));\ COPY_unsigned (x641_ + 2, (conv_));\ COPY_exp (x641_ + 3, (arg_));\ (c_class_exp) = x641_;\ } #define DECONS_exp_cast(type_, conv_, arg_, c_class_exp)\ {\ c_class *x642_ = CHECK_TAG ((c_class_exp), 44);\ (type_) = DEREF_type (x642_ + 1);\ (conv_) = DEREF_unsigned (x642_ + 2);\ (arg_) = DEREF_exp (x642_ + 3);\ } #define DESTROY_exp_cast(destroyer_, type_, conv_, arg_, c_class_exp)\ {\ c_class *x643_ = CHECK_TAG ((c_class_exp), 44);\ (type_) = DEREF_type (x643_ + 1);\ (conv_) = DEREF_unsigned (x643_ + 2);\ (arg_) = DEREF_exp (x643_ + 3);\ (destroyer_) (x643_, 4u);\ } /* Operations for field base_cast of union EXP */ #define exp_base_cast_tag 45u #define IS_exp_base_cast(P) (CHECK_NULL (P)->ag_tag == 45) #define exp_base_cast_conv(P) (CHECK_TAG ((P), 45) + 2) #define exp_base_cast_arg(P) (CHECK_TAG ((P), 45) + 3) #define exp_base_cast_off(P) (CHECK_TAG ((P), 45) + 4) #define MAKE_exp_base_cast(type_, conv_, arg_, off_, c_class_exp)\ {\ c_class *x644_ = GEN_c_class ( 5, TYPEID_exp );\ x644_->ag_tag = 45;\ COPY_type (x644_ + 1, (type_));\ COPY_unsigned (x644_ + 2, (conv_));\ COPY_exp (x644_ + 3, (arg_));\ COPY_off (x644_ + 4, (off_));\ (c_class_exp) = x644_;\ } #define DECONS_exp_base_cast(type_, conv_, arg_, off_, c_class_exp)\ {\ c_class *x645_ = CHECK_TAG ((c_class_exp), 45);\ (type_) = DEREF_type (x645_ + 1);\ (conv_) = DEREF_unsigned (x645_ + 2);\ (arg_) = DEREF_exp (x645_ + 3);\ (off_) = DEREF_off (x645_ + 4);\ } #define DESTROY_exp_base_cast(destroyer_, type_, conv_, arg_, off_, c_class_exp)\ {\ c_class *x646_ = CHECK_TAG ((c_class_exp), 45);\ (type_) = DEREF_type (x646_ + 1);\ (conv_) = DEREF_unsigned (x646_ + 2);\ (arg_) = DEREF_exp (x646_ + 3);\ (off_) = DEREF_off (x646_ + 4);\ (destroyer_) (x646_, 5u);\ } /* Operations for field dyn_cast of union EXP */ #define exp_dyn_cast_tag 46u #define IS_exp_dyn_cast(P) (CHECK_NULL (P)->ag_tag == 46) #define exp_dyn_cast_arg(P) (CHECK_TAG ((P), 46) + 2) #define exp_dyn_cast_except(P) (CHECK_TAG ((P), 46) + 3) #define MAKE_exp_dyn_cast(type_, arg_, except_, c_class_exp)\ {\ c_class *x647_ = GEN_c_class ( 4, TYPEID_exp );\ x647_->ag_tag = 46;\ COPY_type (x647_ + 1, (type_));\ COPY_exp (x647_ + 2, (arg_));\ COPY_exp (x647_ + 3, (except_));\ (c_class_exp) = x647_;\ } #define DECONS_exp_dyn_cast(type_, arg_, except_, c_class_exp)\ {\ c_class *x648_ = CHECK_TAG ((c_class_exp), 46);\ (type_) = DEREF_type (x648_ + 1);\ (arg_) = DEREF_exp (x648_ + 2);\ (except_) = DEREF_exp (x648_ + 3);\ } #define DESTROY_exp_dyn_cast(destroyer_, type_, arg_, except_, c_class_exp)\ {\ c_class *x649_ = CHECK_TAG ((c_class_exp), 46);\ (type_) = DEREF_type (x649_ + 1);\ (arg_) = DEREF_exp (x649_ + 2);\ (except_) = DEREF_exp (x649_ + 3);\ (destroyer_) (x649_, 4u);\ } /* Operations for field add_ptr of union EXP */ #define exp_add_ptr_tag 47u #define IS_exp_add_ptr(P) (CHECK_NULL (P)->ag_tag == 47) #define exp_add_ptr_ptr(P) (CHECK_TAG ((P), 47) + 2) #define exp_add_ptr_off(P) (CHECK_TAG ((P), 47) + 3) #define exp_add_ptr_virt(P) (CHECK_TAG ((P), 47) + 4) #define MAKE_exp_add_ptr(type_, ptr_, off_, virt_, c_class_exp)\ {\ c_class *x650_ = GEN_c_class ( 5, TYPEID_exp );\ x650_->ag_tag = 47;\ COPY_type (x650_ + 1, (type_));\ COPY_exp (x650_ + 2, (ptr_));\ COPY_off (x650_ + 3, (off_));\ COPY_int (x650_ + 4, (virt_));\ (c_class_exp) = x650_;\ } #define DECONS_exp_add_ptr(type_, ptr_, off_, virt_, c_class_exp)\ {\ c_class *x651_ = CHECK_TAG ((c_class_exp), 47);\ (type_) = DEREF_type (x651_ + 1);\ (ptr_) = DEREF_exp (x651_ + 2);\ (off_) = DEREF_off (x651_ + 3);\ (virt_) = DEREF_int (x651_ + 4);\ } #define DESTROY_exp_add_ptr(destroyer_, type_, ptr_, off_, virt_, c_class_exp)\ {\ c_class *x652_ = CHECK_TAG ((c_class_exp), 47);\ (type_) = DEREF_type (x652_ + 1);\ (ptr_) = DEREF_exp (x652_ + 2);\ (off_) = DEREF_off (x652_ + 3);\ (virt_) = DEREF_int (x652_ + 4);\ (destroyer_) (x652_, 5u);\ } /* Operations for field offset_size of union EXP */ #define exp_offset_size_tag 48u #define IS_exp_offset_size(P) (CHECK_NULL (P)->ag_tag == 48) #define exp_offset_size_off(P) (CHECK_TAG ((P), 48) + 2) #define exp_offset_size_step(P) (CHECK_TAG ((P), 48) + 3) #define exp_offset_size_pad(P) (CHECK_TAG ((P), 48) + 4) #define MAKE_exp_offset_size(type_, off_, step_, pad_, c_class_exp)\ {\ c_class *x653_ = GEN_c_class ( 5, TYPEID_exp );\ x653_->ag_tag = 48;\ COPY_type (x653_ + 1, (type_));\ COPY_off (x653_ + 2, (off_));\ COPY_type (x653_ + 3, (step_));\ COPY_int (x653_ + 4, (pad_));\ (c_class_exp) = x653_;\ } #define DECONS_exp_offset_size(type_, off_, step_, pad_, c_class_exp)\ {\ c_class *x654_ = CHECK_TAG ((c_class_exp), 48);\ (type_) = DEREF_type (x654_ + 1);\ (off_) = DEREF_off (x654_ + 2);\ (step_) = DEREF_type (x654_ + 3);\ (pad_) = DEREF_int (x654_ + 4);\ } #define DESTROY_exp_offset_size(destroyer_, type_, off_, step_, pad_, c_class_exp)\ {\ c_class *x655_ = CHECK_TAG ((c_class_exp), 48);\ (type_) = DEREF_type (x655_ + 1);\ (off_) = DEREF_off (x655_ + 2);\ (step_) = DEREF_type (x655_ + 3);\ (pad_) = DEREF_int (x655_ + 4);\ (destroyer_) (x655_, 5u);\ } /* Operations for field constr of union EXP */ #define exp_constr_tag 49u #define IS_exp_constr(P) (CHECK_NULL (P)->ag_tag == 49) #define exp_constr_call(P) (CHECK_TAG ((P), 49) + 2) #define exp_constr_obj(P) (CHECK_TAG ((P), 49) + 3) #define exp_constr_alt(P) (CHECK_TAG ((P), 49) + 4) #define exp_constr_info(P) (CHECK_TAG ((P), 49) + 5) #define MAKE_exp_constr(type_, call_, obj_, alt_, info_, c_class_exp)\ {\ c_class *x656_ = GEN_c_class ( 6, TYPEID_exp );\ x656_->ag_tag = 49;\ COPY_type (x656_ + 1, (type_));\ COPY_exp (x656_ + 2, (call_));\ COPY_exp (x656_ + 3, (obj_));\ COPY_exp (x656_ + 4, (alt_));\ COPY_int (x656_ + 5, (info_));\ (c_class_exp) = x656_;\ } #define DECONS_exp_constr(type_, call_, obj_, alt_, info_, c_class_exp)\ {\ c_class *x657_ = CHECK_TAG ((c_class_exp), 49);\ (type_) = DEREF_type (x657_ + 1);\ (call_) = DEREF_exp (x657_ + 2);\ (obj_) = DEREF_exp (x657_ + 3);\ (alt_) = DEREF_exp (x657_ + 4);\ (info_) = DEREF_int (x657_ + 5);\ } #define DESTROY_exp_constr(destroyer_, type_, call_, obj_, alt_, info_, c_class_exp)\ {\ c_class *x658_ = CHECK_TAG ((c_class_exp), 49);\ (type_) = DEREF_type (x658_ + 1);\ (call_) = DEREF_exp (x658_ + 2);\ (obj_) = DEREF_exp (x658_ + 3);\ (alt_) = DEREF_exp (x658_ + 4);\ (info_) = DEREF_int (x658_ + 5);\ (destroyer_) (x658_, 6u);\ } /* Operations for field destr of union EXP */ #define exp_destr_tag 50u #define IS_exp_destr(P) (CHECK_NULL (P)->ag_tag == 50) #define exp_destr_call(P) (CHECK_TAG ((P), 50) + 2) #define exp_destr_obj(P) (CHECK_TAG ((P), 50) + 3) #define exp_destr_count(P) (CHECK_TAG ((P), 50) + 4) #define MAKE_exp_destr(type_, call_, obj_, c_class_exp)\ {\ c_class *x659_ = GEN_c_class ( 5, TYPEID_exp );\ x659_->ag_tag = 50;\ COPY_type (x659_ + 1, (type_));\ COPY_exp (x659_ + 2, (call_));\ COPY_exp (x659_ + 3, (obj_));\ COPY_exp (x659_ + 4, NULL_exp);\ (c_class_exp) = x659_;\ } #define DECONS_exp_destr(type_, call_, obj_, count_, c_class_exp)\ {\ c_class *x660_ = CHECK_TAG ((c_class_exp), 50);\ (type_) = DEREF_type (x660_ + 1);\ (call_) = DEREF_exp (x660_ + 2);\ (obj_) = DEREF_exp (x660_ + 3);\ (count_) = DEREF_exp (x660_ + 4);\ } #define DESTROY_exp_destr(destroyer_, type_, call_, obj_, count_, c_class_exp)\ {\ c_class *x661_ = CHECK_TAG ((c_class_exp), 50);\ (type_) = DEREF_type (x661_ + 1);\ (call_) = DEREF_exp (x661_ + 2);\ (obj_) = DEREF_exp (x661_ + 3);\ (count_) = DEREF_exp (x661_ + 4);\ (destroyer_) (x661_, 5u);\ } /* Operations for field alloc of union EXP */ #define exp_alloc_tag 51u #define IS_exp_alloc(P) (CHECK_NULL (P)->ag_tag == 51) #define exp_alloc_call(P) (CHECK_TAG ((P), 51) + 2) #define exp_alloc_init(P) (CHECK_TAG ((P), 51) + 3) #define exp_alloc_garbage(P) (CHECK_TAG ((P), 51) + 4) #define exp_alloc_size(P) (CHECK_TAG ((P), 51) + 5) #define MAKE_exp_alloc(type_, call_, init_, garbage_, size_, c_class_exp)\ {\ c_class *x662_ = GEN_c_class ( 6, TYPEID_exp );\ x662_->ag_tag = 51;\ COPY_type (x662_ + 1, (type_));\ COPY_exp (x662_ + 2, (call_));\ COPY_exp (x662_ + 3, (init_));\ COPY_exp (x662_ + 4, (garbage_));\ COPY_exp (x662_ + 5, (size_));\ (c_class_exp) = x662_;\ } #define DECONS_exp_alloc(type_, call_, init_, garbage_, size_, c_class_exp)\ {\ c_class *x663_ = CHECK_TAG ((c_class_exp), 51);\ (type_) = DEREF_type (x663_ + 1);\ (call_) = DEREF_exp (x663_ + 2);\ (init_) = DEREF_exp (x663_ + 3);\ (garbage_) = DEREF_exp (x663_ + 4);\ (size_) = DEREF_exp (x663_ + 5);\ } #define DESTROY_exp_alloc(destroyer_, type_, call_, init_, garbage_, size_, c_class_exp)\ {\ c_class *x664_ = CHECK_TAG ((c_class_exp), 51);\ (type_) = DEREF_type (x664_ + 1);\ (call_) = DEREF_exp (x664_ + 2);\ (init_) = DEREF_exp (x664_ + 3);\ (garbage_) = DEREF_exp (x664_ + 4);\ (size_) = DEREF_exp (x664_ + 5);\ (destroyer_) (x664_, 6u);\ } /* Operations for field dealloc of union EXP */ #define exp_dealloc_tag 52u #define IS_exp_dealloc(P) (CHECK_NULL (P)->ag_tag == 52) #define exp_dealloc_term(P) (CHECK_TAG ((P), 52) + 2) #define exp_dealloc_call(P) (CHECK_TAG ((P), 52) + 3) #define exp_dealloc_arg(P) (CHECK_TAG ((P), 52) + 4) #define exp_dealloc_size(P) (CHECK_TAG ((P), 52) + 5) #define MAKE_exp_dealloc(type_, term_, call_, arg_, size_, c_class_exp)\ {\ c_class *x665_ = GEN_c_class ( 6, TYPEID_exp );\ x665_->ag_tag = 52;\ COPY_type (x665_ + 1, (type_));\ COPY_exp (x665_ + 2, (term_));\ COPY_exp (x665_ + 3, (call_));\ COPY_exp (x665_ + 4, (arg_));\ COPY_exp (x665_ + 5, (size_));\ (c_class_exp) = x665_;\ } #define DECONS_exp_dealloc(type_, term_, call_, arg_, size_, c_class_exp)\ {\ c_class *x666_ = CHECK_TAG ((c_class_exp), 52);\ (type_) = DEREF_type (x666_ + 1);\ (term_) = DEREF_exp (x666_ + 2);\ (call_) = DEREF_exp (x666_ + 3);\ (arg_) = DEREF_exp (x666_ + 4);\ (size_) = DEREF_exp (x666_ + 5);\ } #define DESTROY_exp_dealloc(destroyer_, type_, term_, call_, arg_, size_, c_class_exp)\ {\ c_class *x667_ = CHECK_TAG ((c_class_exp), 52);\ (type_) = DEREF_type (x667_ + 1);\ (term_) = DEREF_exp (x667_ + 2);\ (call_) = DEREF_exp (x667_ + 3);\ (arg_) = DEREF_exp (x667_ + 4);\ (size_) = DEREF_exp (x667_ + 5);\ (destroyer_) (x667_, 6u);\ } /* Operations for field rtti of union EXP */ #define exp_rtti_tag 53u #define IS_exp_rtti(P) (CHECK_NULL (P)->ag_tag == 53) #define exp_rtti_arg(P) (CHECK_TAG ((P), 53) + 2) #define exp_rtti_except(P) (CHECK_TAG ((P), 53) + 3) #define exp_rtti_op(P) (CHECK_TAG ((P), 53) + 4) #define MAKE_exp_rtti(type_, arg_, except_, op_, c_class_exp)\ {\ c_class *x668_ = GEN_c_class ( 5, TYPEID_exp );\ x668_->ag_tag = 53;\ COPY_type (x668_ + 1, (type_));\ COPY_exp (x668_ + 2, (arg_));\ COPY_exp (x668_ + 3, (except_));\ COPY_int (x668_ + 4, (op_));\ (c_class_exp) = x668_;\ } #define DECONS_exp_rtti(type_, arg_, except_, op_, c_class_exp)\ {\ c_class *x669_ = CHECK_TAG ((c_class_exp), 53);\ (type_) = DEREF_type (x669_ + 1);\ (arg_) = DEREF_exp (x669_ + 2);\ (except_) = DEREF_exp (x669_ + 3);\ (op_) = DEREF_int (x669_ + 4);\ } #define DESTROY_exp_rtti(destroyer_, type_, arg_, except_, op_, c_class_exp)\ {\ c_class *x670_ = CHECK_TAG ((c_class_exp), 53);\ (type_) = DEREF_type (x670_ + 1);\ (arg_) = DEREF_exp (x670_ + 2);\ (except_) = DEREF_exp (x670_ + 3);\ (op_) = DEREF_int (x670_ + 4);\ (destroyer_) (x670_, 5u);\ } /* Operations for field rtti_type of union EXP */ #define exp_rtti_type_tag 54u #define IS_exp_rtti_type(P) (CHECK_NULL (P)->ag_tag == 54) #define exp_rtti_type_arg(P) (CHECK_TAG ((P), 54) + 2) #define exp_rtti_type_op(P) (CHECK_TAG ((P), 54) + 3) #define MAKE_exp_rtti_type(type_, arg_, op_, c_class_exp)\ {\ c_class *x671_ = GEN_c_class ( 4, TYPEID_exp );\ x671_->ag_tag = 54;\ COPY_type (x671_ + 1, (type_));\ COPY_type (x671_ + 2, (arg_));\ COPY_int (x671_ + 3, (op_));\ (c_class_exp) = x671_;\ } #define DECONS_exp_rtti_type(type_, arg_, op_, c_class_exp)\ {\ c_class *x672_ = CHECK_TAG ((c_class_exp), 54);\ (type_) = DEREF_type (x672_ + 1);\ (arg_) = DEREF_type (x672_ + 2);\ (op_) = DEREF_int (x672_ + 3);\ } #define DESTROY_exp_rtti_type(destroyer_, type_, arg_, op_, c_class_exp)\ {\ c_class *x673_ = CHECK_TAG ((c_class_exp), 54);\ (type_) = DEREF_type (x673_ + 1);\ (arg_) = DEREF_type (x673_ + 2);\ (op_) = DEREF_int (x673_ + 3);\ (destroyer_) (x673_, 4u);\ } /* Operations for field rtti_no of union EXP */ #define exp_rtti_no_tag 55u #define IS_exp_rtti_no(P) (CHECK_NULL (P)->ag_tag == 55) #define exp_rtti_no_arg(P) (CHECK_TAG ((P), 55) + 2) #define MAKE_exp_rtti_no(type_, arg_, c_class_exp)\ {\ c_class *x674_ = GEN_c_class ( 3, TYPEID_exp );\ x674_->ag_tag = 55;\ COPY_type (x674_ + 1, (type_));\ COPY_type (x674_ + 2, (arg_));\ (c_class_exp) = x674_;\ } #define DECONS_exp_rtti_no(type_, arg_, c_class_exp)\ {\ c_class *x675_ = CHECK_TAG ((c_class_exp), 55);\ (type_) = DEREF_type (x675_ + 1);\ (arg_) = DEREF_type (x675_ + 2);\ } #define DESTROY_exp_rtti_no(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x676_ = CHECK_TAG ((c_class_exp), 55);\ (type_) = DEREF_type (x676_ + 1);\ (arg_) = DEREF_type (x676_ + 2);\ (destroyer_) (x676_, 3u);\ } /* Operations for field dynamic of union EXP */ #define exp_dynamic_tag 56u #define IS_exp_dynamic(P) (CHECK_NULL (P)->ag_tag == 56) #define exp_dynamic_arg(P) (CHECK_TAG ((P), 56) + 2) #define MAKE_exp_dynamic(type_, arg_, c_class_exp)\ {\ c_class *x677_ = GEN_c_class ( 3, TYPEID_exp );\ x677_->ag_tag = 56;\ COPY_type (x677_ + 1, (type_));\ COPY_exp (x677_ + 2, (arg_));\ (c_class_exp) = x677_;\ } #define DECONS_exp_dynamic(type_, arg_, c_class_exp)\ {\ c_class *x678_ = CHECK_TAG ((c_class_exp), 56);\ (type_) = DEREF_type (x678_ + 1);\ (arg_) = DEREF_exp (x678_ + 2);\ } #define DESTROY_exp_dynamic(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x679_ = CHECK_TAG ((c_class_exp), 56);\ (type_) = DEREF_type (x679_ + 1);\ (arg_) = DEREF_exp (x679_ + 2);\ (destroyer_) (x679_, 3u);\ } /* Operations for field aggregate of union EXP */ #define exp_aggregate_tag 57u #define IS_exp_aggregate(P) (CHECK_NULL (P)->ag_tag == 57) #define exp_aggregate_args(P) (CHECK_TAG ((P), 57) + 2) #define exp_aggregate_offs(P) (CHECK_TAG ((P), 57) + 3) #define MAKE_exp_aggregate(type_, args_, offs_, c_class_exp)\ {\ c_class *x680_ = GEN_c_class ( 4, TYPEID_exp );\ x680_->ag_tag = 57;\ COPY_type (x680_ + 1, (type_));\ COPY_list (x680_ + 2, (args_));\ COPY_list (x680_ + 3, (offs_));\ (c_class_exp) = x680_;\ } #define DECONS_exp_aggregate(type_, args_, offs_, c_class_exp)\ {\ c_class *x681_ = CHECK_TAG ((c_class_exp), 57);\ (type_) = DEREF_type (x681_ + 1);\ (args_) = DEREF_list (x681_ + 2);\ (offs_) = DEREF_list (x681_ + 3);\ } #define DESTROY_exp_aggregate(destroyer_, type_, args_, offs_, c_class_exp)\ {\ c_class *x682_ = CHECK_TAG ((c_class_exp), 57);\ (type_) = DEREF_type (x682_ + 1);\ (args_) = DEREF_list (x682_ + 2);\ (offs_) = DEREF_list (x682_ + 3);\ (destroyer_) (x682_, 4u);\ } /* Operations for field initialiser of union EXP */ #define exp_initialiser_tag 58u #define IS_exp_initialiser(P) (CHECK_NULL (P)->ag_tag == 58) #define exp_initialiser_args(P) (CHECK_TAG ((P), 58) + 2) #define exp_initialiser_offs(P) (CHECK_TAG ((P), 58) + 3) #define exp_initialiser_kind(P) (CHECK_TAG ((P), 58) + 4) #define exp_initialiser_virt(P) (CHECK_TAG ((P), 58) + 5) #define exp_initialiser_base(P) (CHECK_TAG ((P), 58) + 6) #define MAKE_exp_initialiser(type_, args_, offs_, kind_, virt_, base_, c_class_exp)\ {\ c_class *x683_ = GEN_c_class ( 7, TYPEID_exp );\ x683_->ag_tag = 58;\ COPY_type (x683_ + 1, (type_));\ COPY_list (x683_ + 2, (args_));\ COPY_list (x683_ + 3, (offs_));\ COPY_int (x683_ + 4, (kind_));\ COPY_unsigned (x683_ + 5, (virt_));\ COPY_unsigned (x683_ + 6, (base_));\ (c_class_exp) = x683_;\ } #define DECONS_exp_initialiser(type_, args_, offs_, kind_, virt_, base_, c_class_exp)\ {\ c_class *x684_ = CHECK_TAG ((c_class_exp), 58);\ (type_) = DEREF_type (x684_ + 1);\ (args_) = DEREF_list (x684_ + 2);\ (offs_) = DEREF_list (x684_ + 3);\ (kind_) = DEREF_int (x684_ + 4);\ (virt_) = DEREF_unsigned (x684_ + 5);\ (base_) = DEREF_unsigned (x684_ + 6);\ } #define DESTROY_exp_initialiser(destroyer_, type_, args_, offs_, kind_, virt_, base_, c_class_exp)\ {\ c_class *x685_ = CHECK_TAG ((c_class_exp), 58);\ (type_) = DEREF_type (x685_ + 1);\ (args_) = DEREF_list (x685_ + 2);\ (offs_) = DEREF_list (x685_ + 3);\ (kind_) = DEREF_int (x685_ + 4);\ (virt_) = DEREF_unsigned (x685_ + 5);\ (base_) = DEREF_unsigned (x685_ + 6);\ (destroyer_) (x685_, 7u);\ } /* Operations for field nof of union EXP */ #define exp_nof_tag 59u #define IS_exp_nof(P) (CHECK_NULL (P)->ag_tag == 59) #define exp_nof_start(P) (CHECK_TAG ((P), 59) + 2) #define exp_nof_size(P) (CHECK_TAG ((P), 59) + 3) #define exp_nof_pad(P) (CHECK_TAG ((P), 59) + 4) #define exp_nof_end(P) (CHECK_TAG ((P), 59) + 5) #define MAKE_exp_nof(type_, start_, size_, pad_, end_, c_class_exp)\ {\ c_class *x686_ = GEN_c_class ( 6, TYPEID_exp );\ x686_->ag_tag = 59;\ COPY_type (x686_ + 1, (type_));\ COPY_exp (x686_ + 2, (start_));\ COPY_nat (x686_ + 3, (size_));\ COPY_exp (x686_ + 4, (pad_));\ COPY_exp (x686_ + 5, (end_));\ (c_class_exp) = x686_;\ } #define DECONS_exp_nof(type_, start_, size_, pad_, end_, c_class_exp)\ {\ c_class *x687_ = CHECK_TAG ((c_class_exp), 59);\ (type_) = DEREF_type (x687_ + 1);\ (start_) = DEREF_exp (x687_ + 2);\ (size_) = DEREF_nat (x687_ + 3);\ (pad_) = DEREF_exp (x687_ + 4);\ (end_) = DEREF_exp (x687_ + 5);\ } #define DESTROY_exp_nof(destroyer_, type_, start_, size_, pad_, end_, c_class_exp)\ {\ c_class *x688_ = CHECK_TAG ((c_class_exp), 59);\ (type_) = DEREF_type (x688_ + 1);\ (start_) = DEREF_exp (x688_ + 2);\ (size_) = DEREF_nat (x688_ + 3);\ (pad_) = DEREF_exp (x688_ + 4);\ (end_) = DEREF_exp (x688_ + 5);\ (destroyer_) (x688_, 6u);\ } /* Operations for field comma of union EXP */ #define exp_comma_tag 60u #define IS_exp_comma(P) (CHECK_NULL (P)->ag_tag == 60) #define exp_comma_args(P) (CHECK_TAG ((P), 60) + 2) #define MAKE_exp_comma(type_, args_, c_class_exp)\ {\ c_class *x689_ = GEN_c_class ( 3, TYPEID_exp );\ x689_->ag_tag = 60;\ COPY_type (x689_ + 1, (type_));\ COPY_list (x689_ + 2, (args_));\ (c_class_exp) = x689_;\ } #define DECONS_exp_comma(type_, args_, c_class_exp)\ {\ c_class *x690_ = CHECK_TAG ((c_class_exp), 60);\ (type_) = DEREF_type (x690_ + 1);\ (args_) = DEREF_list (x690_ + 2);\ } #define DESTROY_exp_comma(destroyer_, type_, args_, c_class_exp)\ {\ c_class *x691_ = CHECK_TAG ((c_class_exp), 60);\ (type_) = DEREF_type (x691_ + 1);\ (args_) = DEREF_list (x691_ + 2);\ (destroyer_) (x691_, 3u);\ } /* Operations for field set set_etc of union EXP */ #define exp_set_etc_tag 63u #define IS_exp_set_etc(P) ((unsigned) (CHECK_NULL (P)->ag_tag - 61) < 2u) #define exp_set_etc_arg(P) (CHECK_TAG_ETC ((P), 61, 63) + 2) #define MAKE_exp_set_etc(tag, type_, arg_, c_class_exp)\ {\ c_class *x692_ = GEN_c_class ( 3, TYPEID_exp );\ x692_->ag_tag = (tag);\ COPY_type (x692_ + 1, (type_));\ COPY_exp (x692_ + 2, (arg_));\ (c_class_exp) = CHECK_TAG_ETC (x692_, 61, 63);\ } #define MODIFY_exp_set_etc(tag, c_class_exp)\ {\ c_class *x693_ = CHECK_TAG_ETC ((c_class_exp), 61, 63);\ x693_->ag_tag = (tag);\ (void) CHECK_TAG_ETC (x693_, 61, 63);\ } #define DECONS_exp_set_etc(type_, arg_, c_class_exp)\ {\ c_class *x694_ = CHECK_TAG_ETC ((c_class_exp), 61, 63);\ (type_) = DEREF_type (x694_ + 1);\ (arg_) = DEREF_exp (x694_ + 2);\ } #define DESTROY_exp_set_etc(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x695_ = CHECK_TAG_ETC ((c_class_exp), 61, 63);\ (type_) = DEREF_type (x695_ + 1);\ (arg_) = DEREF_exp (x695_ + 2);\ (destroyer_) (x695_, 3u);\ } /* Operations for field set of union EXP */ #define exp_set_tag 61u #define IS_exp_set(P) (CHECK_NULL (P)->ag_tag == 61) #define exp_set_arg(P) (CHECK_TAG ((P), 61) + 2) #define MAKE_exp_set(type_, arg_, c_class_exp)\ {\ c_class *x696_ = GEN_c_class ( 3, TYPEID_exp );\ x696_->ag_tag = 61;\ COPY_type (x696_ + 1, (type_));\ COPY_exp (x696_ + 2, (arg_));\ (c_class_exp) = x696_;\ } #define DECONS_exp_set(type_, arg_, c_class_exp)\ {\ c_class *x697_ = CHECK_TAG ((c_class_exp), 61);\ (type_) = DEREF_type (x697_ + 1);\ (arg_) = DEREF_exp (x697_ + 2);\ } #define DESTROY_exp_set(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x698_ = CHECK_TAG ((c_class_exp), 61);\ (type_) = DEREF_type (x698_ + 1);\ (arg_) = DEREF_exp (x698_ + 2);\ (destroyer_) (x698_, 3u);\ } /* Operations for field unused of union EXP */ #define exp_unused_tag 62u #define IS_exp_unused(P) (CHECK_NULL (P)->ag_tag == 62) #define exp_unused_arg(P) (CHECK_TAG ((P), 62) + 2) #define MAKE_exp_unused(type_, arg_, c_class_exp)\ {\ c_class *x699_ = GEN_c_class ( 3, TYPEID_exp );\ x699_->ag_tag = 62;\ COPY_type (x699_ + 1, (type_));\ COPY_exp (x699_ + 2, (arg_));\ (c_class_exp) = x699_;\ } #define DECONS_exp_unused(type_, arg_, c_class_exp)\ {\ c_class *x700_ = CHECK_TAG ((c_class_exp), 62);\ (type_) = DEREF_type (x700_ + 1);\ (arg_) = DEREF_exp (x700_ + 2);\ } #define DESTROY_exp_unused(destroyer_, type_, arg_, c_class_exp)\ {\ c_class *x701_ = CHECK_TAG ((c_class_exp), 62);\ (type_) = DEREF_type (x701_ + 1);\ (arg_) = DEREF_exp (x701_ + 2);\ (destroyer_) (x701_, 3u);\ } /* Operations for field set reach_etc of union EXP */ #define exp_reach_etc_tag 65u #define IS_exp_reach_etc(P) ((unsigned) (CHECK_NULL (P)->ag_tag - 63) < 2u) #define exp_reach_etc_parent(P) (CHECK_TAG_ETC ((P), 63, 65) + 2) #define exp_reach_etc_body(P) (CHECK_TAG_ETC ((P), 63, 65) + 3) #define MAKE_exp_reach_etc(tag, type_, body_, c_class_exp)\ {\ c_class *x702_ = GEN_c_class ( 4, TYPEID_exp );\ x702_->ag_tag = (tag);\ COPY_type (x702_ + 1, (type_));\ COPY_exp (x702_ + 2, NULL_exp);\ COPY_exp (x702_ + 3, (body_));\ (c_class_exp) = CHECK_TAG_ETC (x702_, 63, 65);\ } #define MODIFY_exp_reach_etc(tag, c_class_exp)\ {\ c_class *x703_ = CHECK_TAG_ETC ((c_class_exp), 63, 65);\ x703_->ag_tag = (tag);\ (void) CHECK_TAG_ETC (x703_, 63, 65);\ } #define DECONS_exp_reach_etc(type_, parent_, body_, c_class_exp)\ {\ c_class *x704_ = CHECK_TAG_ETC ((c_class_exp), 63, 65);\ (type_) = DEREF_type (x704_ + 1);\ (parent_) = DEREF_exp (x704_ + 2);\ (body_) = DEREF_exp (x704_ + 3);\ } #define DESTROY_exp_reach_etc(destroyer_, type_, parent_, body_, c_class_exp)\ {\ c_class *x705_ = CHECK_TAG_ETC ((c_class_exp), 63, 65);\ (type_) = DEREF_type (x705_ + 1);\ (parent_) = DEREF_exp (x705_ + 2);\ (body_) = DEREF_exp (x705_ + 3);\ (destroyer_) (x705_, 4u);\ } /* Operations for field reach of union EXP */ #define exp_reach_tag 63u #define IS_exp_reach(P) (CHECK_NULL (P)->ag_tag == 63) #define exp_reach_parent(P) (CHECK_TAG ((P), 63) + 2) #define exp_reach_body(P) (CHECK_TAG ((P), 63) + 3) #define MAKE_exp_reach(type_, body_, c_class_exp)\ {\ c_class *x706_ = GEN_c_class ( 4, TYPEID_exp );\ x706_->ag_tag = 63;\ COPY_type (x706_ + 1, (type_));\ COPY_exp (x706_ + 2, NULL_exp);\ COPY_exp (x706_ + 3, (body_));\ (c_class_exp) = x706_;\ } #define DECONS_exp_reach(type_, parent_, body_, c_class_exp)\ {\ c_class *x707_ = CHECK_TAG ((c_class_exp), 63);\ (type_) = DEREF_type (x707_ + 1);\ (parent_) = DEREF_exp (x707_ + 2);\ (body_) = DEREF_exp (x707_ + 3);\ } #define DESTROY_exp_reach(destroyer_, type_, parent_, body_, c_class_exp)\ {\ c_class *x708_ = CHECK_TAG ((c_class_exp), 63);\ (type_) = DEREF_type (x708_ + 1);\ (parent_) = DEREF_exp (x708_ + 2);\ (body_) = DEREF_exp (x708_ + 3);\ (destroyer_) (x708_, 4u);\ } /* Operations for field unreach of union EXP */ #define exp_unreach_tag 64u #define IS_exp_unreach(P) (CHECK_NULL (P)->ag_tag == 64) #define exp_unreach_parent(P) (CHECK_TAG ((P), 64) + 2) #define exp_unreach_body(P) (CHECK_TAG ((P), 64) + 3) #define MAKE_exp_unreach(type_, body_, c_class_exp)\ {\ c_class *x709_ = GEN_c_class ( 4, TYPEID_exp );\ x709_->ag_tag = 64;\ COPY_type (x709_ + 1, (type_));\ COPY_exp (x709_ + 2, NULL_exp);\ COPY_exp (x709_ + 3, (body_));\ (c_class_exp) = x709_;\ } #define DECONS_exp_unreach(type_, parent_, body_, c_class_exp)\ {\ c_class *x710_ = CHECK_TAG ((c_class_exp), 64);\ (type_) = DEREF_type (x710_ + 1);\ (parent_) = DEREF_exp (x710_ + 2);\ (body_) = DEREF_exp (x710_ + 3);\ } #define DESTROY_exp_unreach(destroyer_, type_, parent_, body_, c_class_exp)\ {\ c_class *x711_ = CHECK_TAG ((c_class_exp), 64);\ (type_) = DEREF_type (x711_ + 1);\ (parent_) = DEREF_exp (x711_ + 2);\ (body_) = DEREF_exp (x711_ + 3);\ (destroyer_) (x711_, 4u);\ } /* Operations for field sequence of union EXP */ #define exp_sequence_tag 65u #define IS_exp_sequence(P) (CHECK_NULL (P)->ag_tag == 65) #define exp_sequence_parent(P) (CHECK_TAG ((P), 65) + 2) #define exp_sequence_first(P) (CHECK_TAG ((P), 65) + 3) #define exp_sequence_last(P) (CHECK_TAG ((P), 65) + 4) #define exp_sequence_decl(P) (CHECK_TAG ((P), 65) + 5) #define exp_sequence_block(P) (CHECK_TAG ((P), 65) + 6) #define MAKE_exp_sequence(type_, first_, last_, decl_, block_, c_class_exp)\ {\ c_class *x712_ = GEN_c_class ( 7, TYPEID_exp );\ x712_->ag_tag = 65;\ COPY_type (x712_ + 1, (type_));\ COPY_exp (x712_ + 2, NULL_exp);\ COPY_list (x712_ + 3, (first_));\ COPY_list (x712_ + 4, (last_));\ COPY_nspace (x712_ + 5, (decl_));\ COPY_int (x712_ + 6, (block_));\ (c_class_exp) = x712_;\ } #define DECONS_exp_sequence(type_, parent_, first_, last_, decl_, block_, c_class_exp)\ {\ c_class *x713_ = CHECK_TAG ((c_class_exp), 65);\ (type_) = DEREF_type (x713_ + 1);\ (parent_) = DEREF_exp (x713_ + 2);\ (first_) = DEREF_list (x713_ + 3);\ (last_) = DEREF_list (x713_ + 4);\ (decl_) = DEREF_nspace (x713_ + 5);\ (block_) = DEREF_int (x713_ + 6);\ } #define DESTROY_exp_sequence(destroyer_, type_, parent_, first_, last_, decl_, block_, c_class_exp)\ {\ c_class *x714_ = CHECK_TAG ((c_class_exp), 65);\ (type_) = DEREF_type (x714_ + 1);\ (parent_) = DEREF_exp (x714_ + 2);\ (first_) = DEREF_list (x714_ + 3);\ (last_) = DEREF_list (x714_ + 4);\ (decl_) = DEREF_nspace (x714_ + 5);\ (block_) = DEREF_int (x714_ + 6);\ (destroyer_) (x714_, 7u);\ } /* Operations for field solve_stmt of union EXP */ #define exp_solve_stmt_tag 66u #define IS_exp_solve_stmt(P) (CHECK_NULL (P)->ag_tag == 66) #define exp_solve_stmt_parent(P) (CHECK_TAG ((P), 66) + 2) #define exp_solve_stmt_body(P) (CHECK_TAG ((P), 66) + 3) #define exp_solve_stmt_labels(P) (CHECK_TAG ((P), 66) + 4) #define exp_solve_stmt_vars(P) (CHECK_TAG ((P), 66) + 5) #define MAKE_exp_solve_stmt(type_, body_, c_class_exp)\ {\ c_class *x715_ = GEN_c_class ( 6, TYPEID_exp );\ x715_->ag_tag = 66;\ COPY_type (x715_ + 1, (type_));\ COPY_exp (x715_ + 2, NULL_exp);\ COPY_exp (x715_ + 3, (body_));\ COPY_list (x715_ + 4, NULL_list ( IDENTIFIER ));\ COPY_list (x715_ + 5, NULL_list ( IDENTIFIER ));\ (c_class_exp) = x715_;\ } #define DECONS_exp_solve_stmt(type_, parent_, body_, labels_, vars_, c_class_exp)\ {\ c_class *x716_ = CHECK_TAG ((c_class_exp), 66);\ (type_) = DEREF_type (x716_ + 1);\ (parent_) = DEREF_exp (x716_ + 2);\ (body_) = DEREF_exp (x716_ + 3);\ (labels_) = DEREF_list (x716_ + 4);\ (vars_) = DEREF_list (x716_ + 5);\ } #define DESTROY_exp_solve_stmt(destroyer_, type_, parent_, body_, labels_, vars_, c_class_exp)\ {\ c_class *x717_ = CHECK_TAG ((c_class_exp), 66);\ (type_) = DEREF_type (x717_ + 1);\ (parent_) = DEREF_exp (x717_ + 2);\ (body_) = DEREF_exp (x717_ + 3);\ (labels_) = DEREF_list (x717_ + 4);\ (vars_) = DEREF_list (x717_ + 5);\ (destroyer_) (x717_, 6u);\ } /* Operations for field decl_stmt of union EXP */ #define exp_decl_stmt_tag 67u #define IS_exp_decl_stmt(P) (CHECK_NULL (P)->ag_tag == 67) #define exp_decl_stmt_parent(P) (CHECK_TAG ((P), 67) + 2) #define exp_decl_stmt_id(P) (CHECK_TAG ((P), 67) + 3) #define exp_decl_stmt_body(P) (CHECK_TAG ((P), 67) + 4) #define MAKE_exp_decl_stmt(type_, id_, body_, c_class_exp)\ {\ c_class *x718_ = GEN_c_class ( 5, TYPEID_exp );\ x718_->ag_tag = 67;\ COPY_type (x718_ + 1, (type_));\ COPY_exp (x718_ + 2, NULL_exp);\ COPY_id (x718_ + 3, (id_));\ COPY_exp (x718_ + 4, (body_));\ (c_class_exp) = x718_;\ } #define DECONS_exp_decl_stmt(type_, parent_, id_, body_, c_class_exp)\ {\ c_class *x719_ = CHECK_TAG ((c_class_exp), 67);\ (type_) = DEREF_type (x719_ + 1);\ (parent_) = DEREF_exp (x719_ + 2);\ (id_) = DEREF_id (x719_ + 3);\ (body_) = DEREF_exp (x719_ + 4);\ } #define DESTROY_exp_decl_stmt(destroyer_, type_, parent_, id_, body_, c_class_exp)\ {\ c_class *x720_ = CHECK_TAG ((c_class_exp), 67);\ (type_) = DEREF_type (x720_ + 1);\ (parent_) = DEREF_exp (x720_ + 2);\ (id_) = DEREF_id (x720_ + 3);\ (body_) = DEREF_exp (x720_ + 4);\ (destroyer_) (x720_, 5u);\ } /* Operations for field if_stmt of union EXP */ #define exp_if_stmt_tag 68u #define IS_exp_if_stmt(P) (CHECK_NULL (P)->ag_tag == 68) #define exp_if_stmt_parent(P) (CHECK_TAG ((P), 68) + 2) #define exp_if_stmt_cond(P) (CHECK_TAG ((P), 68) + 3) #define exp_if_stmt_true_code(P) (CHECK_TAG ((P), 68) + 4) #define exp_if_stmt_false_code(P) (CHECK_TAG ((P), 68) + 5) #define exp_if_stmt_label(P) (CHECK_TAG ((P), 68) + 6) #define MAKE_exp_if_stmt(type_, cond_, true_code_, false_code_, label_, c_class_exp)\ {\ c_class *x721_ = GEN_c_class ( 7, TYPEID_exp );\ x721_->ag_tag = 68;\ COPY_type (x721_ + 1, (type_));\ COPY_exp (x721_ + 2, NULL_exp);\ COPY_exp (x721_ + 3, (cond_));\ COPY_exp (x721_ + 4, (true_code_));\ COPY_exp (x721_ + 5, (false_code_));\ COPY_id (x721_ + 6, (label_));\ (c_class_exp) = x721_;\ } #define DECONS_exp_if_stmt(type_, parent_, cond_, true_code_, false_code_, label_, c_class_exp)\ {\ c_class *x722_ = CHECK_TAG ((c_class_exp), 68);\ (type_) = DEREF_type (x722_ + 1);\ (parent_) = DEREF_exp (x722_ + 2);\ (cond_) = DEREF_exp (x722_ + 3);\ (true_code_) = DEREF_exp (x722_ + 4);\ (false_code_) = DEREF_exp (x722_ + 5);\ (label_) = DEREF_id (x722_ + 6);\ } #define DESTROY_exp_if_stmt(destroyer_, type_, parent_, cond_, true_code_, false_code_, label_, c_class_exp)\ {\ c_class *x723_ = CHECK_TAG ((c_class_exp), 68);\ (type_) = DEREF_type (x723_ + 1);\ (parent_) = DEREF_exp (x723_ + 2);\ (cond_) = DEREF_exp (x723_ + 3);\ (true_code_) = DEREF_exp (x723_ + 4);\ (false_code_) = DEREF_exp (x723_ + 5);\ (label_) = DEREF_id (x723_ + 6);\ (destroyer_) (x723_, 7u);\ } /* Operations for field while_stmt of union EXP */ #define exp_while_stmt_tag 69u #define IS_exp_while_stmt(P) (CHECK_NULL (P)->ag_tag == 69) #define exp_while_stmt_parent(P) (CHECK_TAG ((P), 69) + 2) #define exp_while_stmt_cond(P) (CHECK_TAG ((P), 69) + 3) #define exp_while_stmt_body(P) (CHECK_TAG ((P), 69) + 4) #define exp_while_stmt_break_lab(P) (CHECK_TAG ((P), 69) + 5) #define exp_while_stmt_cont_lab(P) (CHECK_TAG ((P), 69) + 6) #define exp_while_stmt_loop_lab(P) (CHECK_TAG ((P), 69) + 7) #define exp_while_stmt_cond_id(P) (CHECK_TAG ((P), 69) + 8) #define MAKE_exp_while_stmt(type_, cond_, break_lab_, cont_lab_, loop_lab_, c_class_exp)\ {\ c_class *x724_ = GEN_c_class ( 9, TYPEID_exp );\ x724_->ag_tag = 69;\ COPY_type (x724_ + 1, (type_));\ COPY_exp (x724_ + 2, NULL_exp);\ COPY_exp (x724_ + 3, (cond_));\ COPY_exp (x724_ + 4, NULL_exp);\ COPY_id (x724_ + 5, (break_lab_));\ COPY_id (x724_ + 6, (cont_lab_));\ COPY_id (x724_ + 7, (loop_lab_));\ COPY_list (x724_ + 8, NULL_list ( IDENTIFIER ));\ (c_class_exp) = x724_;\ } #define DECONS_exp_while_stmt(type_, parent_, cond_, body_, break_lab_, cont_lab_, loop_lab_, cond_id_, c_class_exp)\ {\ c_class *x725_ = CHECK_TAG ((c_class_exp), 69);\ (type_) = DEREF_type (x725_ + 1);\ (parent_) = DEREF_exp (x725_ + 2);\ (cond_) = DEREF_exp (x725_ + 3);\ (body_) = DEREF_exp (x725_ + 4);\ (break_lab_) = DEREF_id (x725_ + 5);\ (cont_lab_) = DEREF_id (x725_ + 6);\ (loop_lab_) = DEREF_id (x725_ + 7);\ (cond_id_) = DEREF_list (x725_ + 8);\ } #define DESTROY_exp_while_stmt(destroyer_, type_, parent_, cond_, body_, break_lab_, cont_lab_, loop_lab_, cond_id_, c_class_exp)\ {\ c_class *x726_ = CHECK_TAG ((c_class_exp), 69);\ (type_) = DEREF_type (x726_ + 1);\ (parent_) = DEREF_exp (x726_ + 2);\ (cond_) = DEREF_exp (x726_ + 3);\ (body_) = DEREF_exp (x726_ + 4);\ (break_lab_) = DEREF_id (x726_ + 5);\ (cont_lab_) = DEREF_id (x726_ + 6);\ (loop_lab_) = DEREF_id (x726_ + 7);\ (cond_id_) = DEREF_list (x726_ + 8);\ (destroyer_) (x726_, 9u);\ } /* Operations for field do_stmt of union EXP */ #define exp_do_stmt_tag 70u #define IS_exp_do_stmt(P) (CHECK_NULL (P)->ag_tag == 70) #define exp_do_stmt_parent(P) (CHECK_TAG ((P), 70) + 2) #define exp_do_stmt_cond(P) (CHECK_TAG ((P), 70) + 3) #define exp_do_stmt_body(P) (CHECK_TAG ((P), 70) + 4) #define exp_do_stmt_break_lab(P) (CHECK_TAG ((P), 70) + 5) #define exp_do_stmt_cont_lab(P) (CHECK_TAG ((P), 70) + 6) #define exp_do_stmt_loop_lab(P) (CHECK_TAG ((P), 70) + 7) #define MAKE_exp_do_stmt(type_, cond_, break_lab_, cont_lab_, loop_lab_, c_class_exp)\ {\ c_class *x727_ = GEN_c_class ( 8, TYPEID_exp );\ x727_->ag_tag = 70;\ COPY_type (x727_ + 1, (type_));\ COPY_exp (x727_ + 2, NULL_exp);\ COPY_exp (x727_ + 3, (cond_));\ COPY_exp (x727_ + 4, NULL_exp);\ COPY_id (x727_ + 5, (break_lab_));\ COPY_id (x727_ + 6, (cont_lab_));\ COPY_id (x727_ + 7, (loop_lab_));\ (c_class_exp) = x727_;\ } #define DECONS_exp_do_stmt(type_, parent_, cond_, body_, break_lab_, cont_lab_, loop_lab_, c_class_exp)\ {\ c_class *x728_ = CHECK_TAG ((c_class_exp), 70);\ (type_) = DEREF_type (x728_ + 1);\ (parent_) = DEREF_exp (x728_ + 2);\ (cond_) = DEREF_exp (x728_ + 3);\ (body_) = DEREF_exp (x728_ + 4);\ (break_lab_) = DEREF_id (x728_ + 5);\ (cont_lab_) = DEREF_id (x728_ + 6);\ (loop_lab_) = DEREF_id (x728_ + 7);\ } #define DESTROY_exp_do_stmt(destroyer_, type_, parent_, cond_, body_, break_lab_, cont_lab_, loop_lab_, c_class_exp)\ {\ c_class *x729_ = CHECK_TAG ((c_class_exp), 70);\ (type_) = DEREF_type (x729_ + 1);\ (parent_) = DEREF_exp (x729_ + 2);\ (cond_) = DEREF_exp (x729_ + 3);\ (body_) = DEREF_exp (x729_ + 4);\ (break_lab_) = DEREF_id (x729_ + 5);\ (cont_lab_) = DEREF_id (x729_ + 6);\ (loop_lab_) = DEREF_id (x729_ + 7);\ (destroyer_) (x729_, 8u);\ } /* Operations for field switch_stmt of union EXP */ #define exp_switch_stmt_tag 71u #define IS_exp_switch_stmt(P) (CHECK_NULL (P)->ag_tag == 71) #define exp_switch_stmt_parent(P) (CHECK_TAG ((P), 71) + 2) #define exp_switch_stmt_control(P) (CHECK_TAG ((P), 71) + 3) #define exp_switch_stmt_body(P) (CHECK_TAG ((P), 71) + 4) #define exp_switch_stmt_cases(P) (CHECK_TAG ((P), 71) + 5) #define exp_switch_stmt_case_labs(P) (CHECK_TAG ((P), 71) + 6) #define exp_switch_stmt_default_lab(P) (CHECK_TAG ((P), 71) + 7) #define exp_switch_stmt_exhaust(P) (CHECK_TAG ((P), 71) + 8) #define exp_switch_stmt_break_lab(P) (CHECK_TAG ((P), 71) + 9) #define MAKE_exp_switch_stmt(type_, control_, body_, exhaust_, break_lab_, c_class_exp)\ {\ c_class *x730_ = GEN_c_class ( 10, TYPEID_exp );\ x730_->ag_tag = 71;\ COPY_type (x730_ + 1, (type_));\ COPY_exp (x730_ + 2, NULL_exp);\ COPY_exp (x730_ + 3, (control_));\ COPY_exp (x730_ + 4, (body_));\ COPY_list (x730_ + 5, NULL_list ( NAT ));\ COPY_list (x730_ + 6, NULL_list ( IDENTIFIER ));\ COPY_id (x730_ + 7, NULL_id);\ COPY_int (x730_ + 8, (exhaust_));\ COPY_id (x730_ + 9, (break_lab_));\ (c_class_exp) = x730_;\ } #define DECONS_exp_switch_stmt(type_, parent_, control_, body_, cases_, case_labs_, default_lab_, exhaust_, break_lab_, c_class_exp)\ {\ c_class *x731_ = CHECK_TAG ((c_class_exp), 71);\ (type_) = DEREF_type (x731_ + 1);\ (parent_) = DEREF_exp (x731_ + 2);\ (control_) = DEREF_exp (x731_ + 3);\ (body_) = DEREF_exp (x731_ + 4);\ (cases_) = DEREF_list (x731_ + 5);\ (case_labs_) = DEREF_list (x731_ + 6);\ (default_lab_) = DEREF_id (x731_ + 7);\ (exhaust_) = DEREF_int (x731_ + 8);\ (break_lab_) = DEREF_id (x731_ + 9);\ } #define DESTROY_exp_switch_stmt(destroyer_, type_, parent_, control_, body_, cases_, case_labs_, default_lab_, exhaust_, break_lab_, c_class_exp)\ {\ c_class *x732_ = CHECK_TAG ((c_class_exp), 71);\ (type_) = DEREF_type (x732_ + 1);\ (parent_) = DEREF_exp (x732_ + 2);\ (control_) = DEREF_exp (x732_ + 3);\ (body_) = DEREF_exp (x732_ + 4);\ (cases_) = DEREF_list (x732_ + 5);\ (case_labs_) = DEREF_list (x732_ + 6);\ (default_lab_) = DEREF_id (x732_ + 7);\ (exhaust_) = DEREF_int (x732_ + 8);\ (break_lab_) = DEREF_id (x732_ + 9);\ (destroyer_) (x732_, 10u);\ } /* Operations for field hash_if of union EXP */ #define exp_hash_if_tag 72u #define IS_exp_hash_if(P) (CHECK_NULL (P)->ag_tag == 72) #define exp_hash_if_parent(P) (CHECK_TAG ((P), 72) + 2) #define exp_hash_if_cond(P) (CHECK_TAG ((P), 72) + 3) #define exp_hash_if_true_code(P) (CHECK_TAG ((P), 72) + 4) #define exp_hash_if_false_code(P) (CHECK_TAG ((P), 72) + 5) #define exp_hash_if_last(P) (CHECK_TAG ((P), 72) + 6) #define MAKE_exp_hash_if(type_, cond_, true_code_, false_code_, c_class_exp)\ {\ c_class *x733_ = GEN_c_class ( 7, TYPEID_exp );\ x733_->ag_tag = 72;\ COPY_type (x733_ + 1, (type_));\ COPY_exp (x733_ + 2, NULL_exp);\ COPY_exp (x733_ + 3, (cond_));\ COPY_exp (x733_ + 4, (true_code_));\ COPY_exp (x733_ + 5, (false_code_));\ COPY_exp (x733_ + 6, NULL_exp);\ (c_class_exp) = x733_;\ } #define DECONS_exp_hash_if(type_, parent_, cond_, true_code_, false_code_, last_, c_class_exp)\ {\ c_class *x734_ = CHECK_TAG ((c_class_exp), 72);\ (type_) = DEREF_type (x734_ + 1);\ (parent_) = DEREF_exp (x734_ + 2);\ (cond_) = DEREF_exp (x734_ + 3);\ (true_code_) = DEREF_exp (x734_ + 4);\ (false_code_) = DEREF_exp (x734_ + 5);\ (last_) = DEREF_exp (x734_ + 6);\ } #define DESTROY_exp_hash_if(destroyer_, type_, parent_, cond_, true_code_, false_code_, last_, c_class_exp)\ {\ c_class *x735_ = CHECK_TAG ((c_class_exp), 72);\ (type_) = DEREF_type (x735_ + 1);\ (parent_) = DEREF_exp (x735_ + 2);\ (cond_) = DEREF_exp (x735_ + 3);\ (true_code_) = DEREF_exp (x735_ + 4);\ (false_code_) = DEREF_exp (x735_ + 5);\ (last_) = DEREF_exp (x735_ + 6);\ (destroyer_) (x735_, 7u);\ } /* Operations for field return_stmt of union EXP */ #define exp_return_stmt_tag 73u #define IS_exp_return_stmt(P) (CHECK_NULL (P)->ag_tag == 73) #define exp_return_stmt_parent(P) (CHECK_TAG ((P), 73) + 2) #define exp_return_stmt_value(P) (CHECK_TAG ((P), 73) + 3) #define MAKE_exp_return_stmt(type_, value_, c_class_exp)\ {\ c_class *x736_ = GEN_c_class ( 4, TYPEID_exp );\ x736_->ag_tag = 73;\ COPY_type (x736_ + 1, (type_));\ COPY_exp (x736_ + 2, NULL_exp);\ COPY_exp (x736_ + 3, (value_));\ (c_class_exp) = x736_;\ } #define DECONS_exp_return_stmt(type_, parent_, value_, c_class_exp)\ {\ c_class *x737_ = CHECK_TAG ((c_class_exp), 73);\ (type_) = DEREF_type (x737_ + 1);\ (parent_) = DEREF_exp (x737_ + 2);\ (value_) = DEREF_exp (x737_ + 3);\ } #define DESTROY_exp_return_stmt(destroyer_, type_, parent_, value_, c_class_exp)\ {\ c_class *x738_ = CHECK_TAG ((c_class_exp), 73);\ (type_) = DEREF_type (x738_ + 1);\ (parent_) = DEREF_exp (x738_ + 2);\ (value_) = DEREF_exp (x738_ + 3);\ (destroyer_) (x738_, 4u);\ } /* Operations for field goto_stmt of union EXP */ #define exp_goto_stmt_tag 74u #define IS_exp_goto_stmt(P) (CHECK_NULL (P)->ag_tag == 74) #define exp_goto_stmt_parent(P) (CHECK_TAG ((P), 74) + 2) #define exp_goto_stmt_label(P) (CHECK_TAG ((P), 74) + 3) #define exp_goto_stmt_join(P) (CHECK_TAG ((P), 74) + 4) #define exp_goto_stmt_next(P) (CHECK_TAG ((P), 74) + 5) #define MAKE_exp_goto_stmt(type_, label_, join_, next_, c_class_exp)\ {\ c_class *x739_ = GEN_c_class ( 6, TYPEID_exp );\ x739_->ag_tag = 74;\ COPY_type (x739_ + 1, (type_));\ COPY_exp (x739_ + 2, NULL_exp);\ COPY_id (x739_ + 3, (label_));\ COPY_exp (x739_ + 4, (join_));\ COPY_exp (x739_ + 5, (next_));\ (c_class_exp) = x739_;\ } #define DECONS_exp_goto_stmt(type_, parent_, label_, join_, next_, c_class_exp)\ {\ c_class *x740_ = CHECK_TAG ((c_class_exp), 74);\ (type_) = DEREF_type (x740_ + 1);\ (parent_) = DEREF_exp (x740_ + 2);\ (label_) = DEREF_id (x740_ + 3);\ (join_) = DEREF_exp (x740_ + 4);\ (next_) = DEREF_exp (x740_ + 5);\ } #define DESTROY_exp_goto_stmt(destroyer_, type_, parent_, label_, join_, next_, c_class_exp)\ {\ c_class *x741_ = CHECK_TAG ((c_class_exp), 74);\ (type_) = DEREF_type (x741_ + 1);\ (parent_) = DEREF_exp (x741_ + 2);\ (label_) = DEREF_id (x741_ + 3);\ (join_) = DEREF_exp (x741_ + 4);\ (next_) = DEREF_exp (x741_ + 5);\ (destroyer_) (x741_, 6u);\ } /* Operations for field label_stmt of union EXP */ #define exp_label_stmt_tag 75u #define IS_exp_label_stmt(P) (CHECK_NULL (P)->ag_tag == 75) #define exp_label_stmt_parent(P) (CHECK_TAG ((P), 75) + 2) #define exp_label_stmt_label(P) (CHECK_TAG ((P), 75) + 3) #define exp_label_stmt_body(P) (CHECK_TAG ((P), 75) + 4) #define exp_label_stmt_next(P) (CHECK_TAG ((P), 75) + 5) #define MAKE_exp_label_stmt(type_, label_, body_, c_class_exp)\ {\ c_class *x742_ = GEN_c_class ( 6, TYPEID_exp );\ x742_->ag_tag = 75;\ COPY_type (x742_ + 1, (type_));\ COPY_exp (x742_ + 2, NULL_exp);\ COPY_id (x742_ + 3, (label_));\ COPY_exp (x742_ + 4, (body_));\ COPY_id (x742_ + 5, NULL_id);\ (c_class_exp) = x742_;\ } #define DECONS_exp_label_stmt(type_, parent_, label_, body_, next_, c_class_exp)\ {\ c_class *x743_ = CHECK_TAG ((c_class_exp), 75);\ (type_) = DEREF_type (x743_ + 1);\ (parent_) = DEREF_exp (x743_ + 2);\ (label_) = DEREF_id (x743_ + 3);\ (body_) = DEREF_exp (x743_ + 4);\ (next_) = DEREF_id (x743_ + 5);\ } #define DESTROY_exp_label_stmt(destroyer_, type_, parent_, label_, body_, next_, c_class_exp)\ {\ c_class *x744_ = CHECK_TAG ((c_class_exp), 75);\ (type_) = DEREF_type (x744_ + 1);\ (parent_) = DEREF_exp (x744_ + 2);\ (label_) = DEREF_id (x744_ + 3);\ (body_) = DEREF_exp (x744_ + 4);\ (next_) = DEREF_id (x744_ + 5);\ (destroyer_) (x744_, 6u);\ } /* Operations for field try_block of union EXP */ #define exp_try_block_tag 76u #define IS_exp_try_block(P) (CHECK_NULL (P)->ag_tag == 76) #define exp_try_block_parent(P) (CHECK_TAG ((P), 76) + 2) #define exp_try_block_body(P) (CHECK_TAG ((P), 76) + 3) #define exp_try_block_func(P) (CHECK_TAG ((P), 76) + 4) #define exp_try_block_handlers(P) (CHECK_TAG ((P), 76) + 5) #define exp_try_block_htypes(P) (CHECK_TAG ((P), 76) + 6) #define exp_try_block_ellipsis(P) (CHECK_TAG ((P), 76) + 7) #define exp_try_block_ttypes(P) (CHECK_TAG ((P), 76) + 8) #define exp_try_block_tlocs(P) (CHECK_TAG ((P), 76) + 9) #define exp_try_block_no(P) (CHECK_TAG ((P), 76) + 10) #define MAKE_exp_try_block(type_, body_, func_, c_class_exp)\ {\ c_class *x745_ = GEN_c_class ( 11, TYPEID_exp );\ x745_->ag_tag = 76;\ COPY_type (x745_ + 1, (type_));\ COPY_exp (x745_ + 2, NULL_exp);\ COPY_exp (x745_ + 3, (body_));\ COPY_int (x745_ + 4, (func_));\ COPY_list (x745_ + 5, NULL_list ( EXP ));\ COPY_list (x745_ + 6, NULL_list ( TYPE ));\ COPY_exp (x745_ + 7, NULL_exp);\ COPY_list (x745_ + 8, NULL_list ( TYPE ));\ COPY_list (x745_ + 9, NULL_list ( LOCATION ));\ COPY_ulong (x745_ + 10, LINK_NONE);\ (c_class_exp) = x745_;\ } #define DECONS_exp_try_block(type_, parent_, body_, func_, handlers_, htypes_, ellipsis_, ttypes_, tlocs_, no_, c_class_exp)\ {\ c_class *x746_ = CHECK_TAG ((c_class_exp), 76);\ (type_) = DEREF_type (x746_ + 1);\ (parent_) = DEREF_exp (x746_ + 2);\ (body_) = DEREF_exp (x746_ + 3);\ (func_) = DEREF_int (x746_ + 4);\ (handlers_) = DEREF_list (x746_ + 5);\ (htypes_) = DEREF_list (x746_ + 6);\ (ellipsis_) = DEREF_exp (x746_ + 7);\ (ttypes_) = DEREF_list (x746_ + 8);\ (tlocs_) = DEREF_list (x746_ + 9);\ (no_) = DEREF_ulong (x746_ + 10);\ } #define DESTROY_exp_try_block(destroyer_, type_, parent_, body_, func_, handlers_, htypes_, ellipsis_, ttypes_, tlocs_, no_, c_class_exp)\ {\ c_class *x747_ = CHECK_TAG ((c_class_exp), 76);\ (type_) = DEREF_type (x747_ + 1);\ (parent_) = DEREF_exp (x747_ + 2);\ (body_) = DEREF_exp (x747_ + 3);\ (func_) = DEREF_int (x747_ + 4);\ (handlers_) = DEREF_list (x747_ + 5);\ (htypes_) = DEREF_list (x747_ + 6);\ (ellipsis_) = DEREF_exp (x747_ + 7);\ (ttypes_) = DEREF_list (x747_ + 8);\ (tlocs_) = DEREF_list (x747_ + 9);\ (no_) = DEREF_ulong (x747_ + 10);\ (destroyer_) (x747_, 11u);\ } /* Operations for field handler of union EXP */ #define exp_handler_tag 77u #define IS_exp_handler(P) (CHECK_NULL (P)->ag_tag == 77) #define exp_handler_parent(P) (CHECK_TAG ((P), 77) + 2) #define exp_handler_except(P) (CHECK_TAG ((P), 77) + 3) #define exp_handler_body(P) (CHECK_TAG ((P), 77) + 4) #define exp_handler_diag(P) (CHECK_TAG ((P), 77) + 5) #define MAKE_exp_handler(type_, except_, body_, c_class_exp)\ {\ c_class *x748_ = GEN_c_class ( 6, TYPEID_exp );\ x748_->ag_tag = 77;\ COPY_type (x748_ + 1, (type_));\ COPY_exp (x748_ + 2, NULL_exp);\ COPY_id (x748_ + 3, (except_));\ COPY_exp (x748_ + 4, (body_));\ COPY_ulong (x748_ + 5, LINK_NONE);\ (c_class_exp) = x748_;\ } #define DECONS_exp_handler(type_, parent_, except_, body_, diag_, c_class_exp)\ {\ c_class *x749_ = CHECK_TAG ((c_class_exp), 77);\ (type_) = DEREF_type (x749_ + 1);\ (parent_) = DEREF_exp (x749_ + 2);\ (except_) = DEREF_id (x749_ + 3);\ (body_) = DEREF_exp (x749_ + 4);\ (diag_) = DEREF_ulong (x749_ + 5);\ } #define DESTROY_exp_handler(destroyer_, type_, parent_, except_, body_, diag_, c_class_exp)\ {\ c_class *x750_ = CHECK_TAG ((c_class_exp), 77);\ (type_) = DEREF_type (x750_ + 1);\ (parent_) = DEREF_exp (x750_ + 2);\ (except_) = DEREF_id (x750_ + 3);\ (body_) = DEREF_exp (x750_ + 4);\ (diag_) = DEREF_ulong (x750_ + 5);\ (destroyer_) (x750_, 6u);\ } /* Operations for field exception of union EXP */ #define exp_exception_tag 78u #define IS_exp_exception(P) (CHECK_NULL (P)->ag_tag == 78) #define exp_exception_arg(P) (CHECK_TAG ((P), 78) + 2) #define exp_exception_size(P) (CHECK_TAG ((P), 78) + 3) #define exp_exception_destr(P) (CHECK_TAG ((P), 78) + 4) #define exp_exception_expl(P) (CHECK_TAG ((P), 78) + 5) #define MAKE_exp_exception(type_, arg_, size_, destr_, expl_, c_class_exp)\ {\ c_class *x751_ = GEN_c_class ( 6, TYPEID_exp );\ x751_->ag_tag = 78;\ COPY_type (x751_ + 1, (type_));\ COPY_exp (x751_ + 2, (arg_));\ COPY_exp (x751_ + 3, (size_));\ COPY_exp (x751_ + 4, (destr_));\ COPY_int (x751_ + 5, (expl_));\ (c_class_exp) = x751_;\ } #define DECONS_exp_exception(type_, arg_, size_, destr_, expl_, c_class_exp)\ {\ c_class *x752_ = CHECK_TAG ((c_class_exp), 78);\ (type_) = DEREF_type (x752_ + 1);\ (arg_) = DEREF_exp (x752_ + 2);\ (size_) = DEREF_exp (x752_ + 3);\ (destr_) = DEREF_exp (x752_ + 4);\ (expl_) = DEREF_int (x752_ + 5);\ } #define DESTROY_exp_exception(destroyer_, type_, arg_, size_, destr_, expl_, c_class_exp)\ {\ c_class *x753_ = CHECK_TAG ((c_class_exp), 78);\ (type_) = DEREF_type (x753_ + 1);\ (arg_) = DEREF_exp (x753_ + 2);\ (size_) = DEREF_exp (x753_ + 3);\ (destr_) = DEREF_exp (x753_ + 4);\ (expl_) = DEREF_int (x753_ + 5);\ (destroyer_) (x753_, 6u);\ } /* Operations for field thrown of union EXP */ #define exp_thrown_tag 79u #define IS_exp_thrown(P) (CHECK_NULL (P)->ag_tag == 79) #define exp_thrown_done(P) (CHECK_TAG ((P), 79) + 2) #define MAKE_exp_thrown(type_, done_, c_class_exp)\ {\ c_class *x754_ = GEN_c_class ( 3, TYPEID_exp );\ x754_->ag_tag = 79;\ COPY_type (x754_ + 1, (type_));\ COPY_int (x754_ + 2, (done_));\ (c_class_exp) = x754_;\ } #define DECONS_exp_thrown(type_, done_, c_class_exp)\ {\ c_class *x755_ = CHECK_TAG ((c_class_exp), 79);\ (type_) = DEREF_type (x755_ + 1);\ (done_) = DEREF_int (x755_ + 2);\ } #define DESTROY_exp_thrown(destroyer_, type_, done_, c_class_exp)\ {\ c_class *x756_ = CHECK_TAG ((c_class_exp), 79);\ (type_) = DEREF_type (x756_ + 1);\ (done_) = DEREF_int (x756_ + 2);\ (destroyer_) (x756_, 3u);\ } /* Operations for field op of union EXP */ #define exp_op_tag 80u #define IS_exp_op(P) (CHECK_NULL (P)->ag_tag == 80) #define exp_op_lex(P) (CHECK_TAG ((P), 80) + 2) #define exp_op_arg1(P) (CHECK_TAG ((P), 80) + 3) #define exp_op_arg2(P) (CHECK_TAG ((P), 80) + 4) #define MAKE_exp_op(type_, lex_, arg1_, arg2_, c_class_exp)\ {\ c_class *x757_ = GEN_c_class ( 5, TYPEID_exp );\ x757_->ag_tag = 80;\ COPY_type (x757_ + 1, (type_));\ COPY_int (x757_ + 2, (lex_));\ COPY_exp (x757_ + 3, (arg1_));\ COPY_exp (x757_ + 4, (arg2_));\ (c_class_exp) = x757_;\ } #define DECONS_exp_op(type_, lex_, arg1_, arg2_, c_class_exp)\ {\ c_class *x758_ = CHECK_TAG ((c_class_exp), 80);\ (type_) = DEREF_type (x758_ + 1);\ (lex_) = DEREF_int (x758_ + 2);\ (arg1_) = DEREF_exp (x758_ + 3);\ (arg2_) = DEREF_exp (x758_ + 4);\ } #define DESTROY_exp_op(destroyer_, type_, lex_, arg1_, arg2_, c_class_exp)\ {\ c_class *x759_ = CHECK_TAG ((c_class_exp), 80);\ (type_) = DEREF_type (x759_ + 1);\ (lex_) = DEREF_int (x759_ + 2);\ (arg1_) = DEREF_exp (x759_ + 3);\ (arg2_) = DEREF_exp (x759_ + 4);\ (destroyer_) (x759_, 5u);\ } /* Operations for field opn of union EXP */ #define exp_opn_tag 81u #define IS_exp_opn(P) (CHECK_NULL (P)->ag_tag == 81) #define exp_opn_lex(P) (CHECK_TAG ((P), 81) + 2) #define exp_opn_args(P) (CHECK_TAG ((P), 81) + 3) #define MAKE_exp_opn(type_, lex_, args_, c_class_exp)\ {\ c_class *x760_ = GEN_c_class ( 4, TYPEID_exp );\ x760_->ag_tag = 81;\ COPY_type (x760_ + 1, (type_));\ COPY_int (x760_ + 2, (lex_));\ COPY_list (x760_ + 3, (args_));\ (c_class_exp) = x760_;\ } #define DECONS_exp_opn(type_, lex_, args_, c_class_exp)\ {\ c_class *x761_ = CHECK_TAG ((c_class_exp), 81);\ (type_) = DEREF_type (x761_ + 1);\ (lex_) = DEREF_int (x761_ + 2);\ (args_) = DEREF_list (x761_ + 3);\ } #define DESTROY_exp_opn(destroyer_, type_, lex_, args_, c_class_exp)\ {\ c_class *x762_ = CHECK_TAG ((c_class_exp), 81);\ (type_) = DEREF_type (x762_ + 1);\ (lex_) = DEREF_int (x762_ + 2);\ (args_) = DEREF_list (x762_ + 3);\ (destroyer_) (x762_, 4u);\ } /* Operations for field assembler of union EXP */ #define exp_assembler_tag 82u #define IS_exp_assembler(P) (CHECK_NULL (P)->ag_tag == 82) #define exp_assembler_op(P) (CHECK_TAG ((P), 82) + 2) #define exp_assembler_args(P) (CHECK_TAG ((P), 82) + 3) #define MAKE_exp_assembler(type_, op_, args_, c_class_exp)\ {\ c_class *x763_ = GEN_c_class ( 4, TYPEID_exp );\ x763_->ag_tag = 82;\ COPY_type (x763_ + 1, (type_));\ COPY_str (x763_ + 2, (op_));\ COPY_list (x763_ + 3, (args_));\ (c_class_exp) = x763_;\ } #define DECONS_exp_assembler(type_, op_, args_, c_class_exp)\ {\ c_class *x764_ = CHECK_TAG ((c_class_exp), 82);\ (type_) = DEREF_type (x764_ + 1);\ (op_) = DEREF_str (x764_ + 2);\ (args_) = DEREF_list (x764_ + 3);\ } #define DESTROY_exp_assembler(destroyer_, type_, op_, args_, c_class_exp)\ {\ c_class *x765_ = CHECK_TAG ((c_class_exp), 82);\ (type_) = DEREF_type (x765_ + 1);\ (op_) = DEREF_str (x765_ + 2);\ (args_) = DEREF_list (x765_ + 3);\ (destroyer_) (x765_, 4u);\ } /* Operations for field uncompiled of union EXP */ #define exp_uncompiled_tag 83u #define IS_exp_uncompiled(P) (CHECK_NULL (P)->ag_tag == 83) #define exp_uncompiled_start(P) (CHECK_TAG ((P), 83) + 2) #define exp_uncompiled_defn(P) (CHECK_TAG ((P), 83) + 5) #define MAKE_exp_uncompiled(type_, start_, defn_, c_class_exp)\ {\ c_class *x766_ = GEN_c_class ( 6, TYPEID_exp );\ x766_->ag_tag = 83;\ COPY_type (x766_ + 1, (type_));\ COPY_ulong (x766_ + 2, (start_).line);\ COPY_ulong (x766_ + 3, (start_).column);\ COPY_ptr (x766_ + 4, (start_).posn);\ COPY_pptok (x766_ + 5, (defn_));\ (c_class_exp) = x766_;\ } #define DECONS_exp_uncompiled(type_, start_, defn_, c_class_exp)\ {\ c_class *x767_ = CHECK_TAG ((c_class_exp), 83);\ (type_) = DEREF_type (x767_ + 1);\ (start_).line = DEREF_ulong (x767_ + 2);\ (start_).column = DEREF_ulong (x767_ + 3);\ (start_).posn = DEREF_ptr (x767_ + 4);\ (defn_) = DEREF_pptok (x767_ + 5);\ } #define DESTROY_exp_uncompiled(destroyer_, type_, start_, defn_, c_class_exp)\ {\ c_class *x768_ = CHECK_TAG ((c_class_exp), 83);\ (type_) = DEREF_type (x768_ + 1);\ (start_).line = DEREF_ulong (x768_ + 2);\ (start_).column = DEREF_ulong (x768_ + 3);\ (start_).posn = DEREF_ptr (x768_ + 4);\ (defn_) = DEREF_pptok (x768_ + 5);\ (destroyer_) (x768_, 6u);\ } /* Operations for field location of union EXP */ #define exp_location_tag 84u #define IS_exp_location(P) (CHECK_NULL (P)->ag_tag == 84) #define exp_location_end(P) (CHECK_TAG ((P), 84) + 2) #define exp_location_arg(P) (CHECK_TAG ((P), 84) + 5) #define MAKE_exp_location(type_, end_, arg_, c_class_exp)\ {\ c_class *x769_ = GEN_c_class ( 6, TYPEID_exp );\ x769_->ag_tag = 84;\ COPY_type (x769_ + 1, (type_));\ COPY_ulong (x769_ + 2, (end_).line);\ COPY_ulong (x769_ + 3, (end_).column);\ COPY_ptr (x769_ + 4, (end_).posn);\ COPY_exp (x769_ + 5, (arg_));\ (c_class_exp) = x769_;\ } #define DECONS_exp_location(type_, end_, arg_, c_class_exp)\ {\ c_class *x770_ = CHECK_TAG ((c_class_exp), 84);\ (type_) = DEREF_type (x770_ + 1);\ (end_).line = DEREF_ulong (x770_ + 2);\ (end_).column = DEREF_ulong (x770_ + 3);\ (end_).posn = DEREF_ptr (x770_ + 4);\ (arg_) = DEREF_exp (x770_ + 5);\ } #define DESTROY_exp_location(destroyer_, type_, end_, arg_, c_class_exp)\ {\ c_class *x771_ = CHECK_TAG ((c_class_exp), 84);\ (type_) = DEREF_type (x771_ + 1);\ (end_).line = DEREF_ulong (x771_ + 2);\ (end_).column = DEREF_ulong (x771_ + 3);\ (end_).posn = DEREF_ptr (x771_ + 4);\ (arg_) = DEREF_exp (x771_ + 5);\ (destroyer_) (x771_, 6u);\ } /* Operations for field fail of union EXP */ #define exp_fail_tag 85u #define IS_exp_fail(P) (CHECK_NULL (P)->ag_tag == 85) #define exp_fail_msg(P) (CHECK_TAG ((P), 85) + 2) #define MAKE_exp_fail(type_, msg_, c_class_exp)\ {\ c_class *x772_ = GEN_c_class ( 3, TYPEID_exp );\ x772_->ag_tag = 85;\ COPY_type (x772_ + 1, (type_));\ COPY_string (x772_ + 2, (msg_));\ (c_class_exp) = x772_;\ } #define DECONS_exp_fail(type_, msg_, c_class_exp)\ {\ c_class *x773_ = CHECK_TAG ((c_class_exp), 85);\ (type_) = DEREF_type (x773_ + 1);\ (msg_) = DEREF_string (x773_ + 2);\ } #define DESTROY_exp_fail(destroyer_, type_, msg_, c_class_exp)\ {\ c_class *x774_ = CHECK_TAG ((c_class_exp), 85);\ (type_) = DEREF_type (x774_ + 1);\ (msg_) = DEREF_string (x774_ + 2);\ (destroyer_) (x774_, 3u);\ } /* Operations for field token of union EXP */ #define exp_token_tag 86u #define IS_exp_token(P) (CHECK_NULL (P)->ag_tag == 86) #define exp_token_parent(P) (CHECK_TAG ((P), 86) + 2) #define exp_token_tok(P) (CHECK_TAG ((P), 86) + 3) #define exp_token_args(P) (CHECK_TAG ((P), 86) + 4) #define MAKE_exp_token(type_, tok_, args_, c_class_exp)\ {\ c_class *x775_ = GEN_c_class ( 5, TYPEID_exp );\ x775_->ag_tag = 86;\ COPY_type (x775_ + 1, (type_));\ COPY_exp (x775_ + 2, NULL_exp);\ COPY_id (x775_ + 3, (tok_));\ COPY_list (x775_ + 4, (args_));\ (c_class_exp) = x775_;\ } #define DECONS_exp_token(type_, parent_, tok_, args_, c_class_exp)\ {\ c_class *x776_ = CHECK_TAG ((c_class_exp), 86);\ (type_) = DEREF_type (x776_ + 1);\ (parent_) = DEREF_exp (x776_ + 2);\ (tok_) = DEREF_id (x776_ + 3);\ (args_) = DEREF_list (x776_ + 4);\ } #define DESTROY_exp_token(destroyer_, type_, parent_, tok_, args_, c_class_exp)\ {\ c_class *x777_ = CHECK_TAG ((c_class_exp), 86);\ (type_) = DEREF_type (x777_ + 1);\ (parent_) = DEREF_exp (x777_ + 2);\ (tok_) = DEREF_id (x777_ + 3);\ (args_) = DEREF_list (x777_ + 4);\ (destroyer_) (x777_, 5u);\ } /* Operations for field dummy of union EXP */ #define exp_dummy_tag 87u #define IS_exp_dummy(P) (CHECK_NULL (P)->ag_tag == 87) #define exp_dummy_value(P) (CHECK_TAG ((P), 87) + 2) #define exp_dummy_no(P) (CHECK_TAG ((P), 87) + 3) #define exp_dummy_off(P) (CHECK_TAG ((P), 87) + 4) #define exp_dummy_virt(P) (CHECK_TAG ((P), 87) + 5) #define exp_dummy_cont(P) (CHECK_TAG ((P), 87) + 6) #define MAKE_exp_dummy(type_, value_, no_, off_, cont_, c_class_exp)\ {\ c_class *x778_ = GEN_c_class ( 7, TYPEID_exp );\ x778_->ag_tag = 87;\ COPY_type (x778_ + 1, (type_));\ COPY_exp (x778_ + 2, (value_));\ COPY_ulong (x778_ + 3, (no_));\ COPY_off (x778_ + 4, (off_));\ COPY_int (x778_ + 5, 0);\ COPY_int (x778_ + 6, (cont_));\ (c_class_exp) = x778_;\ } #define DECONS_exp_dummy(type_, value_, no_, off_, virt_, cont_, c_class_exp)\ {\ c_class *x779_ = CHECK_TAG ((c_class_exp), 87);\ (type_) = DEREF_type (x779_ + 1);\ (value_) = DEREF_exp (x779_ + 2);\ (no_) = DEREF_ulong (x779_ + 3);\ (off_) = DEREF_off (x779_ + 4);\ (virt_) = DEREF_int (x779_ + 5);\ (cont_) = DEREF_int (x779_ + 6);\ } #define DESTROY_exp_dummy(destroyer_, type_, value_, no_, off_, virt_, cont_, c_class_exp)\ {\ c_class *x780_ = CHECK_TAG ((c_class_exp), 87);\ (type_) = DEREF_type (x780_ + 1);\ (value_) = DEREF_exp (x780_ + 2);\ (no_) = DEREF_ulong (x780_ + 3);\ (off_) = DEREF_off (x780_ + 4);\ (virt_) = DEREF_int (x780_ + 5);\ (cont_) = DEREF_int (x780_ + 6);\ (destroyer_) (x780_, 7u);\ } #endif