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


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

bool_option no_bool_option;

bool_option
yes_bool_option(bool elem)
{
    UNUSED (elem);
    return (f_dummy_bool_option);
}

void
init_bool_option(void)
{
    return;
}

dg_accessibility f_dg_local_accessibility;

dg_accessibility f_dg_private_accessibility;

dg_accessibility f_dg_protected_accessibility;

dg_accessibility f_dg_public_accessibility;

dg_accessibility f_dummy_dg_accessibility;

void
init_dg_accessibility(void)
{
    return;
}

dg_accessibility_option no_dg_accessibility_option;

dg_accessibility_option
yes_dg_accessibility_option(dg_accessibility elem)
{
    UNUSED (elem);
    return (f_dummy_dg_accessibility_option);
}

void
init_dg_accessibility_option(void)
{
    return;
}

dg_append
f_dg_name_append(dg_tag tg, dg_name name)
{
    UNUSED (tg);
    UNUSED (name);
    return (f_dummy_dg_append);
}

dg_append f_dummy_dg_append;

void
init_dg_append(void)
{
    return;
}

dg_append_list
new_dg_append_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_append_list);
}

dg_append_list
add_dg_append_list(dg_append_list list, dg_append elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_append_list);
}

void
init_dg_append_list(void)
{
    return;
}

dg_bound
f_dg_dynamic_bound(dg_tag bound, shape sh)
{
    UNUSED (bound);
    UNUSED (sh);
    return (f_dummy_dg_bound);
}

dg_bound
f_dg_static_bound(exp bound)
{
    UNUSED (bound);
    return (f_dummy_dg_bound);
}

dg_bound
f_dg_unknown_bound(shape sh)
{
    UNUSED (sh);
    return (f_dummy_dg_bound);
}

dg_bound f_dummy_dg_bound;

void
init_dg_bound(void)
{
    return;
}

dg_class_base
f_make_dg_class_base(dg_tag base, dg_sourcepos_option whence, token_option location, dg_accessibility_option accessibility, dg_virtuality_option virtuality)
{
    UNUSED (base);
    UNUSED (whence);
    UNUSED (location);
    UNUSED (accessibility);
    UNUSED (virtuality);
    return (f_dummy_dg_class_base);
}

dg_class_base f_dummy_dg_class_base;

void
init_dg_class_base(void)
{
    return;
}

dg_class_base_list
new_dg_class_base_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_class_base_list);
}

dg_class_base_list
add_dg_class_base_list(dg_class_base_list list, dg_class_base elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_class_base_list);
}

void
init_dg_class_base_list(void)
{
    return;
}

dg_classmem
f_dg_tag_classmem(dg_tag tg, dg_classmem mem)
{
    UNUSED (tg);
    UNUSED (mem);
    return (f_dummy_dg_classmem);
}

dg_classmem
f_dg_field_classmem(dg_idname idname, dg_sourcepos src_pos, exp offset, dg_type field_type, dg_accessibility_option accessibility, bool_option discr, dg_default_option deflt)
{
    UNUSED (idname);
    UNUSED (src_pos);
    UNUSED (offset);
    UNUSED (field_type);
    UNUSED (accessibility);
    UNUSED (discr);
    UNUSED (deflt);
    return (f_dummy_dg_classmem);
}

dg_classmem
f_dg_function_classmem(dg_name fn, exp_option vtable_slot)
{
    UNUSED (fn);
    UNUSED (vtable_slot);
    return (f_dummy_dg_classmem);
}

dg_classmem
f_dg_indirect_classmem(dg_idname idname, dg_sourcepos src_pos, token location, dg_type cmem_type)
{
    UNUSED (idname);
    UNUSED (src_pos);
    UNUSED (location);
    UNUSED (cmem_type);
    return (f_dummy_dg_classmem);
}

dg_classmem
f_dg_name_classmem(dg_name name)
{
    UNUSED (name);
    return (f_dummy_dg_classmem);
}

dg_classmem f_dummy_dg_classmem;

void
init_dg_classmem(void)
{
    return;
}

dg_classmem_list
new_dg_classmem_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_classmem_list);
}

dg_classmem_list
add_dg_classmem_list(dg_classmem_list list, dg_classmem elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_classmem_list);
}

void
init_dg_classmem_list(void)
{
    return;
}

dg_comp_props
f_make_dg_compunit(tdfint no_labels, dg_compilation comp_unit, dg_append_list l)
{
    UNUSED (no_labels);
    UNUSED (comp_unit);
    UNUSED (l);
    return (f_dummy_dg_comp_props);
}

dg_comp_props f_dummy_dg_comp_props;

void
init_dg_comp_props(void)
{
    return;
}

dg_compilation
f_dg_tag_compilation(dg_tag tg, dg_compilation comp)
{
    UNUSED (tg);
    UNUSED (comp);
    return (f_dummy_dg_compilation);
}

dg_compilation
f_make_dg_compilation(dg_filename primary_file, string_list comp_unit_deps, dg_macro_list macros, dg_filename comp_dir, nat date, nat language, nat id_case, string producer, string_list options, dg_namelist dnames)
{
    UNUSED (primary_file);
    UNUSED (comp_unit_deps);
    UNUSED (macros);
    UNUSED (comp_dir);
    UNUSED (date);
    UNUSED (language);
    UNUSED (id_case);
    UNUSED (producer);
    UNUSED (options);
    UNUSED (dnames);
    return (f_dummy_dg_compilation);
}

dg_compilation f_dummy_dg_compilation;

void
init_dg_compilation(void)
{
    return;
}

dg_constraint
f_dg_type_constraint(dg_tag_option ref_member, dg_type type)
{
    UNUSED (ref_member);
    UNUSED (type);
    return (f_dummy_dg_constraint);
}

dg_constraint
f_dg_value_constraint(dg_tag_option ref_member, exp value)
{
    UNUSED (ref_member);
    UNUSED (value);
    return (f_dummy_dg_constraint);
}

dg_constraint f_dummy_dg_constraint;

void
init_dg_constraint(void)
{
    return;
}

dg_constraint_list
new_dg_constraint_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_constraint_list);
}

dg_constraint_list
add_dg_constraint_list(dg_constraint_list list, dg_constraint elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_constraint_list);
}

void
init_dg_constraint_list(void)
{
    return;
}

dg_constraint_list_option no_dg_constraint_list_option;

dg_constraint_list_option
yes_dg_constraint_list_option(dg_constraint_list elem)
{
    UNUSED (elem);
    return (f_dummy_dg_constraint_list_option);
}

void
init_dg_constraint_list_option(void)
{
    return;
}

dg_default
f_make_dg_default(exp_option value, dg_sourcepos_option src_span)
{
    UNUSED (value);
    UNUSED (src_span);
    return (f_dummy_dg_default);
}

dg_default f_dummy_dg_default;

void
init_dg_default(void)
{
    return;
}

dg_default_option no_dg_default_option;

dg_default_option
yes_dg_default_option(dg_default elem)
{
    UNUSED (elem);
    return (f_dummy_dg_default_option);
}

void
init_dg_default_option(void)
{
    return;
}

dg_dim
f_dg_dim_apply_token(token token_value, bitstream token_args)
{
    UNUSED (token_value);
    UNUSED (token_args);
    return (f_dummy_dg_dim);
}

dg_dim
f_dg_tag_dim(dg_tag tg, dg_dim d)
{
    UNUSED (tg);
    UNUSED (d);
    return (f_dummy_dg_dim);
}

dg_dim
f_dg_bounds_dim(dg_bound low, dg_bound high, dg_type index_type)
{
    UNUSED (low);
    UNUSED (high);
    UNUSED (index_type);
    return (f_dummy_dg_dim);
}

dg_dim
f_dg_count_dim(dg_bound low, dg_bound count, dg_type index_type)
{
    UNUSED (low);
    UNUSED (count);
    UNUSED (index_type);
    return (f_dummy_dg_dim);
}

dg_dim
f_dg_type_dim(dg_type type, nat_option n)
{
    UNUSED (type);
    UNUSED (n);
    return (f_dummy_dg_dim);
}

dg_dim f_dg_unspecified_dim;

dg_dim f_dummy_dg_dim;

void
init_dg_dim(void)
{
    return;
}

dg_dim_list
new_dg_dim_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_dim_list);
}

dg_dim_list
add_dg_dim_list(dg_dim_list list, dg_dim elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_dim_list);
}

void
init_dg_dim_list(void)
{
    return;
}

dg_dim_option no_dg_dim_option;

dg_dim_option
yes_dg_dim_option(dg_dim elem)
{
    UNUSED (elem);
    return (f_dummy_dg_dim_option);
}

void
init_dg_dim_option(void)
{
    return;
}

dg_discrim
f_make_dg_discrim(exp lower, exp upper)
{
    UNUSED (lower);
    UNUSED (upper);
    return (f_dummy_dg_discrim);
}

dg_discrim f_dummy_dg_discrim;

void
init_dg_discrim(void)
{
    return;
}

dg_discrim_list
new_dg_discrim_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_discrim_list);
}

dg_discrim_list
add_dg_discrim_list(dg_discrim_list list, dg_discrim elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_discrim_list);
}

void
init_dg_discrim_list(void)
{
    return;
}

dg_enum
f_dg_tag_enum(dg_tag tg, dg_enum e)
{
    UNUSED (tg);
    UNUSED (e);
    return (f_dummy_dg_enum);
}

dg_enum
f_make_dg_enum(exp value, dg_idname idname, dg_sourcepos src_pos)
{
    UNUSED (value);
    UNUSED (idname);
    UNUSED (src_pos);
    return (f_dummy_dg_enum);
}

dg_enum
f_dg_char_enum(exp value, nat idchar, dg_sourcepos src_pos)
{
    UNUSED (value);
    UNUSED (idchar);
    UNUSED (src_pos);
    return (f_dummy_dg_enum);
}

dg_enum f_dummy_dg_enum;

void
init_dg_enum(void)
{
    return;
}

dg_enum_list
new_dg_enum_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_enum_list);
}

dg_enum_list
add_dg_enum_list(dg_enum_list list, dg_enum elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_enum_list);
}

void
init_dg_enum_list(void)
{
    return;
}

dg_filename
f_dg_filename_apply_token(token token_value, bitstream token_args)
{
    UNUSED (token_value);
    UNUSED (token_args);
    return (f_dummy_dg_filename);
}

dg_filename
f_make_dg_filename(nat date, string machine, string path, string file)
{
    UNUSED (date);
    UNUSED (machine);
    UNUSED (path);
    UNUSED (file);
    return (f_dummy_dg_filename);
}

dg_filename f_dummy_dg_filename;

void
init_dg_filename(void)
{
    return;
}

dg_filename_option no_dg_filename_option;

dg_filename_option
yes_dg_filename_option(dg_filename elem)
{
    UNUSED (elem);
    return (f_dummy_dg_filename_option);
}

void
init_dg_filename_option(void)
{
    return;
}

dg_idname
f_dg_idname_apply_token(token token_value, bitstream token_args)
{
    UNUSED (token_value);
    UNUSED (token_args);
    return (f_dummy_dg_idname);
}

dg_idname
f_dg_anonymous_idname(string_option descr)
{
    UNUSED (descr);
    return (f_dummy_dg_idname);
}

dg_idname
f_dg_artificial_idname(string_option aname)
{
    UNUSED (aname);
    return (f_dummy_dg_idname);
}

dg_idname
f_dg_external_idname(string src_name)
{
    UNUSED (src_name);
    return (f_dummy_dg_idname);
}

dg_idname
f_dg_instance_idname(dg_idname_option idname, dg_idname spec, dg_sourcepos whence, dg_name_list aparams)
{
    UNUSED (idname);
    UNUSED (spec);
    UNUSED (whence);
    UNUSED (aparams);
    return (f_dummy_dg_idname);
}

dg_idname
f_dg_sourcestring_idname(string src_name)
{
    UNUSED (src_name);
    return (f_dummy_dg_idname);
}

dg_idname f_dummy_dg_idname;

void
init_dg_idname(void)
{
    return;
}

dg_idname_list
new_dg_idname_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_idname_list);
}

dg_idname_list
add_dg_idname_list(dg_idname_list list, dg_idname elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_idname_list);
}

void
init_dg_idname_list(void)
{
    return;
}

dg_idname_option no_dg_idname_option;

dg_idname_option
yes_dg_idname_option(dg_idname elem)
{
    UNUSED (elem);
    return (f_dummy_dg_idname_option);
}

void
init_dg_idname_option(void)
{
    return;
}

dg_macro
f_dg_function_macro(dg_sourcepos src_pos, dg_idname idname, dg_idname_list param, string def)
{
    UNUSED (src_pos);
    UNUSED (idname);
    UNUSED (param);
    UNUSED (def);
    return (f_dummy_dg_macro);
}

dg_macro
f_dg_include_macro(dg_sourcepos src_pos, dg_filename file, dg_macro_list macros)
{
    UNUSED (src_pos);
    UNUSED (file);
    UNUSED (macros);
    return (f_dummy_dg_macro);
}

dg_macro
f_dg_object_macro(dg_sourcepos src_pos, dg_idname idname, string def)
{
    UNUSED (src_pos);
    UNUSED (idname);
    UNUSED (def);
    return (f_dummy_dg_macro);
}

dg_macro
f_dg_undef_macro(dg_sourcepos src_pos, dg_idname idname)
{
    UNUSED (src_pos);
    UNUSED (idname);
    return (f_dummy_dg_macro);
}

dg_macro f_dummy_dg_macro;

void
init_dg_macro(void)
{
    return;
}

dg_macro_list
new_dg_macro_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_macro_list);
}

dg_macro_list
add_dg_macro_list(dg_macro_list list, dg_macro elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_macro_list);
}

void
init_dg_macro_list(void)
{
    return;
}

dg_name
f_dg_name_apply_token(token token_value, bitstream token_args)
{
    UNUSED (token_value);
    UNUSED (token_args);
    return (f_dummy_dg_name);
}

dg_name
f_dg_tag_name(dg_tag tg, dg_name name)
{
    UNUSED (tg);
    UNUSED (name);
    return (f_dummy_dg_name);
}

dg_name
f_dg_constant_name(dg_name name)
{
    UNUSED (name);
    return (f_dummy_dg_name);
}

dg_name
f_dg_entry_family_name(dg_name proc, dg_dim family)
{
    UNUSED (proc);
    UNUSED (family);
    return (f_dummy_dg_name);
}

dg_name
f_dg_entry_name(dg_idname idname, dg_sourcepos whence, dg_type type, dg_accessibility_option accessibility, dg_dim_option family)
{
    UNUSED (idname);
    UNUSED (whence);
    UNUSED (type);
    UNUSED (accessibility);
    UNUSED (family);
    return (f_dummy_dg_name);
}

dg_name
f_dg_inlined_name(dg_name name, dg_tag origin)
{
    UNUSED (name);
    UNUSED (origin);
    return (f_dummy_dg_name);
}

dg_name
f_dg_is_spec_name(dg_name name, bool_option is_separate)
{
    UNUSED (name);
    UNUSED (is_separate);
    return (f_dummy_dg_name);
}

dg_name
f_dg_module_name(dg_idname idname, dg_sourcepos whence, dg_namelist memlist, exp_option init, dg_tag_option elaboration)
{
    UNUSED (idname);
    UNUSED (whence);
    UNUSED (memlist);
    UNUSED (init);
    UNUSED (elaboration);
    return (f_dummy_dg_name);
}

dg_name
f_dg_namespace_name(dg_idname idname, dg_sourcepos whence, dg_namelist members)
{
    UNUSED (idname);
    UNUSED (whence);
    UNUSED (members);
    return (f_dummy_dg_name);
}

dg_name
f_dg_object_name(dg_idname idname, dg_sourcepos whence, dg_type type, exp_option obtain_value, dg_accessibility_option accessibility)
{
    UNUSED (idname);
    UNUSED (whence);
    UNUSED (type);
    UNUSED (obtain_value);
    UNUSED (accessibility);
    return (f_dummy_dg_name);
}

dg_name
f_dg_proc_name(dg_idname idname, dg_sourcepos whence, dg_type type, exp_option obtain_value, dg_accessibility_option accessibility, dg_virtuality_option virtuality, bool inl, dg_type_list_option exceptions, dg_tag_option elaboration)
{
    UNUSED (idname);
    UNUSED (whence);
    UNUSED (type);
    UNUSED (obtain_value);
    UNUSED (accessibility);
    UNUSED (virtuality);
    UNUSED (inl);
    UNUSED (exceptions);
    UNUSED (elaboration);
    return (f_dummy_dg_name);
}

dg_name
f_dg_program_name(dg_idname idname, dg_sourcepos whence, exp obtain_value)
{
    UNUSED (idname);
    UNUSED (whence);
    UNUSED (obtain_value);
    return (f_dummy_dg_name);
}

dg_name
f_dg_rep_clause_name(dg_name item, exp location)
{
    UNUSED (item);
    UNUSED (location);
    return (f_dummy_dg_name);
}

dg_name
f_dg_spec_ref_name(dg_tag specification, dg_name name)
{
    UNUSED (specification);
    UNUSED (name);
    return (f_dummy_dg_name);
}

dg_name
f_dg_subunit_name(dg_tag parent, dg_name name, nat subunit_kind, dg_accessibility_option accessibility)
{
    UNUSED (parent);
    UNUSED (name);
    UNUSED (subunit_kind);
    UNUSED (accessibility);
    return (f_dummy_dg_name);
}

dg_name
f_dg_type_name(dg_idname_option idname, dg_sourcepos whence, dg_accessibility_option accessibility, dg_type_option type, bool new_type, bool_option ada_derived, dg_constraint_list_option constraints)
{
    UNUSED (idname);
    UNUSED (whence);
    UNUSED (accessibility);
    UNUSED (type);
    UNUSED (new_type);
    UNUSED (ada_derived);
    UNUSED (constraints);
    return (f_dummy_dg_name);
}

dg_name
f_dg_visibility_name(dg_tag dname, nat import_kind, dg_idname_option idname, dg_sourcepos_option src_pos, dg_accessibility_option accessibility, dg_type_option type)
{
    UNUSED (dname);
    UNUSED (import_kind);
    UNUSED (idname);
    UNUSED (src_pos);
    UNUSED (accessibility);
    UNUSED (type);
    return (f_dummy_dg_name);
}

dg_name f_dummy_dg_name;

void
init_dg_name(void)
{
    return;
}

dg_name_list
new_dg_name_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_name_list);
}

dg_name_list
add_dg_name_list(dg_name_list list, dg_name elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_name_list);
}

void
init_dg_name_list(void)
{
    return;
}

dg_namelist
f_dg_tag_namelist(dg_tag tg, dg_namelist nl)
{
    UNUSED (tg);
    UNUSED (nl);
    return (f_dummy_dg_namelist);
}

dg_namelist
f_make_dg_namelist(dg_name_list items)
{
    UNUSED (items);
    return (f_dummy_dg_namelist);
}

dg_namelist f_dummy_dg_namelist;

void
init_dg_namelist(void)
{
    return;
}

dg_param
f_dg_object_param(dg_idname_option idname, dg_sourcepos_option src_pos, dg_param_mode_option mode, dg_type param_type, dg_default_option deflt)
{
    UNUSED (idname);
    UNUSED (src_pos);
    UNUSED (mode);
    UNUSED (param_type);
    UNUSED (deflt);
    return (f_dummy_dg_param);
}

dg_param
f_dg_type_param(dg_idname_option idname, dg_sourcepos_option src_pos, dg_param_list fparams)
{
    UNUSED (idname);
    UNUSED (src_pos);
    UNUSED (fparams);
    return (f_dummy_dg_param);
}

dg_param f_dummy_dg_param;

void
init_dg_param(void)
{
    return;
}

dg_param_list
new_dg_param_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_param_list);
}

dg_param_list
add_dg_param_list(dg_param_list list, dg_param elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_param_list);
}

void
init_dg_param_list(void)
{
    return;
}

dg_param_mode f_dg_in_mode;

dg_param_mode f_dg_inout_mode;

dg_param_mode f_dg_out_mode;

dg_param_mode f_dummy_dg_param_mode;

void
init_dg_param_mode(void)
{
    return;
}

dg_param_mode_option no_dg_param_mode_option;

dg_param_mode_option
yes_dg_param_mode_option(dg_param_mode elem)
{
    UNUSED (elem);
    return (f_dummy_dg_param_mode_option);
}

void
init_dg_param_mode_option(void)
{
    return;
}

dg_qualifier f_dg_aliased_qualifier;

dg_qualifier f_dg_class_wide_qualifier;

dg_qualifier f_dg_const_qualifier;

dg_qualifier f_dg_limited_qualifier;

dg_qualifier f_dg_volatile_qualifier;

dg_qualifier f_dummy_dg_qualifier;

void
init_dg_qualifier(void)
{
    return;
}

dg_sourcepos
f_dg_file_sourcepos(dg_filename file)
{
    UNUSED (file);
    return (f_dummy_dg_sourcepos);
}

dg_sourcepos f_dg_global_sourcepos;

dg_sourcepos
f_dg_mark_sourcepos(dg_filename file, nat line, nat column)
{
    UNUSED (file);
    UNUSED (line);
    UNUSED (column);
    return (f_dummy_dg_sourcepos);
}

dg_sourcepos f_dg_null_sourcepos;

dg_sourcepos
f_dg_span_sourcepos(dg_filename from_file, nat from_line, nat from_column, dg_filename_option to_file, nat to_line, nat to_column)
{
    UNUSED (from_file);
    UNUSED (from_line);
    UNUSED (from_column);
    UNUSED (to_file);
    UNUSED (to_line);
    UNUSED (to_column);
    return (f_dummy_dg_sourcepos);
}

dg_sourcepos f_dummy_dg_sourcepos;

void
init_dg_sourcepos(void)
{
    return;
}

dg_sourcepos_option no_dg_sourcepos_option;

dg_sourcepos_option
yes_dg_sourcepos_option(dg_sourcepos elem)
{
    UNUSED (elem);
    return (f_dummy_dg_sourcepos_option);
}

void
init_dg_sourcepos_option(void)
{
    return;
}

dg_tag
f_make_dg_tag(tdfint num)
{
    UNUSED (num);
    return (f_dummy_dg_tag);
}

dg_tag f_dummy_dg_tag;

void
init_dg_tag(void)
{
    return;
}

dg_tag_list
new_dg_tag_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_tag_list);
}

dg_tag_list
add_dg_tag_list(dg_tag_list list, dg_tag elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_tag_list);
}

void
init_dg_tag_list(void)
{
    return;
}

dg_tag_option no_dg_tag_option;

dg_tag_option
yes_dg_tag_option(dg_tag elem)
{
    UNUSED (elem);
    return (f_dummy_dg_tag_option);
}

void
init_dg_tag_option(void)
{
    return;
}

dg_type
f_dg_type_apply_token(token token_value, bitstream token_args)
{
    UNUSED (token_value);
    UNUSED (token_args);
    return (f_dummy_dg_type);
}

dg_type
f_dg_tag_type(dg_tag tg, dg_type type)
{
    UNUSED (tg);
    UNUSED (type);
    return (f_dummy_dg_type);
}

dg_type
f_dg_address_type(dg_idname idname, shape sh)
{
    UNUSED (idname);
    UNUSED (sh);
    return (f_dummy_dg_type);
}

dg_type
f_dg_array_type(dg_type element_type, exp stride, bool_option row_major, dg_dim_list dimensions)
{
    UNUSED (element_type);
    UNUSED (stride);
    UNUSED (row_major);
    UNUSED (dimensions);
    return (f_dummy_dg_type);
}

dg_type
f_dg_bitfield_type(dg_type type, bitfield_variety bv, shape sh)
{
    UNUSED (type);
    UNUSED (bv);
    UNUSED (sh);
    return (f_dummy_dg_type);
}

dg_type
f_dg_boolean_type(dg_idname idname, variety var)
{
    UNUSED (idname);
    UNUSED (var);
    return (f_dummy_dg_type);
}

dg_type
f_dg_char_type(dg_idname idname, variety var)
{
    UNUSED (idname);
    UNUSED (var);
    return (f_dummy_dg_type);
}

dg_type
f_dg_class_type(dg_class_base_list inheritance, dg_classmem_list members, dg_varpart_option varpart, dg_tag_list friends, shape_option sh, dg_tag_option vtable_static, dg_tag_option vtable_dynamic, dg_idname_option tagname, dg_sourcepos_option src_pos, bool is_union, dg_tag_option rtti_static, dg_tag_option rtti_dynamic, bool new_type, bool_option ada_derived)
{
    UNUSED (inheritance);
    UNUSED (members);
    UNUSED (varpart);
    UNUSED (friends);
    UNUSED (sh);
    UNUSED (vtable_static);
    UNUSED (vtable_dynamic);
    UNUSED (tagname);
    UNUSED (src_pos);
    UNUSED (is_union);
    UNUSED (rtti_static);
    UNUSED (rtti_dynamic);
    UNUSED (new_type);
    UNUSED (ada_derived);
    return (f_dummy_dg_type);
}

dg_type
f_dg_complex_float_type(dg_idname idname, floating_variety var)
{
    UNUSED (idname);
    UNUSED (var);
    return (f_dummy_dg_type);
}

dg_type
f_dg_enum_type(dg_enum_list values, dg_idname_option tagname, dg_sourcepos_option src_pos, shape sh, bool new_type)
{
    UNUSED (values);
    UNUSED (tagname);
    UNUSED (src_pos);
    UNUSED (sh);
    UNUSED (new_type);
    return (f_dummy_dg_type);
}

dg_type
f_dg_file_type(dg_type elem_type, shape sh)
{
    UNUSED (elem_type);
    UNUSED (sh);
    return (f_dummy_dg_type);
}

dg_type
f_dg_fixed_point_type(dg_type rep_type, exp small, exp_option delta, exp_option digits)
{
    UNUSED (rep_type);
    UNUSED (small);
    UNUSED (delta);
    UNUSED (digits);
    return (f_dummy_dg_type);
}

dg_type
f_dg_float_type(dg_idname idname, floating_variety var)
{
    UNUSED (idname);
    UNUSED (var);
    return (f_dummy_dg_type);
}

dg_type
f_dg_floating_digits_type(dg_type rep_type, exp digits)
{
    UNUSED (rep_type);
    UNUSED (digits);
    return (f_dummy_dg_type);
}

dg_type
f_dg_inlined_type(dg_type type, dg_tag origin)
{
    UNUSED (type);
    UNUSED (origin);
    return (f_dummy_dg_type);
}

dg_type
f_dg_integer_type(dg_idname idname, variety var)
{
    UNUSED (idname);
    UNUSED (var);
    return (f_dummy_dg_type);
}

dg_type
f_dg_is_spec_type(dg_type type)
{
    UNUSED (type);
    return (f_dummy_dg_type);
}

dg_type
f_dg_modular_type(dg_type rep_type, exp size)
{
    UNUSED (rep_type);
    UNUSED (size);
    return (f_dummy_dg_type);
}

dg_type
f_dg_named_type(dg_tag dname)
{
    UNUSED (dname);
    return (f_dummy_dg_type);
}

dg_type
f_dg_packed_type(dg_type type, shape sh)
{
    UNUSED (type);
    UNUSED (sh);
    return (f_dummy_dg_type);
}

dg_type
f_dg_pointer_type(dg_type type, bool_option heap_only)
{
    UNUSED (type);
    UNUSED (heap_only);
    return (f_dummy_dg_type);
}

dg_type
f_dg_proc_type(dg_param_list params, dg_type result_type, bool_option prototype, nat_option call_convention, nat_option language, procprops_option prcprops)
{
    UNUSED (params);
    UNUSED (result_type);
    UNUSED (prototype);
    UNUSED (call_convention);
    UNUSED (language);
    UNUSED (prcprops);
    return (f_dummy_dg_type);
}

dg_type
f_dg_ptr_memdata_type(dg_tag cls, dg_type memtype, shape sh, dg_tag_option pdm_type)
{
    UNUSED (cls);
    UNUSED (memtype);
    UNUSED (sh);
    UNUSED (pdm_type);
    return (f_dummy_dg_type);
}

dg_type
f_dg_ptr_memfn_type(dg_tag cls, dg_type memtype, shape sh, dg_tag_option pfn_type)
{
    UNUSED (cls);
    UNUSED (memtype);
    UNUSED (sh);
    UNUSED (pfn_type);
    return (f_dummy_dg_type);
}

dg_type
f_dg_qualified_type(dg_qualifier qualifier, dg_type type)
{
    UNUSED (qualifier);
    UNUSED (type);
    return (f_dummy_dg_type);
}

dg_type
f_dg_reference_type(dg_type type)
{
    UNUSED (type);
    return (f_dummy_dg_type);
}

dg_type
f_dg_set_type(dg_type element_type, shape sh)
{
    UNUSED (element_type);
    UNUSED (sh);
    return (f_dummy_dg_type);
}

dg_type
f_dg_spec_ref_type(dg_tag specification, dg_type type)
{
    UNUSED (specification);
    UNUSED (type);
    return (f_dummy_dg_type);
}

dg_type
f_dg_string_type(dg_tag character_type, exp lower_bound, exp length)
{
    UNUSED (character_type);
    UNUSED (lower_bound);
    UNUSED (length);
    return (f_dummy_dg_type);
}

dg_type
f_dg_struct_type(dg_classmem_list fields, shape_option sh, dg_idname_option tagname, dg_sourcepos_option src_pos, dg_varpart_option varpart, bool is_union, bool new_type)
{
    UNUSED (fields);
    UNUSED (sh);
    UNUSED (tagname);
    UNUSED (src_pos);
    UNUSED (varpart);
    UNUSED (is_union);
    UNUSED (new_type);
    return (f_dummy_dg_type);
}

dg_type
f_dg_subrange_type(dg_type rep_type, dg_bound low, dg_bound high)
{
    UNUSED (rep_type);
    UNUSED (low);
    UNUSED (high);
    return (f_dummy_dg_type);
}

dg_type
f_dg_synchronous_type(dg_idname idname, dg_sourcepos whence, dg_name_list entries, dg_tag socb, dg_classmem_list members, dg_varpart_option varpart, shape_option sh, bool new_type, dg_tag_option elaboration)
{
    UNUSED (idname);
    UNUSED (whence);
    UNUSED (entries);
    UNUSED (socb);
    UNUSED (members);
    UNUSED (varpart);
    UNUSED (sh);
    UNUSED (new_type);
    UNUSED (elaboration);
    return (f_dummy_dg_type);
}

dg_type
f_dg_task_type(dg_idname idname, dg_sourcepos whence, dg_name_list entries, dg_tag task_id, dg_tag tcb, dg_classmem_list members, dg_varpart_option varpart, shape_option sh, bool new_type, dg_tag_option elaboration)
{
    UNUSED (idname);
    UNUSED (whence);
    UNUSED (entries);
    UNUSED (task_id);
    UNUSED (tcb);
    UNUSED (members);
    UNUSED (varpart);
    UNUSED (sh);
    UNUSED (new_type);
    UNUSED (elaboration);
    return (f_dummy_dg_type);
}

dg_type
f_dg_unknown_type(shape sh)
{
    UNUSED (sh);
    return (f_dummy_dg_type);
}

dg_type f_dg_void_type;

dg_type f_dummy_dg_type;

void
init_dg_type(void)
{
    return;
}

dg_type_list
new_dg_type_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_type_list);
}

dg_type_list
add_dg_type_list(dg_type_list list, dg_type elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_type_list);
}

void
init_dg_type_list(void)
{
    return;
}

dg_type_list_option no_dg_type_list_option;

dg_type_list_option
yes_dg_type_list_option(dg_type_list elem)
{
    UNUSED (elem);
    return (f_dummy_dg_type_list_option);
}

void
init_dg_type_list_option(void)
{
    return;
}

dg_type_option no_dg_type_option;

dg_type_option
yes_dg_type_option(dg_type elem)
{
    UNUSED (elem);
    return (f_dummy_dg_type_option);
}

void
init_dg_type_option(void)
{
    return;
}

dg_variant
f_make_dg_variant(dg_discrim_list discr, dg_classmem_list fields)
{
    UNUSED (discr);
    UNUSED (fields);
    return (f_dummy_dg_variant);
}

dg_variant f_dummy_dg_variant;

void
init_dg_variant(void)
{
    return;
}

dg_variant_list
new_dg_variant_list(int n)
{
    UNUSED (n);
    return (f_dummy_dg_variant_list);
}

dg_variant_list
add_dg_variant_list(dg_variant_list list, dg_variant elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_dg_variant_list);
}

void
init_dg_variant_list(void)
{
    return;
}

dg_varpart
f_dg_discrim_varpart(dg_classmem discrim, dg_variant_list variants)
{
    UNUSED (discrim);
    UNUSED (variants);
    return (f_dummy_dg_varpart);
}

dg_varpart
f_dg_sibl_discrim_varpart(dg_tag discrim, dg_variant_list variants)
{
    UNUSED (discrim);
    UNUSED (variants);
    return (f_dummy_dg_varpart);
}

dg_varpart
f_dg_undiscrim_varpart(dg_type tag_type, dg_variant_list variants)
{
    UNUSED (tag_type);
    UNUSED (variants);
    return (f_dummy_dg_varpart);
}

dg_varpart f_dummy_dg_varpart;

void
init_dg_varpart(void)
{
    return;
}

dg_varpart_option no_dg_varpart_option;

dg_varpart_option
yes_dg_varpart_option(dg_varpart elem)
{
    UNUSED (elem);
    return (f_dummy_dg_varpart_option);
}

void
init_dg_varpart_option(void)
{
    return;
}

dg_virtuality f_dg_abstract_virtuality;

dg_virtuality f_dg_virtual_virtuality;

dg_virtuality f_dummy_dg_virtuality;

void
init_dg_virtuality(void)
{
    return;
}

dg_virtuality_option no_dg_virtuality_option;

dg_virtuality_option
yes_dg_virtuality_option(dg_virtuality elem)
{
    UNUSED (elem);
    return (f_dummy_dg_virtuality_option);
}

void
init_dg_virtuality_option(void)
{
    return;
}

shape_option no_shape_option;

shape_option
yes_shape_option(shape elem)
{
    UNUSED (elem);
    return (f_dummy_shape_option);
}

void
init_shape_option(void)
{
    return;
}

string_list
new_string_list(int n)
{
    UNUSED (n);
    return (f_dummy_string_list);
}

string_list
add_string_list(string_list list, string elem, int index)
{
    UNUSED (list);
    UNUSED (elem);
    UNUSED (index);
    return (f_dummy_string_list);
}

void
init_string_list(void)
{
    return;
}

string_option no_string_option;

string_option
yes_string_option(string elem)
{
    UNUSED (elem);
    return (f_dummy_string_option);
}

void
init_string_option(void)
{
    return;
}

token_option no_token_option;

token_option
yes_token_option(token elem)
{
    UNUSED (elem);
    return (f_dummy_token_option);
}

void
init_token_option(void)
{
    return;
}