Subversion Repositories tendra.SVN

/*
                 Crown Copyright (c) 1997
    
    This TenDRA(r) Computer Program is subject to Copyright
    owned by the United Kingdom Secretary of State for Defence
    acting through the Defence Evaluation and Research Agency
    (DERA).  It is made available to Recipients with a
    royalty-free licence for its use, reproduction, transfer
    to other parties and amendment for any purpose not excluding
    product development provided that any such use et cetera
    shall be deemed to be acceptance of the following conditions:-
    
        (1) Its Recipients shall ensure that this Notice is
        reproduced upon any copies or amended versions of it;
    
        (2) Any amended version of it shall be clearly marked to
        show both the nature of and the organisation responsible
        for the relevant amendment or amendments;
    
        (3) Its onward transfer from a recipient to another
        party shall be deemed to be that party's acceptance of
        these conditions;
    
        (4) DERA gives no warranty or assurance as to its
        quality or suitability for any purpose and DERA accepts
        no liability whatsoever in relation to any use to which
        it may be put.
*/


/* AUTOMATICALLY GENERATED BY make_tdf VERSION 2.0 FROM TDF 4.0 */

#include "config.h"
#include "encodings.h"
#include "enc_nos.h"
#include "defs.h"
#include "analyse_sort.h"
#include "consfile.h"
#include "lex.h"
#include "syntax.h"

void c_add_accesses
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_add_accesses (
        read_access () ; skip_term ( lex_comma ),
        read_access () ; skip_term ( lex_crd )
    )
    return ;
}

void c_constant
    PROTO_Z ()
{
    o_constant ;
    return ;
}

void c_long_jump_access
    PROTO_Z ()
{
    o_long_jump_access ;
    return ;
}

void c_no_other_read
    PROTO_Z ()
{
    o_no_other_read ;
    return ;
}

void c_no_other_write
    PROTO_Z ()
{
    o_no_other_write ;
    return ;
}

void c_out_par
    PROTO_Z ()
{
    o_out_par ;
    return ;
}

void c_preserve
    PROTO_Z ()
{
    o_preserve ;
    return ;
}

void c_register
    PROTO_Z ()
{
    o_register ;
    return ;
}

void c_standard_access
    PROTO_Z ()
{
    o_standard_access ;
    return ;
}

void c_used_as_volatile
    PROTO_Z ()
{
    o_used_as_volatile ;
    return ;
}

void c_visible
    PROTO_Z ()
{
    o_visible ;
    return ;
}

void c_alignment
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_alignment (
        read_shape () ; skip_term ( lex_crd )
    )
    return ;
}

void c_alloca_alignment
    PROTO_Z ()
{
    o_alloca_alignment ;
    return ;
}

void c_callees_alignment
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_callees_alignment (
        read_bool () ; skip_term ( lex_crd )
    )
    return ;
}

void c_callers_alignment
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_callers_alignment (
        read_bool () ; skip_term ( lex_crd )
    )
    return ;
}

void c_code_alignment
    PROTO_Z ()
{
    o_code_alignment ;
    return ;
}

void c_locals_alignment
    PROTO_Z ()
{
    o_locals_alignment ;
    return ;
}

void c_parameter_alignment
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_parameter_alignment (
        read_shape () ; skip_term ( lex_crd )
    )
    return ;
}

void c_unite_alignments
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_unite_alignments (
        read_alignment () ; skip_term ( lex_comma ),
        read_alignment () ; skip_term ( lex_crd )
    )
    return ;
}

void c_var_param_alignment
    PROTO_Z ()
{
    o_var_param_alignment ;
    return ;
}

void c_bfvar_bits
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_bfvar_bits (
        read_bool () ; skip_term ( lex_comma ),
        read_nat () ; skip_term ( lex_crd )
    )
    return ;
}

void c_false
    PROTO_Z ()
{
    o_false ;
    return ;
}

void c_true
    PROTO_Z ()
{
    o_true ;
    return ;
}

void c_nil_access
    PROTO_Z ()
{
    o_nil_access ;
    return ;
}

void c_overflow
    PROTO_Z ()
{
    o_overflow ;
    return ;
}

void c_stack_overflow
    PROTO_Z ()
{
    o_stack_overflow ;
    return ;
}

void c_continue
    PROTO_Z ()
{
    o_continue ;
    return ;
}

void c_trap
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_trap (
        read_error_code_list () ; skip_term ( lex_crd )
    )
    return ;
}

void c_wrap
    PROTO_Z ()
{
    o_wrap ;
    return ;
}

void c_impossible
    PROTO_Z ()
{
    o_impossible ;
    return ;
}

void c_abs
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_abs (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_add_to_ptr
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_add_to_ptr (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_and
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_and (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_assign
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_assign (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_assign_with_mode
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_assign_with_mode (
        read_transfer_mode () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_bitfield_assign
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_bitfield_assign (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_bitfield_assign_with_mode
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_bitfield_assign_with_mode (
        read_transfer_mode () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_bitfield_contents
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_bitfield_contents (
        read_bitfield_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_bitfield_contents_with_mode
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_bitfield_contents_with_mode (
        read_transfer_mode () ; skip_term ( lex_comma ),
        read_bitfield_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_change_bitfield_to_int
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_change_bitfield_to_int (
        read_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_change_floating_variety
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_change_floating_variety (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_floating_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_change_variety
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_change_variety (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_change_int_to_bitfield
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_change_int_to_bitfield (
        read_bitfield_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_complex_conjugate
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_complex_conjugate (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_component
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_component (
        read_shape () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_concat_nof
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_concat_nof (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_conditional
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_conditional (
        read_label () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_contents
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_contents (
        read_shape () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_contents_with_mode
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_contents_with_mode (
        read_transfer_mode () ; skip_term ( lex_comma ),
        read_shape () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_current_env
    PROTO_Z ()
{
    o_current_env ;
    return ;
}

void c_div0
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_div0 (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_div1
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_div1 (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_div2
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_div2 (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_env_offset
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_env_offset (
        read_alignment () ; skip_term ( lex_comma ),
        read_alignment () ; skip_term ( lex_comma ),
        read_tag () ; skip_term ( lex_crd )
    )
    return ;
}

void c_env_size
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_env_size (
        read_tag () ; skip_term ( lex_crd )
    )
    return ;
}

void c_fail_installer
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_fail_installer (
        read_string () ; skip_term ( lex_crd )
    )
    return ;
}

void c_float_int
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_float_int (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_floating_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_abs
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_abs (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_div
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_div (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_minus
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_minus (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_maximum
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_maximum (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_minimum
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_minimum (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_mult
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_mult (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp_list () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_negate
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_negate (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_plus
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_plus (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp_list () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_power
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_power (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating_test
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating_test (
        read_nat_option () ; skip_term ( lex_comma ),
        read_error_treatment () ; skip_term ( lex_comma ),
        read_ntest () ; skip_term ( lex_comma ),
        read_label () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_goto
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_goto (
        read_label () ; skip_term ( lex_crd )
    )
    return ;
}

void c_goto_local_lv
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_goto_local_lv (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_ignorable
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_ignorable (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_imaginary_part
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_imaginary_part (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_initial_value
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_initial_value (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_integer_test
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_integer_test (
        read_nat_option () ; skip_term ( lex_comma ),
        read_ntest () ; skip_term ( lex_comma ),
        read_label () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_last_local
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_last_local (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_local_alloc
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_local_alloc (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_local_alloc_check
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_local_alloc_check (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_local_free
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_local_free (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_local_free_all
    PROTO_Z ()
{
    o_local_free_all ;
    return ;
}

void c_long_jump
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_long_jump (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_make_complex
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_make_complex (
        read_floating_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_make_compound
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_make_compound (
        read_exp () ; skip_term ( lex_comma ),
        read_exp_list () ; skip_term ( lex_crd )
    )
    return ;
}

void c_make_local_lv
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_make_local_lv (
        read_label () ; skip_term ( lex_crd )
    )
    return ;
}

void c_make_nof
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_make_nof (
        read_exp_list () ; skip_term ( lex_crd )
    )
    return ;
}

void c_make_nof_int
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_make_nof_int (
        read_variety () ; skip_term ( lex_comma ),
        read_string () ; skip_term ( lex_crd )
    )
    return ;
}

void c_make_null_local_lv
    PROTO_Z ()
{
    o_make_null_local_lv ;
    return ;
}

void c_make_null_proc
    PROTO_Z ()
{
    o_make_null_proc ;
    return ;
}

void c_make_null_ptr
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_make_null_ptr (
        read_alignment () ; skip_term ( lex_crd )
    )
    return ;
}

void c_make_stack_limit
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_make_stack_limit (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_make_top
    PROTO_Z ()
{
    o_make_top ;
    return ;
}

void c_make_value
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_make_value (
        read_shape () ; skip_term ( lex_crd )
    )
    return ;
}

void c_maximum
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_maximum (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_minimum
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_minimum (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_minus
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_minus (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_move_some
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_move_some (
        read_transfer_mode () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_mult
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_mult (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_n_copies
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_n_copies (
        read_nat () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_negate
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_negate (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_not
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_not (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_add
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_add (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_div
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_div (
        read_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_div_by_int
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_div_by_int (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_max
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_max (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_mult
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_mult (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_negate
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_negate (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_pad
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_pad (
        read_alignment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_subtract
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_subtract (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_test
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_test (
        read_nat_option () ; skip_term ( lex_comma ),
        read_ntest () ; skip_term ( lex_comma ),
        read_label () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset_zero
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset_zero (
        read_alignment () ; skip_term ( lex_crd )
    )
    return ;
}

void c_or
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_or (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_plus
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_plus (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_pointer_test
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_pointer_test (
        read_nat_option () ; skip_term ( lex_comma ),
        read_ntest () ; skip_term ( lex_comma ),
        read_label () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_power
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_power (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_proc_test
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_proc_test (
        read_nat_option () ; skip_term ( lex_comma ),
        read_ntest () ; skip_term ( lex_comma ),
        read_label () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_profile
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_profile (
        read_nat () ; skip_term ( lex_crd )
    )
    return ;
}

void c_real_part
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_real_part (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_rem0
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_rem0 (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_rem1
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_rem1 (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_rem2
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_rem2 (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_repeat
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_repeat (
        read_label () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_return
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_return (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_return_to_label
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_return_to_label (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_round_with_mode
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_round_with_mode (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_rounding_mode () ; skip_term ( lex_comma ),
        read_variety () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_rotate_left
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_rotate_left (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_rotate_right
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_rotate_right (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_set_stack_limit
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_set_stack_limit (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_shape_offset
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_shape_offset (
        read_shape () ; skip_term ( lex_crd )
    )
    return ;
}

void c_shift_left
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_shift_left (
        read_error_treatment () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_shift_right
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_shift_right (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_subtract_ptrs
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_subtract_ptrs (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_untidy_return
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_untidy_return (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_xor
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_xor (
        read_exp () ; skip_term ( lex_comma ),
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_flvar_parms
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_flvar_parms (
        read_nat () ; skip_term ( lex_comma ),
        read_nat () ; skip_term ( lex_comma ),
        read_nat () ; skip_term ( lex_comma ),
        read_nat () ; skip_term ( lex_crd )
    )
    return ;
}

void c_complex_parms
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_complex_parms (
        read_nat () ; skip_term ( lex_comma ),
        read_nat () ; skip_term ( lex_comma ),
        read_nat () ; skip_term ( lex_comma ),
        read_nat () ; skip_term ( lex_crd )
    )
    return ;
}

void c_float_of_complex
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_float_of_complex (
        read_shape () ; skip_term ( lex_crd )
    )
    return ;
}

void c_complex_of_float
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_complex_of_float (
        read_shape () ; skip_term ( lex_crd )
    )
    return ;
}

void c_computed_nat
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_computed_nat (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_error_val
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_error_val (
        read_error_code () ; skip_term ( lex_crd )
    )
    return ;
}

void c_equal
    PROTO_Z ()
{
    o_equal ;
    return ;
}

void c_greater_than
    PROTO_Z ()
{
    o_greater_than ;
    return ;
}

void c_greater_than_or_equal
    PROTO_Z ()
{
    o_greater_than_or_equal ;
    return ;
}

void c_less_than
    PROTO_Z ()
{
    o_less_than ;
    return ;
}

void c_less_than_or_equal
    PROTO_Z ()
{
    o_less_than_or_equal ;
    return ;
}

void c_not_equal
    PROTO_Z ()
{
    o_not_equal ;
    return ;
}

void c_not_greater_than
    PROTO_Z ()
{
    o_not_greater_than ;
    return ;
}

void c_not_greater_than_or_equal
    PROTO_Z ()
{
    o_not_greater_than_or_equal ;
    return ;
}

void c_not_less_than
    PROTO_Z ()
{
    o_not_less_than ;
    return ;
}

void c_not_less_than_or_equal
    PROTO_Z ()
{
    o_not_less_than_or_equal ;
    return ;
}

void c_less_than_or_greater_than
    PROTO_Z ()
{
    o_less_than_or_greater_than ;
    return ;
}

void c_not_less_than_and_not_greater_than
    PROTO_Z ()
{
    o_not_less_than_and_not_greater_than ;
    return ;
}

void c_comparable
    PROTO_Z ()
{
    o_comparable ;
    return ;
}

void c_not_comparable
    PROTO_Z ()
{
    o_not_comparable ;
    return ;
}

void c_round_as_state
    PROTO_Z ()
{
    o_round_as_state ;
    return ;
}

void c_to_nearest
    PROTO_Z ()
{
    o_to_nearest ;
    return ;
}

void c_toward_larger
    PROTO_Z ()
{
    o_toward_larger ;
    return ;
}

void c_toward_smaller
    PROTO_Z ()
{
    o_toward_smaller ;
    return ;
}

void c_toward_zero
    PROTO_Z ()
{
    o_toward_zero ;
    return ;
}

void c_bitfield
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_bitfield (
        read_bitfield_variety () ; skip_term ( lex_crd )
    )
    return ;
}

void c_bottom
    PROTO_Z ()
{
    o_bottom ;
    return ;
}

void c_compound
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_compound (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_floating
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_floating (
        read_floating_variety () ; skip_term ( lex_crd )
    )
    return ;
}

void c_integer
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_integer (
        read_variety () ; skip_term ( lex_crd )
    )
    return ;
}

void c_nof
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_nof (
        read_nat () ; skip_term ( lex_comma ),
        read_shape () ; skip_term ( lex_crd )
    )
    return ;
}

void c_offset
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_offset (
        read_alignment () ; skip_term ( lex_comma ),
        read_alignment () ; skip_term ( lex_crd )
    )
    return ;
}

void c_pointer
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_pointer (
        read_alignment () ; skip_term ( lex_crd )
    )
    return ;
}

void c_proc
    PROTO_Z ()
{
    o_proc ;
    return ;
}

void c_top
    PROTO_Z ()
{
    o_top ;
    return ;
}

void c_computed_signed_nat
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_computed_signed_nat (
        read_exp () ; skip_term ( lex_crd )
    )
    return ;
}

void c_make_signed_nat
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_make_signed_nat (
        read_tdfbool () ; skip_term ( lex_comma ),
        read_tdfint () ; skip_term ( lex_crd )
    )
    return ;
}

void c_snat_from_nat
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_snat_from_nat (
        read_bool () ; skip_term ( lex_comma ),
        read_nat () ; skip_term ( lex_crd )
    )
    return ;
}

void c_add_modes
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_add_modes (
        read_transfer_mode () ; skip_term ( lex_comma ),
        read_transfer_mode () ; skip_term ( lex_crd )
    )
    return ;
}

void c_overlap
    PROTO_Z ()
{
    o_overlap ;
    return ;
}

void c_standard_transfer_mode
    PROTO_Z ()
{
    o_standard_transfer_mode ;
    return ;
}

void c_trap_on_nil
    PROTO_Z ()
{
    o_trap_on_nil ;
    return ;
}

void c_volatile
    PROTO_Z ()
{
    o_volatile ;
    return ;
}

void c_complete
    PROTO_Z ()
{
    o_complete ;
    return ;
}

void c_var_limits
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_var_limits (
        read_signed_nat () ; skip_term ( lex_comma ),
        read_signed_nat () ; skip_term ( lex_crd )
    )
    return ;
}

void c_var_width
    PROTO_Z ()
{
    skip_term ( lex_ord ) ;
    o_var_width (
        read_bool () ; skip_term ( lex_comma ),
        read_nat () ; skip_term ( lex_crd )
    )
    return ;
}