Subversion Repositories tendra.SVN

/*
 * Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.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,
 *    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.
 * 3. Neither the name of The TenDRA Project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``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 COPYRIGHT HOLDERS OR
 * CONTRIBUTORS 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.
 *
 * $Id$
 */
/*
                 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.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;
}