Subversion Repositories tendra.SVN

Rev

Rev 2 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2 Rev 7
Line -... Line 1...
- 
 
 1 
/*
- 
 
 2 
 * Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.org/>.
- 
 
 3 
 * All rights reserved.
- 
 
 4 
 *
- 
 
 5 
 * Redistribution and use in source and binary forms, with or without
- 
 
 6 
 * modification, are permitted provided that the following conditions are met:
- 
 
 7 
 *
- 
 
 8 
 * 1. Redistributions of source code must retain the above copyright notice,
- 
 
 9 
 *    this list of conditions and the following disclaimer.
- 
 
 10 
 * 2. Redistributions in binary form must reproduce the above copyright notice,
- 
 
 11 
 *    this list of conditions and the following disclaimer in the documentation
- 
 
 12 
 *    and/or other materials provided with the distribution.
- 
 
 13 
 * 3. Neither the name of The TenDRA Project nor the names of its contributors
- 
 
 14 
 *    may be used to endorse or promote products derived from this software
- 
 
 15 
 *    without specific, prior written permission.
- 
 
 16 
 *
- 
 
 17 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
- 
 
 18 
 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- 
 
 19 
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- 
 
 20 
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
- 
 
 21 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- 
 
 22 
 * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- 
 
 23 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- 
 
 24 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- 
 
 25 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- 
 
 26 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- 
 
 27 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
 
 28 
 *
- 
 
 29 
 * $Id$
- 
 
 30 
 */
1 
/*
 31 
/*
2 
    		 Crown Copyright (c) 1997
 32 
    		 Crown Copyright (c) 1997
3
33 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
 34 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
 35 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
 36 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
 37 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
 38 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
 39 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
 40 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
 41 
    shall be deemed to be acceptance of the following conditions:-
12
42 
 
13 
        (1) Its Recipients shall ensure that this Notice is
 43 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
 44 
        reproduced upon any copies or amended versions of it;
15
45 
 
16 
        (2) Any amended version of it shall be clearly marked to
 46 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
 47 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
 48 
        for the relevant amendment or amendments;
19
49 
 
20 
        (3) Its onward transfer from a recipient to another
 50 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
 51 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
 52 
        these conditions;
23
53 
 
24 
        (4) DERA gives no warranty or assurance as to its
 54 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
 55 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
 56 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
 57 
        it may be put.
28 
*/
 58 
*/
29 
 
 59 
 
30 
 
 60 
 
31 
/* AUTOMATICALLY GENERATED BY make_tdf VERSION 2.0 FROM TDF 4.1 */
 61 
/* AUTOMATICALLY GENERATED BY make_tdf VERSION 2.0 FROM TDF 4.1 */
32 
 
 62 
 
33 
bool_option no_bool_option ;
 63 
bool_option no_bool_option;
34 
 
 64 
 
35 
bool_option yes_bool_option
 65 
bool_option yes_bool_option
36 
    PROTO_N ( ( elem ) )
 - 
 
37 
    PROTO_T ( bool elem )
 66 
(bool elem)
38 
{
 67 
{
39 
    UNUSED ( elem ) ;
 68 
    UNUSED(elem);
40 
    return ( f_dummy_bool_option ) ;
 69 
    return(f_dummy_bool_option);
41 
}
 70 
}
42 
 
 71 
 
43 
void init_bool_option
 72 
void init_bool_option
44 
    PROTO_Z ()
 73 
(void)
45 
{
 74 
{
46 
    return ;
 75 
    return;
47 
}
 76 
}
48 
 
 77 
 
49 
dg_accessibility f_dg_local_accessibility ;
 78 
dg_accessibility f_dg_local_accessibility;
50 
 
 79 
 
51 
dg_accessibility f_dg_private_accessibility ;
 80 
dg_accessibility f_dg_private_accessibility;
52 
 
 81 
 
53 
dg_accessibility f_dg_protected_accessibility ;
 82 
dg_accessibility f_dg_protected_accessibility;
54 
 
 83 
 
55 
dg_accessibility f_dg_public_accessibility ;
 84 
dg_accessibility f_dg_public_accessibility;
56 
 
 85 
 
57 
dg_accessibility f_dummy_dg_accessibility ;
 86 
dg_accessibility f_dummy_dg_accessibility;
58 
 
 87 
 
59 
void init_dg_accessibility
 88 
void init_dg_accessibility
60 
    PROTO_Z ()
 89 
(void)
61 
{
 90 
{
62 
    return ;
 91 
    return;
63 
}
 92 
}
64 
 
 93 
 
65 
dg_accessibility_option no_dg_accessibility_option ;
 94 
dg_accessibility_option no_dg_accessibility_option;
66 
 
 95 
 
67 
dg_accessibility_option yes_dg_accessibility_option
 96 
dg_accessibility_option yes_dg_accessibility_option
68 
    PROTO_N ( ( elem ) )
 - 
 
69 
    PROTO_T ( dg_accessibility elem )
 97 
(dg_accessibility elem)
70 
{
 98 
{
71 
    UNUSED ( elem ) ;
 99 
    UNUSED(elem);
72 
    return ( f_dummy_dg_accessibility_option ) ;
 100 
    return(f_dummy_dg_accessibility_option);
73 
}
 101 
}
74 
 
 102 
 
75 
void init_dg_accessibility_option
 103 
void init_dg_accessibility_option
76 
    PROTO_Z ()
 104 
(void)
77 
{
 105 
{
78 
    return ;
 106 
    return;
79 
}
 107 
}
80 
 
 108 
 
81 
dg_append f_dg_name_append
 109 
dg_append f_dg_name_append
82 
    PROTO_N ( ( tg, name ) )
 - 
 
83 
    PROTO_T ( dg_tag tg X dg_name name )
 110 
(dg_tag tg, dg_name name)
84 
{
 111 
{
85 
    UNUSED ( tg ) ;
 112 
    UNUSED(tg);
86 
    UNUSED ( name ) ;
 113 
    UNUSED(name);
87 
    return ( f_dummy_dg_append ) ;
 114 
    return(f_dummy_dg_append);
88 
}
 115 
}
89 
 
 116 
 
90 
dg_append f_dummy_dg_append ;
 117 
dg_append f_dummy_dg_append;
91 
 
 118 
 
92 
void init_dg_append
 119 
void init_dg_append
93 
    PROTO_Z ()
 120 
(void)
94 
{
 121 
{
95 
    return ;
 122 
    return;
96 
}
 123 
}
97 
 
 124 
 
98 
dg_append_list new_dg_append_list
 125 
dg_append_list new_dg_append_list
99 
    PROTO_N ( ( n ) )
 - 
 
100 
    PROTO_T ( int n )
 126 
(int n)
101 
{
 127 
{
102 
    UNUSED ( n ) ;
 128 
    UNUSED(n);
103 
    return ( f_dummy_dg_append_list ) ;
 129 
    return(f_dummy_dg_append_list);
104 
}
 130 
}
105 
 
 131 
 
106 
dg_append_list add_dg_append_list
 132 
dg_append_list add_dg_append_list
107 
   PROTO_N ( ( list, elem, index ) )
 - 
 
108 
   PROTO_T ( dg_append_list list X dg_append elem X int index )
 133 
(dg_append_list list, dg_append elem, int index)
109 
{
 134 
{
110 
    UNUSED ( list ) ;
 135 
    UNUSED(list);
111 
    UNUSED ( elem ) ;
 136 
    UNUSED(elem);
112 
    UNUSED ( index ) ;
 137 
    UNUSED(index);
113 
    return ( f_dummy_dg_append_list ) ;
 138 
    return(f_dummy_dg_append_list);
114 
}
 139 
}
115 
 
 140 
 
116 
void init_dg_append_list
 141 
void init_dg_append_list
117 
    PROTO_Z ()
 142 
(void)
118 
{
 143 
{
119 
    return ;
 144 
    return;
120 
}
 145 
}
121 
 
 146 
 
122 
dg_bound f_dg_dynamic_bound
 147 
dg_bound f_dg_dynamic_bound
123 
    PROTO_N ( ( bound, sh ) )
 - 
 
124 
    PROTO_T ( dg_tag bound X shape sh )
 148 
(dg_tag bound, shape sh)
125 
{
 149 
{
126 
    UNUSED ( bound ) ;
 150 
    UNUSED(bound);
127 
    UNUSED ( sh ) ;
 151 
    UNUSED(sh);
128 
    return ( f_dummy_dg_bound ) ;
 152 
    return(f_dummy_dg_bound);
129 
}
 153 
}
130 
 
 154 
 
131 
dg_bound f_dg_static_bound
 155 
dg_bound f_dg_static_bound
132 
    PROTO_N ( ( bound ) )
 - 
 
133 
    PROTO_T ( exp bound )
 156 
(exp bound)
134 
{
 157 
{
135 
    UNUSED ( bound ) ;
 158 
    UNUSED(bound);
136 
    return ( f_dummy_dg_bound ) ;
 159 
    return(f_dummy_dg_bound);
137 
}
 160 
}
138 
 
 161 
 
139 
dg_bound f_dg_unknown_bound
 162 
dg_bound f_dg_unknown_bound
140 
    PROTO_N ( ( sh ) )
 - 
 
141 
    PROTO_T ( shape sh )
 163 
(shape sh)
142 
{
 164 
{
143 
    UNUSED ( sh ) ;
 165 
    UNUSED(sh);
144 
    return ( f_dummy_dg_bound ) ;
 166 
    return(f_dummy_dg_bound);
145 
}
 167 
}
146 
 
 168 
 
147 
dg_bound f_dummy_dg_bound ;
 169 
dg_bound f_dummy_dg_bound;
148 
 
 170 
 
149 
void init_dg_bound
 171 
void init_dg_bound
150 
    PROTO_Z ()
 172 
(void)
151 
{
 173 
{
152 
    return ;
 174 
    return;
153 
}
 175 
}
154 
 
 176 
 
155 
dg_class_base f_make_dg_class_base
 177 
dg_class_base f_make_dg_class_base
156 
    PROTO_N ( ( base, whence, location, accessibility, virtuality ) )
 - 
 
157 
    PROTO_T ( dg_tag base X dg_sourcepos_option whence X token_option location X dg_accessibility_option accessibility X dg_virtuality_option virtuality )
 178 
(dg_tag base, dg_sourcepos_option whence, token_option location, dg_accessibility_option accessibility, dg_virtuality_option virtuality)
158 
{
 179 
{
159 
    UNUSED ( base ) ;
 180 
    UNUSED(base);
160 
    UNUSED ( whence ) ;
 181 
    UNUSED(whence);
161 
    UNUSED ( location ) ;
 182 
    UNUSED(location);
162 
    UNUSED ( accessibility ) ;
 183 
    UNUSED(accessibility);
163 
    UNUSED ( virtuality ) ;
 184 
    UNUSED(virtuality);
164 
    return ( f_dummy_dg_class_base ) ;
 185 
    return(f_dummy_dg_class_base);
165 
}
 186 
}
166 
 
 187 
 
167 
dg_class_base f_dummy_dg_class_base ;
 188 
dg_class_base f_dummy_dg_class_base;
168 
 
 189 
 
169 
void init_dg_class_base
 190 
void init_dg_class_base
170 
    PROTO_Z ()
 191 
(void)
171 
{
 192 
{
172 
    return ;
 193 
    return;
173 
}
 194 
}
174 
 
 195 
 
175 
dg_class_base_list new_dg_class_base_list
 196 
dg_class_base_list new_dg_class_base_list
176 
    PROTO_N ( ( n ) )
 - 
 
177 
    PROTO_T ( int n )
 197 
(int n)
178 
{
 198 
{
179 
    UNUSED ( n ) ;
 199 
    UNUSED(n);
180 
    return ( f_dummy_dg_class_base_list ) ;
 200 
    return(f_dummy_dg_class_base_list);
181 
}
 201 
}
182 
 
 202 
 
183 
dg_class_base_list add_dg_class_base_list
 203 
dg_class_base_list add_dg_class_base_list
184 
   PROTO_N ( ( list, elem, index ) )
 - 
 
185 
   PROTO_T ( dg_class_base_list list X dg_class_base elem X int index )
 204 
(dg_class_base_list list, dg_class_base elem, int index)
186 
{
 205 
{
187 
    UNUSED ( list ) ;
 206 
    UNUSED(list);
188 
    UNUSED ( elem ) ;
 207 
    UNUSED(elem);
189 
    UNUSED ( index ) ;
 208 
    UNUSED(index);
190 
    return ( f_dummy_dg_class_base_list ) ;
 209 
    return(f_dummy_dg_class_base_list);
191 
}
 210 
}
192 
 
 211 
 
193 
void init_dg_class_base_list
 212 
void init_dg_class_base_list
194 
    PROTO_Z ()
 213 
(void)
195 
{
 214 
{
196 
    return ;
 215 
    return;
197 
}
 216 
}
198 
 
 217 
 
199 
dg_classmem f_dg_tag_classmem
 218 
dg_classmem f_dg_tag_classmem
200 
    PROTO_N ( ( tg, mem ) )
 - 
 
201 
    PROTO_T ( dg_tag tg X dg_classmem mem )
 219 
(dg_tag tg, dg_classmem mem)
202 
{
 220 
{
203 
    UNUSED ( tg ) ;
 221 
    UNUSED(tg);
204 
    UNUSED ( mem ) ;
 222 
    UNUSED(mem);
205 
    return ( f_dummy_dg_classmem ) ;
 223 
    return(f_dummy_dg_classmem);
206 
}
 224 
}
207 
 
 225 
 
208 
dg_classmem f_dg_field_classmem
 226 
dg_classmem f_dg_field_classmem
209 
    PROTO_N ( ( idname, src_pos, offset, field_type, accessibility, discr, deflt ) )
 - 
 
210 
    PROTO_T ( dg_idname idname X dg_sourcepos src_pos X exp offset X dg_type field_type X dg_accessibility_option accessibility X bool_option discr X dg_default_option deflt )
 227 
(dg_idname idname, dg_sourcepos src_pos, exp offset, dg_type field_type, dg_accessibility_option accessibility, bool_option discr, dg_default_option deflt)
211 
{
 228 
{
212 
    UNUSED ( idname ) ;
 229 
    UNUSED(idname);
213 
    UNUSED ( src_pos ) ;
 230 
    UNUSED(src_pos);
214 
    UNUSED ( offset ) ;
 231 
    UNUSED(offset);
215 
    UNUSED ( field_type ) ;
 232 
    UNUSED(field_type);
216 
    UNUSED ( accessibility ) ;
 233 
    UNUSED(accessibility);
217 
    UNUSED ( discr ) ;
 234 
    UNUSED(discr);
218 
    UNUSED ( deflt ) ;
 235 
    UNUSED(deflt);
219 
    return ( f_dummy_dg_classmem ) ;
 236 
    return(f_dummy_dg_classmem);
220 
}
 237 
}
221 
 
 238 
 
222 
dg_classmem f_dg_function_classmem
 239 
dg_classmem f_dg_function_classmem
223 
    PROTO_N ( ( fn, vtable_slot ) )
 - 
 
224 
    PROTO_T ( dg_name fn X exp_option vtable_slot )
 240 
(dg_name fn, exp_option vtable_slot)
225 
{
 241 
{
226 
    UNUSED ( fn ) ;
 242 
    UNUSED(fn);
227 
    UNUSED ( vtable_slot ) ;
 243 
    UNUSED(vtable_slot);
228 
    return ( f_dummy_dg_classmem ) ;
 244 
    return(f_dummy_dg_classmem);
229 
}
 245 
}
230 
 
 246 
 
231 
dg_classmem f_dg_indirect_classmem
 247 
dg_classmem f_dg_indirect_classmem
232 
    PROTO_N ( ( idname, src_pos, location, cmem_type ) )
 - 
 
233 
    PROTO_T ( dg_idname idname X dg_sourcepos src_pos X token location X dg_type cmem_type )
 248 
(dg_idname idname, dg_sourcepos src_pos, token location, dg_type cmem_type)
234 
{
 249 
{
235 
    UNUSED ( idname ) ;
 250 
    UNUSED(idname);
236 
    UNUSED ( src_pos ) ;
 251 
    UNUSED(src_pos);
237 
    UNUSED ( location ) ;
 252 
    UNUSED(location);
238 
    UNUSED ( cmem_type ) ;
 253 
    UNUSED(cmem_type);
239 
    return ( f_dummy_dg_classmem ) ;
 254 
    return(f_dummy_dg_classmem);
240 
}
 255 
}
241 
 
 256 
 
242 
dg_classmem f_dg_name_classmem
 257 
dg_classmem f_dg_name_classmem
243 
    PROTO_N ( ( name ) )
 - 
 
244 
    PROTO_T ( dg_name name )
 258 
(dg_name name)
245 
{
 259 
{
246 
    UNUSED ( name ) ;
 260 
    UNUSED(name);
247 
    return ( f_dummy_dg_classmem ) ;
 261 
    return(f_dummy_dg_classmem);
248 
}
 262 
}
249 
 
 263 
 
250 
dg_classmem f_dummy_dg_classmem ;
 264 
dg_classmem f_dummy_dg_classmem;
251 
 
 265 
 
252 
void init_dg_classmem
 266 
void init_dg_classmem
253 
    PROTO_Z ()
 267 
(void)
254 
{
 268 
{
255 
    return ;
 269 
    return;
256 
}
 270 
}
257 
 
 271 
 
258 
dg_classmem_list new_dg_classmem_list
 272 
dg_classmem_list new_dg_classmem_list
259 
    PROTO_N ( ( n ) )
 - 
 
260 
    PROTO_T ( int n )
 273 
(int n)
261 
{
 274 
{
262 
    UNUSED ( n ) ;
 275 
    UNUSED(n);
263 
    return ( f_dummy_dg_classmem_list ) ;
 276 
    return(f_dummy_dg_classmem_list);
264 
}
 277 
}
265 
 
 278 
 
266 
dg_classmem_list add_dg_classmem_list
 279 
dg_classmem_list add_dg_classmem_list
267 
   PROTO_N ( ( list, elem, index ) )
 - 
 
268 
   PROTO_T ( dg_classmem_list list X dg_classmem elem X int index )
 280 
(dg_classmem_list list, dg_classmem elem, int index)
269 
{
 281 
{
270 
    UNUSED ( list ) ;
 282 
    UNUSED(list);
271 
    UNUSED ( elem ) ;
 283 
    UNUSED(elem);
272 
    UNUSED ( index ) ;
 284 
    UNUSED(index);
273 
    return ( f_dummy_dg_classmem_list ) ;
 285 
    return(f_dummy_dg_classmem_list);
274 
}
 286 
}
275 
 
 287 
 
276 
void init_dg_classmem_list
 288 
void init_dg_classmem_list
277 
    PROTO_Z ()
 289 
(void)
278 
{
 290 
{
279 
    return ;
 291 
    return;
280 
}
 292 
}
281 
 
 293 
 
282 
dg_comp_props f_make_dg_compunit
 294 
dg_comp_props f_make_dg_compunit
283 
    PROTO_N ( ( no_labels, comp_unit, l ) )
 - 
 
284 
    PROTO_T ( tdfint no_labels X dg_compilation comp_unit X dg_append_list l )
 295 
(tdfint no_labels, dg_compilation comp_unit, dg_append_list l)
285 
{
 296 
{
286 
    UNUSED ( no_labels ) ;
 297 
    UNUSED(no_labels);
287 
    UNUSED ( comp_unit ) ;
 298 
    UNUSED(comp_unit);
288 
    UNUSED ( l ) ;
 299 
    UNUSED(l);
289 
    return ( f_dummy_dg_comp_props ) ;
 300 
    return(f_dummy_dg_comp_props);
290 
}
 301 
}
291 
 
 302 
 
292 
dg_comp_props f_dummy_dg_comp_props ;
 303 
dg_comp_props f_dummy_dg_comp_props;
293 
 
 304 
 
294 
void init_dg_comp_props
 305 
void init_dg_comp_props
295 
    PROTO_Z ()
 306 
(void)
296 
{
 307 
{
297 
    return ;
 308 
    return;
298 
}
 309 
}
299 
 
 310 
 
300 
dg_compilation f_dg_tag_compilation
 311 
dg_compilation f_dg_tag_compilation
301 
    PROTO_N ( ( tg, comp ) )
 - 
 
302 
    PROTO_T ( dg_tag tg X dg_compilation comp )
 312 
(dg_tag tg, dg_compilation comp)
303 
{
 313 
{
304 
    UNUSED ( tg ) ;
 314 
    UNUSED(tg);
305 
    UNUSED ( comp ) ;
 315 
    UNUSED(comp);
306 
    return ( f_dummy_dg_compilation ) ;
 316 
    return(f_dummy_dg_compilation);
307 
}
 317 
}
308 
 
 318 
 
309 
dg_compilation f_make_dg_compilation
 319 
dg_compilation f_make_dg_compilation
310 
    PROTO_N ( ( primary_file, comp_unit_deps, macros, comp_dir, date, language, id_case, producer, options, dnames ) )
 - 
 
311 
    PROTO_T ( dg_filename primary_file X string_list comp_unit_deps X dg_macro_list macros X dg_filename comp_dir X nat date X nat language X nat id_case X string producer X string_list options X dg_namelist dnames )
 320 
(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)
312 
{
 321 
{
313 
    UNUSED ( primary_file ) ;
 322 
    UNUSED(primary_file);
314 
    UNUSED ( comp_unit_deps ) ;
 323 
    UNUSED(comp_unit_deps);
315 
    UNUSED ( macros ) ;
 324 
    UNUSED(macros);
316 
    UNUSED ( comp_dir ) ;
 325 
    UNUSED(comp_dir);
317 
    UNUSED ( date ) ;
 326 
    UNUSED(date);
318 
    UNUSED ( language ) ;
 327 
    UNUSED(language);
319 
    UNUSED ( id_case ) ;
 328 
    UNUSED(id_case);
320 
    UNUSED ( producer ) ;
 329 
    UNUSED(producer);
321 
    UNUSED ( options ) ;
 330 
    UNUSED(options);
322 
    UNUSED ( dnames ) ;
 331 
    UNUSED(dnames);
323 
    return ( f_dummy_dg_compilation ) ;
 332 
    return(f_dummy_dg_compilation);
324 
}
 333 
}
325 
 
 334 
 
326 
dg_compilation f_dummy_dg_compilation ;
 335 
dg_compilation f_dummy_dg_compilation;
327 
 
 336 
 
328 
void init_dg_compilation
 337 
void init_dg_compilation
329 
    PROTO_Z ()
 338 
(void)
330 
{
 339 
{
331 
    return ;
 340 
    return;
332 
}
 341 
}
333 
 
 342 
 
334 
dg_constraint f_dg_type_constraint
 343 
dg_constraint f_dg_type_constraint
335 
    PROTO_N ( ( ref_member, type ) )
 - 
 
336 
    PROTO_T ( dg_tag_option ref_member X dg_type type )
 344 
(dg_tag_option ref_member, dg_type type)
337 
{
 345 
{
338 
    UNUSED ( ref_member ) ;
 346 
    UNUSED(ref_member);
339 
    UNUSED ( type ) ;
 347 
    UNUSED(type);
340 
    return ( f_dummy_dg_constraint ) ;
 348 
    return(f_dummy_dg_constraint);
341 
}
 349 
}
342 
 
 350 
 
343 
dg_constraint f_dg_value_constraint
 351 
dg_constraint f_dg_value_constraint
344 
    PROTO_N ( ( ref_member, value ) )
 - 
 
345 
    PROTO_T ( dg_tag_option ref_member X exp value )
 352 
(dg_tag_option ref_member, exp value)
346 
{
 353 
{
347 
    UNUSED ( ref_member ) ;
 354 
    UNUSED(ref_member);
348 
    UNUSED ( value ) ;
 355 
    UNUSED(value);
349 
    return ( f_dummy_dg_constraint ) ;
 356 
    return(f_dummy_dg_constraint);
350 
}
 357 
}
351 
 
 358 
 
352 
dg_constraint f_dummy_dg_constraint ;
 359 
dg_constraint f_dummy_dg_constraint;
353 
 
 360 
 
354 
void init_dg_constraint
 361 
void init_dg_constraint
355 
    PROTO_Z ()
 362 
(void)
356 
{
 363 
{
357 
    return ;
 364 
    return;
358 
}
 365 
}
359 
 
 366 
 
360 
dg_constraint_list new_dg_constraint_list
 367 
dg_constraint_list new_dg_constraint_list
361 
    PROTO_N ( ( n ) )
 - 
 
362 
    PROTO_T ( int n )
 368 
(int n)
363 
{
 369 
{
364 
    UNUSED ( n ) ;
 370 
    UNUSED(n);
365 
    return ( f_dummy_dg_constraint_list ) ;
 371 
    return(f_dummy_dg_constraint_list);
366 
}
 372 
}
367 
 
 373 
 
368 
dg_constraint_list add_dg_constraint_list
 374 
dg_constraint_list add_dg_constraint_list
369 
   PROTO_N ( ( list, elem, index ) )
 - 
 
370 
   PROTO_T ( dg_constraint_list list X dg_constraint elem X int index )
 375 
(dg_constraint_list list, dg_constraint elem, int index)
371 
{
 376 
{
372 
    UNUSED ( list ) ;
 377 
    UNUSED(list);
373 
    UNUSED ( elem ) ;
 378 
    UNUSED(elem);
374 
    UNUSED ( index ) ;
 379 
    UNUSED(index);
375 
    return ( f_dummy_dg_constraint_list ) ;
 380 
    return(f_dummy_dg_constraint_list);
376 
}
 381 
}
377 
 
 382 
 
378 
void init_dg_constraint_list
 383 
void init_dg_constraint_list
379 
    PROTO_Z ()
 384 
(void)
380 
{
 385 
{
381 
    return ;
 386 
    return;
382 
}
 387 
}
383 
 
 388 
 
384 
dg_constraint_list_option no_dg_constraint_list_option ;
 389 
dg_constraint_list_option no_dg_constraint_list_option;
385 
 
 390 
 
386 
dg_constraint_list_option yes_dg_constraint_list_option
 391 
dg_constraint_list_option yes_dg_constraint_list_option
387 
    PROTO_N ( ( elem ) )
 - 
 
388 
    PROTO_T ( dg_constraint_list elem )
 392 
(dg_constraint_list elem)
389 
{
 393 
{
390 
    UNUSED ( elem ) ;
 394 
    UNUSED(elem);
391 
    return ( f_dummy_dg_constraint_list_option ) ;
 395 
    return(f_dummy_dg_constraint_list_option);
392 
}
 396 
}
393 
 
 397 
 
394 
void init_dg_constraint_list_option
 398 
void init_dg_constraint_list_option
395 
    PROTO_Z ()
 399 
(void)
396 
{
 400 
{
397 
    return ;
 401 
    return;
398 
}
 402 
}
399 
 
 403 
 
400 
dg_default f_make_dg_default
 404 
dg_default f_make_dg_default
401 
    PROTO_N ( ( value, src_span ) )
 - 
 
402 
    PROTO_T ( exp_option value X dg_sourcepos_option src_span )
 405 
(exp_option value, dg_sourcepos_option src_span)
403 
{
 406 
{
404 
    UNUSED ( value ) ;
 407 
    UNUSED(value);
405 
    UNUSED ( src_span ) ;
 408 
    UNUSED(src_span);
406 
    return ( f_dummy_dg_default ) ;
 409 
    return(f_dummy_dg_default);
407 
}
 410 
}
408 
 
 411 
 
409 
dg_default f_dummy_dg_default ;
 412 
dg_default f_dummy_dg_default;
410 
 
 413 
 
411 
void init_dg_default
 414 
void init_dg_default
412 
    PROTO_Z ()
 415 
(void)
413 
{
 416 
{
414 
    return ;
 417 
    return;
415 
}
 418 
}
416 
 
 419 
 
417 
dg_default_option no_dg_default_option ;
 420 
dg_default_option no_dg_default_option;
418 
 
 421 
 
419 
dg_default_option yes_dg_default_option
 422 
dg_default_option yes_dg_default_option
420 
    PROTO_N ( ( elem ) )
 - 
 
421 
    PROTO_T ( dg_default elem )
 423 
(dg_default elem)
422 
{
 424 
{
423 
    UNUSED ( elem ) ;
 425 
    UNUSED(elem);
424 
    return ( f_dummy_dg_default_option ) ;
 426 
    return(f_dummy_dg_default_option);
425 
}
 427 
}
426 
 
 428 
 
427 
void init_dg_default_option
 429 
void init_dg_default_option
428 
    PROTO_Z ()
 430 
(void)
429 
{
 431 
{
430 
    return ;
 432 
    return;
431 
}
 433 
}
432 
 
 434 
 
433 
dg_dim f_dg_dim_apply_token
 435 
dg_dim f_dg_dim_apply_token
434 
    PROTO_N ( ( token_value, token_args ) )
 - 
 
435 
    PROTO_T ( token token_value X bitstream token_args )
 436 
(token token_value, bitstream token_args)
436 
{
 437 
{
437 
    UNUSED ( token_value ) ;
 438 
    UNUSED(token_value);
438 
    UNUSED ( token_args ) ;
 439 
    UNUSED(token_args);
439 
    return ( f_dummy_dg_dim ) ;
 440 
    return(f_dummy_dg_dim);
440 
}
 441 
}
441 
 
 442 
 
442 
dg_dim f_dg_tag_dim
 443 
dg_dim f_dg_tag_dim
443 
    PROTO_N ( ( tg, d ) )
 - 
 
444 
    PROTO_T ( dg_tag tg X dg_dim d )
 444 
(dg_tag tg, dg_dim d)
445 
{
 445 
{
446 
    UNUSED ( tg ) ;
 446 
    UNUSED(tg);
447 
    UNUSED ( d ) ;
 447 
    UNUSED(d);
448 
    return ( f_dummy_dg_dim ) ;
 448 
    return(f_dummy_dg_dim);
449 
}
 449 
}
450 
 
 450 
 
451 
dg_dim f_dg_bounds_dim
 451 
dg_dim f_dg_bounds_dim
452 
    PROTO_N ( ( low, high, index_type ) )
 - 
 
453 
    PROTO_T ( dg_bound low X dg_bound high X dg_type index_type )
 452 
(dg_bound low, dg_bound high, dg_type index_type)
454 
{
 453 
{
455 
    UNUSED ( low ) ;
 454 
    UNUSED(low);
456 
    UNUSED ( high ) ;
 455 
    UNUSED(high);
457 
    UNUSED ( index_type ) ;
 456 
    UNUSED(index_type);
458 
    return ( f_dummy_dg_dim ) ;
 457 
    return(f_dummy_dg_dim);
459 
}
 458 
}
460 
 
 459 
 
461 
dg_dim f_dg_count_dim
 460 
dg_dim f_dg_count_dim
462 
    PROTO_N ( ( low, count, index_type ) )
 - 
 
463 
    PROTO_T ( dg_bound low X dg_bound count X dg_type index_type )
 461 
(dg_bound low, dg_bound count, dg_type index_type)
464 
{
 462 
{
465 
    UNUSED ( low ) ;
 463 
    UNUSED(low);
466 
    UNUSED ( count ) ;
 464 
    UNUSED(count);
467 
    UNUSED ( index_type ) ;
 465 
    UNUSED(index_type);
468 
    return ( f_dummy_dg_dim ) ;
 466 
    return(f_dummy_dg_dim);
469 
}
 467 
}
470 
 
 468 
 
471 
dg_dim f_dg_type_dim
 469 
dg_dim f_dg_type_dim
472 
    PROTO_N ( ( type, n ) )
 - 
 
473 
    PROTO_T ( dg_type type X nat_option n )
 470 
(dg_type type, nat_option n)
474 
{
 471 
{
475 
    UNUSED ( type ) ;
 472 
    UNUSED(type);
476 
    UNUSED ( n ) ;
 473 
    UNUSED(n);
477 
    return ( f_dummy_dg_dim ) ;
 474 
    return(f_dummy_dg_dim);
478 
}
 475 
}
479 
 
 476 
 
480 
dg_dim f_dg_unspecified_dim ;
 477 
dg_dim f_dg_unspecified_dim;
481 
 
 478 
 
482 
dg_dim f_dummy_dg_dim ;
 479 
dg_dim f_dummy_dg_dim;
483 
 
 480 
 
484 
void init_dg_dim
 481 
void init_dg_dim
485 
    PROTO_Z ()
 482 
(void)
486 
{
 483 
{
487 
    return ;
 484 
    return;
488 
}
 485 
}
489 
 
 486 
 
490 
dg_dim_list new_dg_dim_list
 487 
dg_dim_list new_dg_dim_list
491 
    PROTO_N ( ( n ) )
 - 
 
492 
    PROTO_T ( int n )
 488 
(int n)
493 
{
 489 
{
494 
    UNUSED ( n ) ;
 490 
    UNUSED(n);
495 
    return ( f_dummy_dg_dim_list ) ;
 491 
    return(f_dummy_dg_dim_list);
496 
}
 492 
}
497 
 
 493 
 
498 
dg_dim_list add_dg_dim_list
 494 
dg_dim_list add_dg_dim_list
499 
   PROTO_N ( ( list, elem, index ) )
 - 
 
500 
   PROTO_T ( dg_dim_list list X dg_dim elem X int index )
 495 
(dg_dim_list list, dg_dim elem, int index)
501 
{
 496 
{
502 
    UNUSED ( list ) ;
 497 
    UNUSED(list);
503 
    UNUSED ( elem ) ;
 498 
    UNUSED(elem);
504 
    UNUSED ( index ) ;
 499 
    UNUSED(index);
505 
    return ( f_dummy_dg_dim_list ) ;
 500 
    return(f_dummy_dg_dim_list);
506 
}
 501 
}
507 
 
 502 
 
508 
void init_dg_dim_list
 503 
void init_dg_dim_list
509 
    PROTO_Z ()
 504 
(void)
510 
{
 505 
{
511 
    return ;
 506 
    return;
512 
}
 507 
}
513 
 
 508 
 
514 
dg_dim_option no_dg_dim_option ;
 509 
dg_dim_option no_dg_dim_option;
515 
 
 510 
 
516 
dg_dim_option yes_dg_dim_option
 511 
dg_dim_option yes_dg_dim_option
517 
    PROTO_N ( ( elem ) )
 - 
 
518 
    PROTO_T ( dg_dim elem )
 512 
(dg_dim elem)
519 
{
 513 
{
520 
    UNUSED ( elem ) ;
 514 
    UNUSED(elem);
521 
    return ( f_dummy_dg_dim_option ) ;
 515 
    return(f_dummy_dg_dim_option);
522 
}
 516 
}
523 
 
 517 
 
524 
void init_dg_dim_option
 518 
void init_dg_dim_option
525 
    PROTO_Z ()
 519 
(void)
526 
{
 520 
{
527 
    return ;
 521 
    return;
528 
}
 522 
}
529 
 
 523 
 
530 
dg_discrim f_make_dg_discrim
 524 
dg_discrim f_make_dg_discrim
531 
    PROTO_N ( ( lower, upper ) )
 - 
 
532 
    PROTO_T ( exp lower X exp upper )
 525 
(exp lower, exp upper)
533 
{
 526 
{
534 
    UNUSED ( lower ) ;
 527 
    UNUSED(lower);
535 
    UNUSED ( upper ) ;
 528 
    UNUSED(upper);
536 
    return ( f_dummy_dg_discrim ) ;
 529 
    return(f_dummy_dg_discrim);
537 
}
 530 
}
538 
 
 531 
 
539 
dg_discrim f_dummy_dg_discrim ;
 532 
dg_discrim f_dummy_dg_discrim;
540 
 
 533 
 
541 
void init_dg_discrim
 534 
void init_dg_discrim
542 
    PROTO_Z ()
 535 
(void)
543 
{
 536 
{
544 
    return ;
 537 
    return;
545 
}
 538 
}
546 
 
 539 
 
547 
dg_discrim_list new_dg_discrim_list
 540 
dg_discrim_list new_dg_discrim_list
548 
    PROTO_N ( ( n ) )
 - 
 
549 
    PROTO_T ( int n )
 541 
(int n)
550 
{
 542 
{
551 
    UNUSED ( n ) ;
 543 
    UNUSED(n);
552 
    return ( f_dummy_dg_discrim_list ) ;
 544 
    return(f_dummy_dg_discrim_list);
553 
}
 545 
}
554 
 
 546 
 
555 
dg_discrim_list add_dg_discrim_list
 547 
dg_discrim_list add_dg_discrim_list
556 
   PROTO_N ( ( list, elem, index ) )
 - 
 
557 
   PROTO_T ( dg_discrim_list list X dg_discrim elem X int index )
 548 
(dg_discrim_list list, dg_discrim elem, int index)
558 
{
 549 
{
559 
    UNUSED ( list ) ;
 550 
    UNUSED(list);
560 
    UNUSED ( elem ) ;
 551 
    UNUSED(elem);
561 
    UNUSED ( index ) ;
 552 
    UNUSED(index);
562 
    return ( f_dummy_dg_discrim_list ) ;
 553 
    return(f_dummy_dg_discrim_list);
563 
}
 554 
}
564 
 
 555 
 
565 
void init_dg_discrim_list
 556 
void init_dg_discrim_list
566 
    PROTO_Z ()
 557 
(void)
567 
{
 558 
{
568 
    return ;
 559 
    return;
569 
}
 560 
}
570 
 
 561 
 
571 
dg_enum f_dg_tag_enum
 562 
dg_enum f_dg_tag_enum
572 
    PROTO_N ( ( tg, e ) )
 - 
 
573 
    PROTO_T ( dg_tag tg X dg_enum e )
 563 
(dg_tag tg, dg_enum e)
574 
{
 564 
{
575 
    UNUSED ( tg ) ;
 565 
    UNUSED(tg);
576 
    UNUSED ( e ) ;
 566 
    UNUSED(e);
577 
    return ( f_dummy_dg_enum ) ;
 567 
    return(f_dummy_dg_enum);
578 
}
 568 
}
579 
 
 569 
 
580 
dg_enum f_make_dg_enum
 570 
dg_enum f_make_dg_enum
581 
    PROTO_N ( ( value, idname, src_pos ) )
 - 
 
582 
    PROTO_T ( exp value X dg_idname idname X dg_sourcepos src_pos )
 571 
(exp value, dg_idname idname, dg_sourcepos src_pos)
583 
{
 572 
{
584 
    UNUSED ( value ) ;
 573 
    UNUSED(value);
585 
    UNUSED ( idname ) ;
 574 
    UNUSED(idname);
586 
    UNUSED ( src_pos ) ;
 575 
    UNUSED(src_pos);
587 
    return ( f_dummy_dg_enum ) ;
 576 
    return(f_dummy_dg_enum);
588 
}
 577 
}
589 
 
 578 
 
590 
dg_enum f_dg_char_enum
 579 
dg_enum f_dg_char_enum
591 
    PROTO_N ( ( value, idchar, src_pos ) )
 - 
 
592 
    PROTO_T ( exp value X nat idchar X dg_sourcepos src_pos )
 580 
(exp value, nat idchar, dg_sourcepos src_pos)
593 
{
 581 
{
594 
    UNUSED ( value ) ;
 582 
    UNUSED(value);
595 
    UNUSED ( idchar ) ;
 583 
    UNUSED(idchar);
596 
    UNUSED ( src_pos ) ;
 584 
    UNUSED(src_pos);
597 
    return ( f_dummy_dg_enum ) ;
 585 
    return(f_dummy_dg_enum);
598 
}
 586 
}
599 
 
 587 
 
600 
dg_enum f_dummy_dg_enum ;
 588 
dg_enum f_dummy_dg_enum;
601 
 
 589 
 
602 
void init_dg_enum
 590 
void init_dg_enum
603 
    PROTO_Z ()
 591 
(void)
604 
{
 592 
{
605 
    return ;
 593 
    return;
606 
}
 594 
}
607 
 
 595 
 
608 
dg_enum_list new_dg_enum_list
 596 
dg_enum_list new_dg_enum_list
609 
    PROTO_N ( ( n ) )
 - 
 
610 
    PROTO_T ( int n )
 597 
(int n)
611 
{
 598 
{
612 
    UNUSED ( n ) ;
 599 
    UNUSED(n);
613 
    return ( f_dummy_dg_enum_list ) ;
 600 
    return(f_dummy_dg_enum_list);
614 
}
 601 
}
615 
 
 602 
 
616 
dg_enum_list add_dg_enum_list
 603 
dg_enum_list add_dg_enum_list
617 
   PROTO_N ( ( list, elem, index ) )
 - 
 
618 
   PROTO_T ( dg_enum_list list X dg_enum elem X int index )
 604 
(dg_enum_list list, dg_enum elem, int index)
619 
{
 605 
{
620 
    UNUSED ( list ) ;
 606 
    UNUSED(list);
621 
    UNUSED ( elem ) ;
 607 
    UNUSED(elem);
622 
    UNUSED ( index ) ;
 608 
    UNUSED(index);
623 
    return ( f_dummy_dg_enum_list ) ;
 609 
    return(f_dummy_dg_enum_list);
624 
}
 610 
}
625 
 
 611 
 
626 
void init_dg_enum_list
 612 
void init_dg_enum_list
627 
    PROTO_Z ()
 613 
(void)
628 
{
 614 
{
629 
    return ;
 615 
    return;
630 
}
 616 
}
631 
 
 617 
 
632 
dg_filename f_dg_filename_apply_token
 618 
dg_filename f_dg_filename_apply_token
633 
    PROTO_N ( ( token_value, token_args ) )
 - 
 
634 
    PROTO_T ( token token_value X bitstream token_args )
 619 
(token token_value, bitstream token_args)
635 
{
 620 
{
636 
    UNUSED ( token_value ) ;
 621 
    UNUSED(token_value);
637 
    UNUSED ( token_args ) ;
 622 
    UNUSED(token_args);
638 
    return ( f_dummy_dg_filename ) ;
 623 
    return(f_dummy_dg_filename);
639 
}
 624 
}
640 
 
 625 
 
641 
dg_filename f_make_dg_filename
 626 
dg_filename f_make_dg_filename
642 
    PROTO_N ( ( date, machine, path, file ) )
 - 
 
643 
    PROTO_T ( nat date X string machine X string path X string file )
 627 
(nat date, string machine, string path, string file)
644 
{
 628 
{
645 
    UNUSED ( date ) ;
 629 
    UNUSED(date);
646 
    UNUSED ( machine ) ;
 630 
    UNUSED(machine);
647 
    UNUSED ( path ) ;
 631 
    UNUSED(path);
648 
    UNUSED ( file ) ;
 632 
    UNUSED(file);
649 
    return ( f_dummy_dg_filename ) ;
 633 
    return(f_dummy_dg_filename);
650 
}
 634 
}
651 
 
 635 
 
652 
dg_filename f_dummy_dg_filename ;
 636 
dg_filename f_dummy_dg_filename;
653 
 
 637 
 
654 
void init_dg_filename
 638 
void init_dg_filename
655 
    PROTO_Z ()
 639 
(void)
656 
{
 640 
{
657 
    return ;
 641 
    return;
658 
}
 642 
}
659 
 
 643 
 
660 
dg_filename_option no_dg_filename_option ;
 644 
dg_filename_option no_dg_filename_option;
661 
 
 645 
 
662 
dg_filename_option yes_dg_filename_option
 646 
dg_filename_option yes_dg_filename_option
663 
    PROTO_N ( ( elem ) )
 - 
 
664 
    PROTO_T ( dg_filename elem )
 647 
(dg_filename elem)
665 
{
 648 
{
666 
    UNUSED ( elem ) ;
 649 
    UNUSED(elem);
667 
    return ( f_dummy_dg_filename_option ) ;
 650 
    return(f_dummy_dg_filename_option);
668 
}
 651 
}
669 
 
 652 
 
670 
void init_dg_filename_option
 653 
void init_dg_filename_option
671 
    PROTO_Z ()
 654 
(void)
672 
{
 655 
{
673 
    return ;
 656 
    return;
674 
}
 657 
}
675 
 
 658 
 
676 
dg_idname f_dg_idname_apply_token
 659 
dg_idname f_dg_idname_apply_token
677 
    PROTO_N ( ( token_value, token_args ) )
 - 
 
678 
    PROTO_T ( token token_value X bitstream token_args )
 660 
(token token_value, bitstream token_args)
679 
{
 661 
{
680 
    UNUSED ( token_value ) ;
 662 
    UNUSED(token_value);
681 
    UNUSED ( token_args ) ;
 663 
    UNUSED(token_args);
682 
    return ( f_dummy_dg_idname ) ;
 664 
    return(f_dummy_dg_idname);
683 
}
 665 
}
684 
 
 666 
 
685 
dg_idname f_dg_anonymous_idname
 667 
dg_idname f_dg_anonymous_idname
686 
    PROTO_N ( ( descr ) )
 - 
 
687 
    PROTO_T ( string_option descr )
 668 
(string_option descr)
688 
{
 669 
{
689 
    UNUSED ( descr ) ;
 670 
    UNUSED(descr);
690 
    return ( f_dummy_dg_idname ) ;
 671 
    return(f_dummy_dg_idname);
691 
}
 672 
}
692 
 
 673 
 
693 
dg_idname f_dg_artificial_idname
 674 
dg_idname f_dg_artificial_idname
694 
    PROTO_N ( ( aname ) )
 - 
 
695 
    PROTO_T ( string_option aname )
 675 
(string_option aname)
696 
{
 676 
{
697 
    UNUSED ( aname ) ;
 677 
    UNUSED(aname);
698 
    return ( f_dummy_dg_idname ) ;
 678 
    return(f_dummy_dg_idname);
699 
}
 679 
}
700 
 
 680 
 
701 
dg_idname f_dg_external_idname
 681 
dg_idname f_dg_external_idname
702 
    PROTO_N ( ( src_name ) )
 - 
 
703 
    PROTO_T ( string src_name )
 682 
(string src_name)
704 
{
 683 
{
705 
    UNUSED ( src_name ) ;
 684 
    UNUSED(src_name);
706 
    return ( f_dummy_dg_idname ) ;
 685 
    return(f_dummy_dg_idname);
707 
}
 686 
}
708 
 
 687 
 
709 
dg_idname f_dg_instance_idname
 688 
dg_idname f_dg_instance_idname
710 
    PROTO_N ( ( idname, spec, whence, aparams ) )
 - 
 
711 
    PROTO_T ( dg_idname_option idname X dg_idname spec X dg_sourcepos whence X dg_name_list aparams )
 689 
(dg_idname_option idname, dg_idname spec, dg_sourcepos whence, dg_name_list aparams)
712 
{
 690 
{
713 
    UNUSED ( idname ) ;
 691 
    UNUSED(idname);
714 
    UNUSED ( spec ) ;
 692 
    UNUSED(spec);
715 
    UNUSED ( whence ) ;
 693 
    UNUSED(whence);
716 
    UNUSED ( aparams ) ;
 694 
    UNUSED(aparams);
717 
    return ( f_dummy_dg_idname ) ;
 695 
    return(f_dummy_dg_idname);
718 
}
 696 
}
719 
 
 697 
 
720 
dg_idname f_dg_sourcestring_idname
 698 
dg_idname f_dg_sourcestring_idname
721 
    PROTO_N ( ( src_name ) )
 - 
 
722 
    PROTO_T ( string src_name )
 699 
(string src_name)
723 
{
 700 
{
724 
    UNUSED ( src_name ) ;
 701 
    UNUSED(src_name);
725 
    return ( f_dummy_dg_idname ) ;
 702 
    return(f_dummy_dg_idname);
726 
}
 703 
}
727 
 
 704 
 
728 
dg_idname f_dummy_dg_idname ;
 705 
dg_idname f_dummy_dg_idname;
729 
 
 706 
 
730 
void init_dg_idname
 707 
void init_dg_idname
731 
    PROTO_Z ()
 708 
(void)
732 
{
 709 
{
733 
    return ;
 710 
    return;
734 
}
 711 
}
735 
 
 712 
 
736 
dg_idname_list new_dg_idname_list
 713 
dg_idname_list new_dg_idname_list
737 
    PROTO_N ( ( n ) )
 - 
 
738 
    PROTO_T ( int n )
 714 
(int n)
739 
{
 715 
{
740 
    UNUSED ( n ) ;
 716 
    UNUSED(n);
741 
    return ( f_dummy_dg_idname_list ) ;
 717 
    return(f_dummy_dg_idname_list);
742 
}
 718 
}
743 
 
 719 
 
744 
dg_idname_list add_dg_idname_list
 720 
dg_idname_list add_dg_idname_list
745 
   PROTO_N ( ( list, elem, index ) )
 - 
 
746 
   PROTO_T ( dg_idname_list list X dg_idname elem X int index )
 721 
(dg_idname_list list, dg_idname elem, int index)
747 
{
 722 
{
748 
    UNUSED ( list ) ;
 723 
    UNUSED(list);
749 
    UNUSED ( elem ) ;
 724 
    UNUSED(elem);
750 
    UNUSED ( index ) ;
 725 
    UNUSED(index);
751 
    return ( f_dummy_dg_idname_list ) ;
 726 
    return(f_dummy_dg_idname_list);
752 
}
 727 
}
753 
 
 728 
 
754 
void init_dg_idname_list
 729 
void init_dg_idname_list
755 
    PROTO_Z ()
 730 
(void)
756 
{
 731 
{
757 
    return ;
 732 
    return;
758 
}
 733 
}
759 
 
 734 
 
760 
dg_idname_option no_dg_idname_option ;
 735 
dg_idname_option no_dg_idname_option;
761 
 
 736 
 
762 
dg_idname_option yes_dg_idname_option
 737 
dg_idname_option yes_dg_idname_option
763 
    PROTO_N ( ( elem ) )
 - 
 
764 
    PROTO_T ( dg_idname elem )
 738 
(dg_idname elem)
765 
{
 739 
{
766 
    UNUSED ( elem ) ;
 740 
    UNUSED(elem);
767 
    return ( f_dummy_dg_idname_option ) ;
 741 
    return(f_dummy_dg_idname_option);
768 
}
 742 
}
769 
 
 743 
 
770 
void init_dg_idname_option
 744 
void init_dg_idname_option
771 
    PROTO_Z ()
 745 
(void)
772 
{
 746 
{
773 
    return ;
 747 
    return;
774 
}
 748 
}
775 
 
 749 
 
776 
dg_macro f_dg_function_macro
 750 
dg_macro f_dg_function_macro
777 
    PROTO_N ( ( src_pos, idname, param, def ) )
 - 
 
778 
    PROTO_T ( dg_sourcepos src_pos X dg_idname idname X dg_idname_list param X string def )
 751 
(dg_sourcepos src_pos, dg_idname idname, dg_idname_list param, string def)
779 
{
 752 
{
780 
    UNUSED ( src_pos ) ;
 753 
    UNUSED(src_pos);
781 
    UNUSED ( idname ) ;
 754 
    UNUSED(idname);
782 
    UNUSED ( param ) ;
 755 
    UNUSED(param);
783 
    UNUSED ( def ) ;
 756 
    UNUSED(def);
784 
    return ( f_dummy_dg_macro ) ;
 757 
    return(f_dummy_dg_macro);
785 
}
 758 
}
786 
 
 759 
 
787 
dg_macro f_dg_include_macro
 760 
dg_macro f_dg_include_macro
788 
    PROTO_N ( ( src_pos, file, macros ) )
 - 
 
789 
    PROTO_T ( dg_sourcepos src_pos X dg_filename file X dg_macro_list macros )
 761 
(dg_sourcepos src_pos, dg_filename file, dg_macro_list macros)
790 
{
 762 
{
791 
    UNUSED ( src_pos ) ;
 763 
    UNUSED(src_pos);
792 
    UNUSED ( file ) ;
 764 
    UNUSED(file);
793 
    UNUSED ( macros ) ;
 765 
    UNUSED(macros);
794 
    return ( f_dummy_dg_macro ) ;
 766 
    return(f_dummy_dg_macro);
795 
}
 767 
}
796 
 
 768 
 
797 
dg_macro f_dg_object_macro
 769 
dg_macro f_dg_object_macro
798 
    PROTO_N ( ( src_pos, idname, def ) )
 - 
 
799 
    PROTO_T ( dg_sourcepos src_pos X dg_idname idname X string def )
 770 
(dg_sourcepos src_pos, dg_idname idname, string def)
800 
{
 771 
{
801 
    UNUSED ( src_pos ) ;
 772 
    UNUSED(src_pos);
802 
    UNUSED ( idname ) ;
 773 
    UNUSED(idname);
803 
    UNUSED ( def ) ;
 774 
    UNUSED(def);
804 
    return ( f_dummy_dg_macro ) ;
 775 
    return(f_dummy_dg_macro);
805 
}
 776 
}
806 
 
 777 
 
807 
dg_macro f_dg_undef_macro
 778 
dg_macro f_dg_undef_macro
808 
    PROTO_N ( ( src_pos, idname ) )
 - 
 
809 
    PROTO_T ( dg_sourcepos src_pos X dg_idname idname )
 779 
(dg_sourcepos src_pos, dg_idname idname)
810 
{
 780 
{
811 
    UNUSED ( src_pos ) ;
 781 
    UNUSED(src_pos);
812 
    UNUSED ( idname ) ;
 782 
    UNUSED(idname);
813 
    return ( f_dummy_dg_macro ) ;
 783 
    return(f_dummy_dg_macro);
814 
}
 784 
}
815 
 
 785 
 
816 
dg_macro f_dummy_dg_macro ;
 786 
dg_macro f_dummy_dg_macro;
817 
 
 787 
 
818 
void init_dg_macro
 788 
void init_dg_macro
819 
    PROTO_Z ()
 789 
(void)
820 
{
 790 
{
821 
    return ;
 791 
    return;
822 
}
 792 
}
823 
 
 793 
 
824 
dg_macro_list new_dg_macro_list
 794 
dg_macro_list new_dg_macro_list
825 
    PROTO_N ( ( n ) )
 - 
 
826 
    PROTO_T ( int n )
 795 
(int n)
827 
{
 796 
{
828 
    UNUSED ( n ) ;
 797 
    UNUSED(n);
829 
    return ( f_dummy_dg_macro_list ) ;
 798 
    return(f_dummy_dg_macro_list);
830 
}
 799 
}
831 
 
 800 
 
832 
dg_macro_list add_dg_macro_list
 801 
dg_macro_list add_dg_macro_list
833 
   PROTO_N ( ( list, elem, index ) )
 - 
 
834 
   PROTO_T ( dg_macro_list list X dg_macro elem X int index )
 802 
(dg_macro_list list, dg_macro elem, int index)
835 
{
 803 
{
836 
    UNUSED ( list ) ;
 804 
    UNUSED(list);
837 
    UNUSED ( elem ) ;
 805 
    UNUSED(elem);
838 
    UNUSED ( index ) ;
 806 
    UNUSED(index);
839 
    return ( f_dummy_dg_macro_list ) ;
 807 
    return(f_dummy_dg_macro_list);
840 
}
 808 
}
841 
 
 809 
 
842 
void init_dg_macro_list
 810 
void init_dg_macro_list
843 
    PROTO_Z ()
 811 
(void)
844 
{
 812 
{
845 
    return ;
 813 
    return;
846 
}
 814 
}
847 
 
 815 
 
848 
dg_name f_dg_name_apply_token
 816 
dg_name f_dg_name_apply_token
849 
    PROTO_N ( ( token_value, token_args ) )
 - 
 
850 
    PROTO_T ( token token_value X bitstream token_args )
 817 
(token token_value, bitstream token_args)
851 
{
 818 
{
852 
    UNUSED ( token_value ) ;
 819 
    UNUSED(token_value);
853 
    UNUSED ( token_args ) ;
 820 
    UNUSED(token_args);
854 
    return ( f_dummy_dg_name ) ;
 821 
    return(f_dummy_dg_name);
855 
}
 822 
}
856 
 
 823 
 
857 
dg_name f_dg_tag_name
 824 
dg_name f_dg_tag_name
858 
    PROTO_N ( ( tg, name ) )
 - 
 
859 
    PROTO_T ( dg_tag tg X dg_name name )
 825 
(dg_tag tg, dg_name name)
860 
{
 826 
{
861 
    UNUSED ( tg ) ;
 827 
    UNUSED(tg);
862 
    UNUSED ( name ) ;
 828 
    UNUSED(name);
863 
    return ( f_dummy_dg_name ) ;
 829 
    return(f_dummy_dg_name);
864 
}
 830 
}
865 
 
 831 
 
866 
dg_name f_dg_constant_name
 832 
dg_name f_dg_constant_name
867 
    PROTO_N ( ( name ) )
 - 
 
868 
    PROTO_T ( dg_name name )
 833 
(dg_name name)
869 
{
 834 
{
870 
    UNUSED ( name ) ;
 835 
    UNUSED(name);
871 
    return ( f_dummy_dg_name ) ;
 836 
    return(f_dummy_dg_name);
872 
}
 837 
}
873 
 
 838 
 
874 
dg_name f_dg_entry_family_name
 839 
dg_name f_dg_entry_family_name
875 
    PROTO_N ( ( proc, family ) )
 - 
 
876 
    PROTO_T ( dg_name proc X dg_dim family )
 840 
(dg_name proc, dg_dim family)
877 
{
 841 
{
878 
    UNUSED ( proc ) ;
 842 
    UNUSED(proc);
879 
    UNUSED ( family ) ;
 843 
    UNUSED(family);
880 
    return ( f_dummy_dg_name ) ;
 844 
    return(f_dummy_dg_name);
881 
}
 845 
}
882 
 
 846 
 
883 
dg_name f_dg_entry_name
 847 
dg_name f_dg_entry_name
884 
    PROTO_N ( ( idname, whence, type, accessibility, family ) )
 - 
 
885 
    PROTO_T ( dg_idname idname X dg_sourcepos whence X dg_type type X dg_accessibility_option accessibility X dg_dim_option family )
 848 
(dg_idname idname, dg_sourcepos whence, dg_type type, dg_accessibility_option accessibility, dg_dim_option family)
886 
{
 849 
{
887 
    UNUSED ( idname ) ;
 850 
    UNUSED(idname);
888 
    UNUSED ( whence ) ;
 851 
    UNUSED(whence);
889 
    UNUSED ( type ) ;
 852 
    UNUSED(type);
890 
    UNUSED ( accessibility ) ;
 853 
    UNUSED(accessibility);
891 
    UNUSED ( family ) ;
 854 
    UNUSED(family);
892 
    return ( f_dummy_dg_name ) ;
 855 
    return(f_dummy_dg_name);
893 
}
 856 
}
894 
 
 857 
 
895 
dg_name f_dg_inlined_name
 858 
dg_name f_dg_inlined_name
896 
    PROTO_N ( ( name, origin ) )
 - 
 
897 
    PROTO_T ( dg_name name X dg_tag origin )
 859 
(dg_name name, dg_tag origin)
898 
{
 860 
{
899 
    UNUSED ( name ) ;
 861 
    UNUSED(name);
900 
    UNUSED ( origin ) ;
 862 
    UNUSED(origin);
901 
    return ( f_dummy_dg_name ) ;
 863 
    return(f_dummy_dg_name);
902 
}
 864 
}
903 
 
 865 
 
904 
dg_name f_dg_is_spec_name
 866 
dg_name f_dg_is_spec_name
905 
    PROTO_N ( ( name, is_separate ) )
 - 
 
906 
    PROTO_T ( dg_name name X bool_option is_separate )
 867 
(dg_name name, bool_option is_separate)
907 
{
 868 
{
908 
    UNUSED ( name ) ;
 869 
    UNUSED(name);
909 
    UNUSED ( is_separate ) ;
 870 
    UNUSED(is_separate);
910 
    return ( f_dummy_dg_name ) ;
 871 
    return(f_dummy_dg_name);
911 
}
 872 
}
912 
 
 873 
 
913 
dg_name f_dg_module_name
 874 
dg_name f_dg_module_name
914 
    PROTO_N ( ( idname, whence, memlist, init, elaboration ) )
 - 
 
915 
    PROTO_T ( dg_idname idname X dg_sourcepos whence X dg_namelist memlist X exp_option init X dg_tag_option elaboration )
 875 
(dg_idname idname, dg_sourcepos whence, dg_namelist memlist, exp_option init, dg_tag_option elaboration)
916 
{
 876 
{
917 
    UNUSED ( idname ) ;
 877 
    UNUSED(idname);
918 
    UNUSED ( whence ) ;
 878 
    UNUSED(whence);
919 
    UNUSED ( memlist ) ;
 879 
    UNUSED(memlist);
920 
    UNUSED ( init ) ;
 880 
    UNUSED(init);
921 
    UNUSED ( elaboration ) ;
 881 
    UNUSED(elaboration);
922 
    return ( f_dummy_dg_name ) ;
 882 
    return(f_dummy_dg_name);
923 
}
 883 
}
924 
 
 884 
 
925 
dg_name f_dg_namespace_name
 885 
dg_name f_dg_namespace_name
926 
    PROTO_N ( ( idname, whence, members ) )
 - 
 
927 
    PROTO_T ( dg_idname idname X dg_sourcepos whence X dg_namelist members )
 886 
(dg_idname idname, dg_sourcepos whence, dg_namelist members)
928 
{
 887 
{
929 
    UNUSED ( idname ) ;
 888 
    UNUSED(idname);
930 
    UNUSED ( whence ) ;
 889 
    UNUSED(whence);
931 
    UNUSED ( members ) ;
 890 
    UNUSED(members);
932 
    return ( f_dummy_dg_name ) ;
 891 
    return(f_dummy_dg_name);
933 
}
 892 
}
934 
 
 893 
 
935 
dg_name f_dg_object_name
 894 
dg_name f_dg_object_name
936 
    PROTO_N ( ( idname, whence, type, obtain_value, accessibility ) )
 - 
 
937 
    PROTO_T ( dg_idname idname X dg_sourcepos whence X dg_type type X exp_option obtain_value X dg_accessibility_option accessibility )
 895 
(dg_idname idname, dg_sourcepos whence, dg_type type, exp_option obtain_value, dg_accessibility_option accessibility)
938 
{
 896 
{
939 
    UNUSED ( idname ) ;
 897 
    UNUSED(idname);
940 
    UNUSED ( whence ) ;
 898 
    UNUSED(whence);
941 
    UNUSED ( type ) ;
 899 
    UNUSED(type);
942 
    UNUSED ( obtain_value ) ;
 900 
    UNUSED(obtain_value);
943 
    UNUSED ( accessibility ) ;
 901 
    UNUSED(accessibility);
944 
    return ( f_dummy_dg_name ) ;
 902 
    return(f_dummy_dg_name);
945 
}
 903 
}
946 
 
 904 
 
947 
dg_name f_dg_proc_name
 905 
dg_name f_dg_proc_name
948 
    PROTO_N ( ( idname, whence, type, obtain_value, accessibility, virtuality, inl, exceptions, elaboration ) )
 - 
 
949 
    PROTO_T ( dg_idname idname X dg_sourcepos whence X dg_type type X exp_option obtain_value X dg_accessibility_option accessibility X dg_virtuality_option virtuality X bool inl X dg_type_list_option exceptions X dg_tag_option elaboration )
 906 
(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)
950 
{
 907 
{
951 
    UNUSED ( idname ) ;
 908 
    UNUSED(idname);
952 
    UNUSED ( whence ) ;
 909 
    UNUSED(whence);
953 
    UNUSED ( type ) ;
 910 
    UNUSED(type);
954 
    UNUSED ( obtain_value ) ;
 911 
    UNUSED(obtain_value);
955 
    UNUSED ( accessibility ) ;
 912 
    UNUSED(accessibility);
956 
    UNUSED ( virtuality ) ;
 913 
    UNUSED(virtuality);
957 
    UNUSED ( inl ) ;
 914 
    UNUSED(inl);
958 
    UNUSED ( exceptions ) ;
 915 
    UNUSED(exceptions);
959 
    UNUSED ( elaboration ) ;
 916 
    UNUSED(elaboration);
960 
    return ( f_dummy_dg_name ) ;
 917 
    return(f_dummy_dg_name);
961 
}
 918 
}
962 
 
 919 
 
963 
dg_name f_dg_program_name
 920 
dg_name f_dg_program_name
964 
    PROTO_N ( ( idname, whence, obtain_value ) )
 - 
 
965 
    PROTO_T ( dg_idname idname X dg_sourcepos whence X exp obtain_value )
 921 
(dg_idname idname, dg_sourcepos whence, exp obtain_value)
966 
{
 922 
{
967 
    UNUSED ( idname ) ;
 923 
    UNUSED(idname);
968 
    UNUSED ( whence ) ;
 924 
    UNUSED(whence);
969 
    UNUSED ( obtain_value ) ;
 925 
    UNUSED(obtain_value);
970 
    return ( f_dummy_dg_name ) ;
 926 
    return(f_dummy_dg_name);
971 
}
 927 
}
972 
 
 928 
 
973 
dg_name f_dg_rep_clause_name
 929 
dg_name f_dg_rep_clause_name
974 
    PROTO_N ( ( item, location ) )
 - 
 
975 
    PROTO_T ( dg_name item X exp location )
 930 
(dg_name item, exp location)
976 
{
 931 
{
977 
    UNUSED ( item ) ;
 932 
    UNUSED(item);
978 
    UNUSED ( location ) ;
 933 
    UNUSED(location);
979 
    return ( f_dummy_dg_name ) ;
 934 
    return(f_dummy_dg_name);
980 
}
 935 
}
981 
 
 936 
 
982 
dg_name f_dg_spec_ref_name
 937 
dg_name f_dg_spec_ref_name
983 
    PROTO_N ( ( specification, name ) )
 - 
 
984 
    PROTO_T ( dg_tag specification X dg_name name )
 938 
(dg_tag specification, dg_name name)
985 
{
 939 
{
986 
    UNUSED ( specification ) ;
 940 
    UNUSED(specification);
987 
    UNUSED ( name ) ;
 941 
    UNUSED(name);
988 
    return ( f_dummy_dg_name ) ;
 942 
    return(f_dummy_dg_name);
989 
}
 943 
}
990 
 
 944 
 
991 
dg_name f_dg_subunit_name
 945 
dg_name f_dg_subunit_name
992 
    PROTO_N ( ( parent, name, subunit_kind, accessibility ) )
 - 
 
993 
    PROTO_T ( dg_tag parent X dg_name name X nat subunit_kind X dg_accessibility_option accessibility )
 946 
(dg_tag parent, dg_name name, nat subunit_kind, dg_accessibility_option accessibility)
994 
{
 947 
{
995 
    UNUSED ( parent ) ;
 948 
    UNUSED(parent);
996 
    UNUSED ( name ) ;
 949 
    UNUSED(name);
997 
    UNUSED ( subunit_kind ) ;
 950 
    UNUSED(subunit_kind);
998 
    UNUSED ( accessibility ) ;
 951 
    UNUSED(accessibility);
999 
    return ( f_dummy_dg_name ) ;
 952 
    return(f_dummy_dg_name);
1000 
}
 953 
}
1001 
 
 954 
 
1002 
dg_name f_dg_type_name
 955 
dg_name f_dg_type_name
1003 
    PROTO_N ( ( idname, whence, accessibility, type, new_type, ada_derived, constraints ) )
 - 
 
1004 
    PROTO_T ( dg_idname_option idname X dg_sourcepos whence X dg_accessibility_option accessibility X dg_type_option type X bool new_type X bool_option ada_derived X dg_constraint_list_option constraints )
 956 
(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)
1005 
{
 957 
{
1006 
    UNUSED ( idname ) ;
 958 
    UNUSED(idname);
1007 
    UNUSED ( whence ) ;
 959 
    UNUSED(whence);
1008 
    UNUSED ( accessibility ) ;
 960 
    UNUSED(accessibility);
1009 
    UNUSED ( type ) ;
 961 
    UNUSED(type);
1010 
    UNUSED ( new_type ) ;
 962 
    UNUSED(new_type);
1011 
    UNUSED ( ada_derived ) ;
 963 
    UNUSED(ada_derived);
1012 
    UNUSED ( constraints ) ;
 964 
    UNUSED(constraints);
1013 
    return ( f_dummy_dg_name ) ;
 965 
    return(f_dummy_dg_name);
1014 
}
 966 
}
1015 
 
 967 
 
1016 
dg_name f_dg_visibility_name
 968 
dg_name f_dg_visibility_name
1017 
    PROTO_N ( ( dname, import_kind, idname, src_pos, accessibility, type ) )
 - 
 
1018 
    PROTO_T ( dg_tag dname X nat import_kind X dg_idname_option idname X dg_sourcepos_option src_pos X dg_accessibility_option accessibility X dg_type_option type )
 969 
(dg_tag dname, nat import_kind, dg_idname_option idname, dg_sourcepos_option src_pos, dg_accessibility_option accessibility, dg_type_option type)
1019 
{
 970 
{
1020 
    UNUSED ( dname ) ;
 971 
    UNUSED(dname);
1021 
    UNUSED ( import_kind ) ;
 972 
    UNUSED(import_kind);
1022 
    UNUSED ( idname ) ;
 973 
    UNUSED(idname);
1023 
    UNUSED ( src_pos ) ;
 974 
    UNUSED(src_pos);
1024 
    UNUSED ( accessibility ) ;
 975 
    UNUSED(accessibility);
1025 
    UNUSED ( type ) ;
 976 
    UNUSED(type);
1026 
    return ( f_dummy_dg_name ) ;
 977 
    return(f_dummy_dg_name);
1027 
}
 978 
}
1028 
 
 979 
 
1029 
dg_name f_dummy_dg_name ;
 980 
dg_name f_dummy_dg_name;
1030 
 
 981 
 
1031 
void init_dg_name
 982 
void init_dg_name
1032 
    PROTO_Z ()
 983 
(void)
1033 
{
 984 
{
1034 
    return ;
 985 
    return;
1035 
}
 986 
}
1036 
 
 987 
 
1037 
dg_name_list new_dg_name_list
 988 
dg_name_list new_dg_name_list
1038 
    PROTO_N ( ( n ) )
 - 
 
1039 
    PROTO_T ( int n )
 989 
(int n)
1040 
{
 990 
{
1041 
    UNUSED ( n ) ;
 991 
    UNUSED(n);
1042 
    return ( f_dummy_dg_name_list ) ;
 992 
    return(f_dummy_dg_name_list);
1043 
}
 993 
}
1044 
 
 994 
 
1045 
dg_name_list add_dg_name_list
 995 
dg_name_list add_dg_name_list
1046 
   PROTO_N ( ( list, elem, index ) )
 - 
 
1047 
   PROTO_T ( dg_name_list list X dg_name elem X int index )
 996 
(dg_name_list list, dg_name elem, int index)
1048 
{
 997 
{
1049 
    UNUSED ( list ) ;
 998 
    UNUSED(list);
1050 
    UNUSED ( elem ) ;
 999 
    UNUSED(elem);
1051 
    UNUSED ( index ) ;
 1000 
    UNUSED(index);
1052 
    return ( f_dummy_dg_name_list ) ;
 1001 
    return(f_dummy_dg_name_list);
1053 
}
 1002 
}
1054 
 
 1003 
 
1055 
void init_dg_name_list
 1004 
void init_dg_name_list
1056 
    PROTO_Z ()
 1005 
(void)
1057 
{
 1006 
{
1058 
    return ;
 1007 
    return;
1059 
}
 1008 
}
1060 
 
 1009 
 
1061 
dg_namelist f_dg_tag_namelist
 1010 
dg_namelist f_dg_tag_namelist
1062 
    PROTO_N ( ( tg, nl ) )
 - 
 
1063 
    PROTO_T ( dg_tag tg X dg_namelist nl )
 1011 
(dg_tag tg, dg_namelist nl)
1064 
{
 1012 
{
1065 
    UNUSED ( tg ) ;
 1013 
    UNUSED(tg);
1066 
    UNUSED ( nl ) ;
 1014 
    UNUSED(nl);
1067 
    return ( f_dummy_dg_namelist ) ;
 1015 
    return(f_dummy_dg_namelist);
1068 
}
 1016 
}
1069 
 
 1017 
 
1070 
dg_namelist f_make_dg_namelist
 1018 
dg_namelist f_make_dg_namelist
1071 
    PROTO_N ( ( items ) )
 - 
 
1072 
    PROTO_T ( dg_name_list items )
 1019 
(dg_name_list items)
1073 
{
 1020 
{
1074 
    UNUSED ( items ) ;
 1021 
    UNUSED(items);
1075 
    return ( f_dummy_dg_namelist ) ;
 1022 
    return(f_dummy_dg_namelist);
1076 
}
 1023 
}
1077 
 
 1024 
 
1078 
dg_namelist f_dummy_dg_namelist ;
 1025 
dg_namelist f_dummy_dg_namelist;
1079 
 
 1026 
 
1080 
void init_dg_namelist
 1027 
void init_dg_namelist
1081 
    PROTO_Z ()
 1028 
(void)
1082 
{
 1029 
{
1083 
    return ;
 1030 
    return;
1084 
}
 1031 
}
1085 
 
 1032 
 
1086 
dg_param f_dg_object_param
 1033 
dg_param f_dg_object_param
1087 
    PROTO_N ( ( idname, src_pos, mode, param_type, deflt ) )
 - 
 
1088 
    PROTO_T ( dg_idname_option idname X dg_sourcepos_option src_pos X dg_param_mode_option mode X dg_type param_type X dg_default_option deflt )
 1034 
(dg_idname_option idname, dg_sourcepos_option src_pos, dg_param_mode_option mode, dg_type param_type, dg_default_option deflt)
1089 
{
 1035 
{
1090 
    UNUSED ( idname ) ;
 1036 
    UNUSED(idname);
1091 
    UNUSED ( src_pos ) ;
 1037 
    UNUSED(src_pos);
1092 
    UNUSED ( mode ) ;
 1038 
    UNUSED(mode);
1093 
    UNUSED ( param_type ) ;
 1039 
    UNUSED(param_type);
1094 
    UNUSED ( deflt ) ;
 1040 
    UNUSED(deflt);
1095 
    return ( f_dummy_dg_param ) ;
 1041 
    return(f_dummy_dg_param);
1096 
}
 1042 
}
1097 
 
 1043 
 
1098 
dg_param f_dg_type_param
 1044 
dg_param f_dg_type_param
1099 
    PROTO_N ( ( idname, src_pos, fparams ) )
 - 
 
1100 
    PROTO_T ( dg_idname_option idname X dg_sourcepos_option src_pos X dg_param_list fparams )
 1045 
(dg_idname_option idname, dg_sourcepos_option src_pos, dg_param_list fparams)
1101 
{
 1046 
{
1102 
    UNUSED ( idname ) ;
 1047 
    UNUSED(idname);
1103 
    UNUSED ( src_pos ) ;
 1048 
    UNUSED(src_pos);
1104 
    UNUSED ( fparams ) ;
 1049 
    UNUSED(fparams);
1105 
    return ( f_dummy_dg_param ) ;
 1050 
    return(f_dummy_dg_param);
1106 
}
 1051 
}
1107 
 
 1052 
 
1108 
dg_param f_dummy_dg_param ;
 1053 
dg_param f_dummy_dg_param;
1109 
 
 1054 
 
1110 
void init_dg_param
 1055 
void init_dg_param
1111 
    PROTO_Z ()
 1056 
(void)
1112 
{
 1057 
{
1113 
    return ;
 1058 
    return;
1114 
}
 1059 
}
1115 
 
 1060 
 
1116 
dg_param_list new_dg_param_list
 1061 
dg_param_list new_dg_param_list
1117 
    PROTO_N ( ( n ) )
 - 
 
1118 
    PROTO_T ( int n )
 1062 
(int n)
1119 
{
 1063 
{
1120 
    UNUSED ( n ) ;
 1064 
    UNUSED(n);
1121 
    return ( f_dummy_dg_param_list ) ;
 1065 
    return(f_dummy_dg_param_list);
1122 
}
 1066 
}
1123 
 
 1067 
 
1124 
dg_param_list add_dg_param_list
 1068 
dg_param_list add_dg_param_list
1125 
   PROTO_N ( ( list, elem, index ) )
 - 
 
1126 
   PROTO_T ( dg_param_list list X dg_param elem X int index )
 1069 
(dg_param_list list, dg_param elem, int index)
1127 
{
 1070 
{
1128 
    UNUSED ( list ) ;
 1071 
    UNUSED(list);
1129 
    UNUSED ( elem ) ;
 1072 
    UNUSED(elem);
1130 
    UNUSED ( index ) ;
 1073 
    UNUSED(index);
1131 
    return ( f_dummy_dg_param_list ) ;
 1074 
    return(f_dummy_dg_param_list);
1132 
}
 1075 
}
1133 
 
 1076 
 
1134 
void init_dg_param_list
 1077 
void init_dg_param_list
1135 
    PROTO_Z ()
 1078 
(void)
1136 
{
 1079 
{
1137 
    return ;
 1080 
    return;
1138 
}
 1081 
}
1139 
 
 1082 
 
1140 
dg_param_mode f_dg_in_mode ;
 1083 
dg_param_mode f_dg_in_mode;
1141 
 
 1084 
 
1142 
dg_param_mode f_dg_inout_mode ;
 1085 
dg_param_mode f_dg_inout_mode;
1143 
 
 1086 
 
1144 
dg_param_mode f_dg_out_mode ;
 1087 
dg_param_mode f_dg_out_mode;
1145 
 
 1088 
 
1146 
dg_param_mode f_dummy_dg_param_mode ;
 1089 
dg_param_mode f_dummy_dg_param_mode;
1147 
 
 1090 
 
1148 
void init_dg_param_mode
 1091 
void init_dg_param_mode
1149 
    PROTO_Z ()
 1092 
(void)
1150 
{
 1093 
{
1151 
    return ;
 1094 
    return;
1152 
}
 1095 
}
1153 
 
 1096 
 
1154 
dg_param_mode_option no_dg_param_mode_option ;
 1097 
dg_param_mode_option no_dg_param_mode_option;
1155 
 
 1098 
 
1156 
dg_param_mode_option yes_dg_param_mode_option
 1099 
dg_param_mode_option yes_dg_param_mode_option
1157 
    PROTO_N ( ( elem ) )
 - 
 
1158 
    PROTO_T ( dg_param_mode elem )
 1100 
(dg_param_mode elem)
1159 
{
 1101 
{
1160 
    UNUSED ( elem ) ;
 1102 
    UNUSED(elem);
1161 
    return ( f_dummy_dg_param_mode_option ) ;
 1103 
    return(f_dummy_dg_param_mode_option);
1162 
}
 1104 
}
1163 
 
 1105 
 
1164 
void init_dg_param_mode_option
 1106 
void init_dg_param_mode_option
1165 
    PROTO_Z ()
 1107 
(void)
1166 
{
 1108 
{
1167 
    return ;
 1109 
    return;
1168 
}
 1110 
}
1169 
 
 1111 
 
1170 
dg_qualifier f_dg_aliased_qualifier ;
 1112 
dg_qualifier f_dg_aliased_qualifier;
1171 
 
 1113 
 
1172 
dg_qualifier f_dg_class_wide_qualifier ;
 1114 
dg_qualifier f_dg_class_wide_qualifier;
1173 
 
 1115 
 
1174 
dg_qualifier f_dg_const_qualifier ;
 1116 
dg_qualifier f_dg_const_qualifier;
1175 
 
 1117 
 
1176 
dg_qualifier f_dg_limited_qualifier ;
 1118 
dg_qualifier f_dg_limited_qualifier;
1177 
 
 1119 
 
1178 
dg_qualifier f_dg_volatile_qualifier ;
 1120 
dg_qualifier f_dg_volatile_qualifier;
1179 
 
 1121 
 
1180 
dg_qualifier f_dummy_dg_qualifier ;
 1122 
dg_qualifier f_dummy_dg_qualifier;
1181 
 
 1123 
 
1182 
void init_dg_qualifier
 1124 
void init_dg_qualifier
1183 
    PROTO_Z ()
 1125 
(void)
1184 
{
 1126 
{
1185 
    return ;
 1127 
    return;
1186 
}
 1128 
}
1187 
 
 1129 
 
1188 
dg_sourcepos f_dg_file_sourcepos
 1130 
dg_sourcepos f_dg_file_sourcepos
1189 
    PROTO_N ( ( file ) )
 - 
 
1190 
    PROTO_T ( dg_filename file )
 1131 
(dg_filename file)
1191 
{
 1132 
{
1192 
    UNUSED ( file ) ;
 1133 
    UNUSED(file);
1193 
    return ( f_dummy_dg_sourcepos ) ;
 1134 
    return(f_dummy_dg_sourcepos);
1194 
}
 1135 
}
1195 
 
 1136 
 
1196 
dg_sourcepos f_dg_global_sourcepos ;
 1137 
dg_sourcepos f_dg_global_sourcepos;
1197 
 
 1138 
 
1198 
dg_sourcepos f_dg_mark_sourcepos
 1139 
dg_sourcepos f_dg_mark_sourcepos
1199 
    PROTO_N ( ( file, line, column ) )
 - 
 
1200 
    PROTO_T ( dg_filename file X nat line X nat column )
 1140 
(dg_filename file, nat line, nat column)
1201 
{
 1141 
{
1202 
    UNUSED ( file ) ;
 1142 
    UNUSED(file);
1203 
    UNUSED ( line ) ;
 1143 
    UNUSED(line);
1204 
    UNUSED ( column ) ;
 1144 
    UNUSED(column);
1205 
    return ( f_dummy_dg_sourcepos ) ;
 1145 
    return(f_dummy_dg_sourcepos);
1206 
}
 1146 
}
1207 
 
 1147 
 
1208 
dg_sourcepos f_dg_null_sourcepos ;
 1148 
dg_sourcepos f_dg_null_sourcepos;
1209 
 
 1149 
 
1210 
dg_sourcepos f_dg_span_sourcepos
 1150 
dg_sourcepos f_dg_span_sourcepos
1211 
    PROTO_N ( ( from_file, from_line, from_column, to_file, to_line, to_column ) )
 - 
 
1212 
    PROTO_T ( dg_filename from_file X nat from_line X nat from_column X dg_filename_option to_file X nat to_line X nat to_column )
 1151 
(dg_filename from_file, nat from_line, nat from_column, dg_filename_option to_file, nat to_line, nat to_column)
1213 
{
 1152 
{
1214 
    UNUSED ( from_file ) ;
 1153 
    UNUSED(from_file);
1215 
    UNUSED ( from_line ) ;
 1154 
    UNUSED(from_line);
1216 
    UNUSED ( from_column ) ;
 1155 
    UNUSED(from_column);
1217 
    UNUSED ( to_file ) ;
 1156 
    UNUSED(to_file);
1218 
    UNUSED ( to_line ) ;
 1157 
    UNUSED(to_line);
1219 
    UNUSED ( to_column ) ;
 1158 
    UNUSED(to_column);
1220 
    return ( f_dummy_dg_sourcepos ) ;
 1159 
    return(f_dummy_dg_sourcepos);
1221 
}
 1160 
}
1222 
 
 1161 
 
1223 
dg_sourcepos f_dummy_dg_sourcepos ;
 1162 
dg_sourcepos f_dummy_dg_sourcepos;
1224 
 
 1163 
 
1225 
void init_dg_sourcepos
 1164 
void init_dg_sourcepos
1226 
    PROTO_Z ()
 1165 
(void)
1227 
{
 1166 
{
1228 
    return ;
 1167 
    return;
1229 
}
 1168 
}
1230 
 
 1169 
 
1231 
dg_sourcepos_option no_dg_sourcepos_option ;
 1170 
dg_sourcepos_option no_dg_sourcepos_option;
1232 
 
 1171 
 
1233 
dg_sourcepos_option yes_dg_sourcepos_option
 1172 
dg_sourcepos_option yes_dg_sourcepos_option
1234 
    PROTO_N ( ( elem ) )
 - 
 
1235 
    PROTO_T ( dg_sourcepos elem )
 1173 
(dg_sourcepos elem)
1236 
{
 1174 
{
1237 
    UNUSED ( elem ) ;
 1175 
    UNUSED(elem);
1238 
    return ( f_dummy_dg_sourcepos_option ) ;
 1176 
    return(f_dummy_dg_sourcepos_option);
1239 
}
 1177 
}
1240 
 
 1178 
 
1241 
void init_dg_sourcepos_option
 1179 
void init_dg_sourcepos_option
1242 
    PROTO_Z ()
 1180 
(void)
1243 
{
 1181 
{
1244 
    return ;
 1182 
    return;
1245 
}
 1183 
}
1246 
 
 1184 
 
1247 
dg_tag f_make_dg_tag
 1185 
dg_tag f_make_dg_tag
1248 
    PROTO_N ( ( num ) )
 - 
 
1249 
    PROTO_T ( tdfint num )
 1186 
(tdfint num)
1250 
{
 1187 
{
1251 
    UNUSED ( num ) ;
 1188 
    UNUSED(num);
1252 
    return ( f_dummy_dg_tag ) ;
 1189 
    return(f_dummy_dg_tag);
1253 
}
 1190 
}
1254 
 
 1191 
 
1255 
dg_tag f_dummy_dg_tag ;
 1192 
dg_tag f_dummy_dg_tag;
1256 
 
 1193 
 
1257 
void init_dg_tag
 1194 
void init_dg_tag
1258 
    PROTO_Z ()
 1195 
(void)
1259 
{
 1196 
{
1260 
    return ;
 1197 
    return;
1261 
}
 1198 
}
1262 
 
 1199 
 
1263 
dg_tag_list new_dg_tag_list
 1200 
dg_tag_list new_dg_tag_list
1264 
    PROTO_N ( ( n ) )
 - 
 
1265 
    PROTO_T ( int n )
 1201 
(int n)
1266 
{
 1202 
{
1267 
    UNUSED ( n ) ;
 1203 
    UNUSED(n);
1268 
    return ( f_dummy_dg_tag_list ) ;
 1204 
    return(f_dummy_dg_tag_list);
1269 
}
 1205 
}
1270 
 
 1206 
 
1271 
dg_tag_list add_dg_tag_list
 1207 
dg_tag_list add_dg_tag_list
1272 
   PROTO_N ( ( list, elem, index ) )
 - 
 
1273 
   PROTO_T ( dg_tag_list list X dg_tag elem X int index )
 1208 
(dg_tag_list list, dg_tag elem, int index)
1274 
{
 1209 
{
1275 
    UNUSED ( list ) ;
 1210 
    UNUSED(list);
1276 
    UNUSED ( elem ) ;
 1211 
    UNUSED(elem);
1277 
    UNUSED ( index ) ;
 1212 
    UNUSED(index);
1278 
    return ( f_dummy_dg_tag_list ) ;
 1213 
    return(f_dummy_dg_tag_list);
1279 
}
 1214 
}
1280 
 
 1215 
 
1281 
void init_dg_tag_list
 1216 
void init_dg_tag_list
1282 
    PROTO_Z ()
 1217 
(void)
1283 
{
 1218 
{
1284 
    return ;
 1219 
    return;
1285 
}
 1220 
}
1286 
 
 1221 
 
1287 
dg_tag_option no_dg_tag_option ;
 1222 
dg_tag_option no_dg_tag_option;
1288 
 
 1223 
 
1289 
dg_tag_option yes_dg_tag_option
 1224 
dg_tag_option yes_dg_tag_option
1290 
    PROTO_N ( ( elem ) )
 - 
 
1291 
    PROTO_T ( dg_tag elem )
 1225 
(dg_tag elem)
1292 
{
 1226 
{
1293 
    UNUSED ( elem ) ;
 1227 
    UNUSED(elem);
1294 
    return ( f_dummy_dg_tag_option ) ;
 1228 
    return(f_dummy_dg_tag_option);
1295 
}
 1229 
}
1296 
 
 1230 
 
1297 
void init_dg_tag_option
 1231 
void init_dg_tag_option
1298 
    PROTO_Z ()
 1232 
(void)
1299 
{
 1233 
{
1300 
    return ;
 1234 
    return;
1301 
}
 1235 
}
1302 
 
 1236 
 
1303 
dg_type f_dg_type_apply_token
 1237 
dg_type f_dg_type_apply_token
1304 
    PROTO_N ( ( token_value, token_args ) )
 - 
 
1305 
    PROTO_T ( token token_value X bitstream token_args )
 1238 
(token token_value, bitstream token_args)
1306 
{
 1239 
{
1307 
    UNUSED ( token_value ) ;
 1240 
    UNUSED(token_value);
1308 
    UNUSED ( token_args ) ;
 1241 
    UNUSED(token_args);
1309 
    return ( f_dummy_dg_type ) ;
 1242 
    return(f_dummy_dg_type);
1310 
}
 1243 
}
1311 
 
 1244 
 
1312 
dg_type f_dg_tag_type
 1245 
dg_type f_dg_tag_type
1313 
    PROTO_N ( ( tg, type ) )
 - 
 
1314 
    PROTO_T ( dg_tag tg X dg_type type )
 1246 
(dg_tag tg, dg_type type)
1315 
{
 1247 
{
1316 
    UNUSED ( tg ) ;
 1248 
    UNUSED(tg);
1317 
    UNUSED ( type ) ;
 1249 
    UNUSED(type);
1318 
    return ( f_dummy_dg_type ) ;
 1250 
    return(f_dummy_dg_type);
1319 
}
 1251 
}
1320 
 
 1252 
 
1321 
dg_type f_dg_address_type
 1253 
dg_type f_dg_address_type
1322 
    PROTO_N ( ( idname, sh ) )
 - 
 
1323 
    PROTO_T ( dg_idname idname X shape sh )
 1254 
(dg_idname idname, shape sh)
1324 
{
 1255 
{
1325 
    UNUSED ( idname ) ;
 1256 
    UNUSED(idname);
1326 
    UNUSED ( sh ) ;
 1257 
    UNUSED(sh);
1327 
    return ( f_dummy_dg_type ) ;
 1258 
    return(f_dummy_dg_type);
1328 
}
 1259 
}
1329 
 
 1260 
 
1330 
dg_type f_dg_array_type
 1261 
dg_type f_dg_array_type
1331 
    PROTO_N ( ( element_type, stride, row_major, dimensions ) )
 - 
 
1332 
    PROTO_T ( dg_type element_type X exp stride X bool_option row_major X dg_dim_list dimensions )
 1262 
(dg_type element_type, exp stride, bool_option row_major, dg_dim_list dimensions)
1333 
{
 1263 
{
1334 
    UNUSED ( element_type ) ;
 1264 
    UNUSED(element_type);
1335 
    UNUSED ( stride ) ;
 1265 
    UNUSED(stride);
1336 
    UNUSED ( row_major ) ;
 1266 
    UNUSED(row_major);
1337 
    UNUSED ( dimensions ) ;
 1267 
    UNUSED(dimensions);
1338 
    return ( f_dummy_dg_type ) ;
 1268 
    return(f_dummy_dg_type);
1339 
}
 1269 
}
1340 
 
 1270 
 
1341 
dg_type f_dg_bitfield_type
 1271 
dg_type f_dg_bitfield_type
1342 
    PROTO_N ( ( type, bv, sh ) )
 - 
 
1343 
    PROTO_T ( dg_type type X bitfield_variety bv X shape sh )
 1272 
(dg_type type, bitfield_variety bv, shape sh)
1344 
{
 1273 
{
1345 
    UNUSED ( type ) ;
 1274 
    UNUSED(type);
1346 
    UNUSED ( bv ) ;
 1275 
    UNUSED(bv);
1347 
    UNUSED ( sh ) ;
 1276 
    UNUSED(sh);
1348 
    return ( f_dummy_dg_type ) ;
 1277 
    return(f_dummy_dg_type);
1349 
}
 1278 
}
1350 
 
 1279 
 
1351 
dg_type f_dg_boolean_type
 1280 
dg_type f_dg_boolean_type
1352 
    PROTO_N ( ( idname, var ) )
 - 
 
1353 
    PROTO_T ( dg_idname idname X variety var )
 1281 
(dg_idname idname, variety var)
1354 
{
 1282 
{
1355 
    UNUSED ( idname ) ;
 1283 
    UNUSED(idname);
1356 
    UNUSED ( var ) ;
 1284 
    UNUSED(var);
1357 
    return ( f_dummy_dg_type ) ;
 1285 
    return(f_dummy_dg_type);
1358 
}
 1286 
}
1359 
 
 1287 
 
1360 
dg_type f_dg_char_type
 1288 
dg_type f_dg_char_type
1361 
    PROTO_N ( ( idname, var ) )
 - 
 
1362 
    PROTO_T ( dg_idname idname X variety var )
 1289 
(dg_idname idname, variety var)
1363 
{
 1290 
{
1364 
    UNUSED ( idname ) ;
 1291 
    UNUSED(idname);
1365 
    UNUSED ( var ) ;
 1292 
    UNUSED(var);
1366 
    return ( f_dummy_dg_type ) ;
 1293 
    return(f_dummy_dg_type);
1367 
}
 1294 
}
1368 
 
 1295 
 
1369 
dg_type f_dg_class_type
 1296 
dg_type f_dg_class_type
1370 
    PROTO_N ( ( inheritance, members, varpart, friends, sh, vtable_static, vtable_dynamic, tagname, src_pos, is_union, rtti_static, rtti_dynamic, new_type, ada_derived ) )
 1297 
(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)
1371 
    PROTO_T ( dg_class_base_list inheritance X dg_classmem_list members X dg_varpart_option varpart X dg_tag_list friends X shape_option sh X dg_tag_option vtable_static X dg_tag_option vtable_dynamic X dg_idname_option tagname X dg_sourcepos_option src_pos X bool is_union X dg_tag_option rtti_static X dg_tag_option rtti_dynamic X bool new_type X bool_option ada_derived )
 - 
 
1372 
{
 1298 
{
1373 
    UNUSED ( inheritance ) ;
 1299 
    UNUSED(inheritance);
1374 
    UNUSED ( members ) ;
 1300 
    UNUSED(members);
1375 
    UNUSED ( varpart ) ;
 1301 
    UNUSED(varpart);
1376 
    UNUSED ( friends ) ;
 1302 
    UNUSED(friends);
1377 
    UNUSED ( sh ) ;
 1303 
    UNUSED(sh);
1378 
    UNUSED ( vtable_static ) ;
 1304 
    UNUSED(vtable_static);
1379 
    UNUSED ( vtable_dynamic ) ;
 1305 
    UNUSED(vtable_dynamic);
1380 
    UNUSED ( tagname ) ;
 1306 
    UNUSED(tagname);
1381 
    UNUSED ( src_pos ) ;
 1307 
    UNUSED(src_pos);
1382 
    UNUSED ( is_union ) ;
 1308 
    UNUSED(is_union);
1383 
    UNUSED ( rtti_static ) ;
 1309 
    UNUSED(rtti_static);
1384 
    UNUSED ( rtti_dynamic ) ;
 1310 
    UNUSED(rtti_dynamic);
1385 
    UNUSED ( new_type ) ;
 1311 
    UNUSED(new_type);
1386 
    UNUSED ( ada_derived ) ;
 1312 
    UNUSED(ada_derived);
1387 
    return ( f_dummy_dg_type ) ;
 1313 
    return(f_dummy_dg_type);
1388 
}
 1314 
}
1389 
 
 1315 
 
1390 
dg_type f_dg_complex_float_type
 1316 
dg_type f_dg_complex_float_type
1391 
    PROTO_N ( ( idname, var ) )
 - 
 
1392 
    PROTO_T ( dg_idname idname X floating_variety var )
 1317 
(dg_idname idname, floating_variety var)
1393 
{
 1318 
{
1394 
    UNUSED ( idname ) ;
 1319 
    UNUSED(idname);
1395 
    UNUSED ( var ) ;
 1320 
    UNUSED(var);
1396 
    return ( f_dummy_dg_type ) ;
 1321 
    return(f_dummy_dg_type);
1397 
}
 1322 
}
1398 
 
 1323 
 
1399 
dg_type f_dg_enum_type
 1324 
dg_type f_dg_enum_type
1400 
    PROTO_N ( ( values, tagname, src_pos, sh, new_type ) )
 - 
 
1401 
    PROTO_T ( dg_enum_list values X dg_idname_option tagname X dg_sourcepos_option src_pos X shape sh X bool new_type )
 1325 
(dg_enum_list values, dg_idname_option tagname, dg_sourcepos_option src_pos, shape sh, bool new_type)
1402 
{
 1326 
{
1403 
    UNUSED ( values ) ;
 1327 
    UNUSED(values);
1404 
    UNUSED ( tagname ) ;
 1328 
    UNUSED(tagname);
1405 
    UNUSED ( src_pos ) ;
 1329 
    UNUSED(src_pos);
1406 
    UNUSED ( sh ) ;
 1330 
    UNUSED(sh);
1407 
    UNUSED ( new_type ) ;
 1331 
    UNUSED(new_type);
1408 
    return ( f_dummy_dg_type ) ;
 1332 
    return(f_dummy_dg_type);
1409 
}
 1333 
}
1410 
 
 1334 
 
1411 
dg_type f_dg_file_type
 1335 
dg_type f_dg_file_type
1412 
    PROTO_N ( ( elem_type, sh ) )
 - 
 
1413 
    PROTO_T ( dg_type elem_type X shape sh )
 1336 
(dg_type elem_type, shape sh)
1414 
{
 1337 
{
1415 
    UNUSED ( elem_type ) ;
 1338 
    UNUSED(elem_type);
1416 
    UNUSED ( sh ) ;
 1339 
    UNUSED(sh);
1417 
    return ( f_dummy_dg_type ) ;
 1340 
    return(f_dummy_dg_type);
1418 
}
 1341 
}
1419 
 
 1342 
 
1420 
dg_type f_dg_fixed_point_type
 1343 
dg_type f_dg_fixed_point_type
1421 
    PROTO_N ( ( rep_type, small, delta, digits ) )
 - 
 
1422 
    PROTO_T ( dg_type rep_type X exp small X exp_option delta X exp_option digits )
 1344 
(dg_type rep_type, exp small, exp_option delta, exp_option digits)
1423 
{
 1345 
{
1424 
    UNUSED ( rep_type ) ;
 1346 
    UNUSED(rep_type);
1425 
    UNUSED ( small ) ;
 1347 
    UNUSED(small);
1426 
    UNUSED ( delta ) ;
 1348 
    UNUSED(delta);
1427 
    UNUSED ( digits ) ;
 1349 
    UNUSED(digits);
1428 
    return ( f_dummy_dg_type ) ;
 1350 
    return(f_dummy_dg_type);
1429 
}
 1351 
}
1430 
 
 1352 
 
1431 
dg_type f_dg_float_type
 1353 
dg_type f_dg_float_type
1432 
    PROTO_N ( ( idname, var ) )
 - 
 
1433 
    PROTO_T ( dg_idname idname X floating_variety var )
 1354 
(dg_idname idname, floating_variety var)
1434 
{
 1355 
{
1435 
    UNUSED ( idname ) ;
 1356 
    UNUSED(idname);
1436 
    UNUSED ( var ) ;
 1357 
    UNUSED(var);
1437 
    return ( f_dummy_dg_type ) ;
 1358 
    return(f_dummy_dg_type);
1438 
}
 1359 
}
1439 
 
 1360 
 
1440 
dg_type f_dg_floating_digits_type
 1361 
dg_type f_dg_floating_digits_type
1441 
    PROTO_N ( ( rep_type, digits ) )
 - 
 
1442 
    PROTO_T ( dg_type rep_type X exp digits )
 1362 
(dg_type rep_type, exp digits)
1443 
{
 1363 
{
1444 
    UNUSED ( rep_type ) ;
 1364 
    UNUSED(rep_type);
1445 
    UNUSED ( digits ) ;
 1365 
    UNUSED(digits);
1446 
    return ( f_dummy_dg_type ) ;
 1366 
    return(f_dummy_dg_type);
1447 
}
 1367 
}
1448 
 
 1368 
 
1449 
dg_type f_dg_inlined_type
 1369 
dg_type f_dg_inlined_type
1450 
    PROTO_N ( ( type, origin ) )
 - 
 
1451 
    PROTO_T ( dg_type type X dg_tag origin )
 1370 
(dg_type type, dg_tag origin)
1452 
{
 1371 
{
1453 
    UNUSED ( type ) ;
 1372 
    UNUSED(type);
1454 
    UNUSED ( origin ) ;
 1373 
    UNUSED(origin);
1455 
    return ( f_dummy_dg_type ) ;
 1374 
    return(f_dummy_dg_type);
1456 
}
 1375 
}
1457 
 
 1376 
 
1458 
dg_type f_dg_integer_type
 1377 
dg_type f_dg_integer_type
1459 
    PROTO_N ( ( idname, var ) )
 - 
 
1460 
    PROTO_T ( dg_idname idname X variety var )
 1378 
(dg_idname idname, variety var)
1461 
{
 1379 
{
1462 
    UNUSED ( idname ) ;
 1380 
    UNUSED(idname);
1463 
    UNUSED ( var ) ;
 1381 
    UNUSED(var);
1464 
    return ( f_dummy_dg_type ) ;
 1382 
    return(f_dummy_dg_type);
1465 
}
 1383 
}
1466 
 
 1384 
 
1467 
dg_type f_dg_is_spec_type
 1385 
dg_type f_dg_is_spec_type
1468 
    PROTO_N ( ( type ) )
 - 
 
1469 
    PROTO_T ( dg_type type )
 1386 
(dg_type type)
1470 
{
 1387 
{
1471 
    UNUSED ( type ) ;
 1388 
    UNUSED(type);
1472 
    return ( f_dummy_dg_type ) ;
 1389 
    return(f_dummy_dg_type);
1473 
}
 1390 
}
1474 
 
 1391 
 
1475 
dg_type f_dg_modular_type
 1392 
dg_type f_dg_modular_type
1476 
    PROTO_N ( ( rep_type, size ) )
 - 
 
1477 
    PROTO_T ( dg_type rep_type X exp size )
 1393 
(dg_type rep_type, exp size)
1478 
{
 1394 
{
1479 
    UNUSED ( rep_type ) ;
 1395 
    UNUSED(rep_type);
1480 
    UNUSED ( size ) ;
 1396 
    UNUSED(size);
1481 
    return ( f_dummy_dg_type ) ;
 1397 
    return(f_dummy_dg_type);
1482 
}
 1398 
}
1483 
 
 1399 
 
1484 
dg_type f_dg_named_type
 1400 
dg_type f_dg_named_type
1485 
    PROTO_N ( ( dname ) )
 - 
 
1486 
    PROTO_T ( dg_tag dname )
 1401 
(dg_tag dname)
1487 
{
 1402 
{
1488 
    UNUSED ( dname ) ;
 1403 
    UNUSED(dname);
1489 
    return ( f_dummy_dg_type ) ;
 1404 
    return(f_dummy_dg_type);
1490 
}
 1405 
}
1491 
 
 1406 
 
1492 
dg_type f_dg_packed_type
 1407 
dg_type f_dg_packed_type
1493 
    PROTO_N ( ( type, sh ) )
 - 
 
1494 
    PROTO_T ( dg_type type X shape sh )
 1408 
(dg_type type, shape sh)
1495 
{
 1409 
{
1496 
    UNUSED ( type ) ;
 1410 
    UNUSED(type);
1497 
    UNUSED ( sh ) ;
 1411 
    UNUSED(sh);
1498 
    return ( f_dummy_dg_type ) ;
 1412 
    return(f_dummy_dg_type);
1499 
}
 1413 
}
1500 
 
 1414 
 
1501 
dg_type f_dg_pointer_type
 1415 
dg_type f_dg_pointer_type
1502 
    PROTO_N ( ( type, heap_only ) )
 - 
 
1503 
    PROTO_T ( dg_type type X bool_option heap_only )
 1416 
(dg_type type, bool_option heap_only)
1504 
{
 1417 
{
1505 
    UNUSED ( type ) ;
 1418 
    UNUSED(type);
1506 
    UNUSED ( heap_only ) ;
 1419 
    UNUSED(heap_only);
1507 
    return ( f_dummy_dg_type ) ;
 1420 
    return(f_dummy_dg_type);
1508 
}
 1421 
}
1509 
 
 1422 
 
1510 
dg_type f_dg_proc_type
 1423 
dg_type f_dg_proc_type
1511 
    PROTO_N ( ( params, result_type, prototype, call_convention, language, prcprops ) )
 - 
 
1512 
    PROTO_T ( dg_param_list params X dg_type result_type X bool_option prototype X nat_option call_convention X nat_option language X procprops_option prcprops )
 1424 
(dg_param_list params, dg_type result_type, bool_option prototype, nat_option call_convention, nat_option language, procprops_option prcprops)
1513 
{
 1425 
{
1514 
    UNUSED ( params ) ;
 1426 
    UNUSED(params);
1515 
    UNUSED ( result_type ) ;
 1427 
    UNUSED(result_type);
1516 
    UNUSED ( prototype ) ;
 1428 
    UNUSED(prototype);
1517 
    UNUSED ( call_convention ) ;
 1429 
    UNUSED(call_convention);
1518 
    UNUSED ( language ) ;
 1430 
    UNUSED(language);
1519 
    UNUSED ( prcprops ) ;
 1431 
    UNUSED(prcprops);
1520 
    return ( f_dummy_dg_type ) ;
 1432 
    return(f_dummy_dg_type);
1521 
}
 1433 
}
1522 
 
 1434 
 
1523 
dg_type f_dg_ptr_memdata_type
 1435 
dg_type f_dg_ptr_memdata_type
1524 
    PROTO_N ( ( cls, memtype, sh, pdm_type ) )
 - 
 
1525 
    PROTO_T ( dg_tag cls X dg_type memtype X shape sh X dg_tag_option pdm_type )
 1436 
(dg_tag cls, dg_type memtype, shape sh, dg_tag_option pdm_type)
1526 
{
 1437 
{
1527 
    UNUSED ( cls ) ;
 1438 
    UNUSED(cls);
1528 
    UNUSED ( memtype ) ;
 1439 
    UNUSED(memtype);
1529 
    UNUSED ( sh ) ;
 1440 
    UNUSED(sh);
1530 
    UNUSED ( pdm_type ) ;
 1441 
    UNUSED(pdm_type);
1531 
    return ( f_dummy_dg_type ) ;
 1442 
    return(f_dummy_dg_type);
1532 
}
 1443 
}
1533 
 
 1444 
 
1534 
dg_type f_dg_ptr_memfn_type
 1445 
dg_type f_dg_ptr_memfn_type
1535 
    PROTO_N ( ( cls, memtype, sh, pfn_type ) )
 - 
 
1536 
    PROTO_T ( dg_tag cls X dg_type memtype X shape sh X dg_tag_option pfn_type )
 1446 
(dg_tag cls, dg_type memtype, shape sh, dg_tag_option pfn_type)
1537 
{
 1447 
{
1538 
    UNUSED ( cls ) ;
 1448 
    UNUSED(cls);
1539 
    UNUSED ( memtype ) ;
 1449 
    UNUSED(memtype);
1540 
    UNUSED ( sh ) ;
 1450 
    UNUSED(sh);
1541 
    UNUSED ( pfn_type ) ;
 1451 
    UNUSED(pfn_type);
1542 
    return ( f_dummy_dg_type ) ;
 1452 
    return(f_dummy_dg_type);
1543 
}
 1453 
}
1544 
 
 1454 
 
1545 
dg_type f_dg_qualified_type
 1455 
dg_type f_dg_qualified_type
1546 
    PROTO_N ( ( qualifier, type ) )
 - 
 
1547 
    PROTO_T ( dg_qualifier qualifier X dg_type type )
 1456 
(dg_qualifier qualifier, dg_type type)
1548 
{
 1457 
{
1549 
    UNUSED ( qualifier ) ;
 1458 
    UNUSED(qualifier);
1550 
    UNUSED ( type ) ;
 1459 
    UNUSED(type);
1551 
    return ( f_dummy_dg_type ) ;
 1460 
    return(f_dummy_dg_type);
1552 
}
 1461 
}
1553 
 
 1462 
 
1554 
dg_type f_dg_reference_type
 1463 
dg_type f_dg_reference_type
1555 
    PROTO_N ( ( type ) )
 - 
 
1556 
    PROTO_T ( dg_type type )
 1464 
(dg_type type)
1557 
{
 1465 
{
1558 
    UNUSED ( type ) ;
 1466 
    UNUSED(type);
1559 
    return ( f_dummy_dg_type ) ;
 1467 
    return(f_dummy_dg_type);
1560 
}
 1468 
}
1561 
 
 1469 
 
1562 
dg_type f_dg_set_type
 1470 
dg_type f_dg_set_type
1563 
    PROTO_N ( ( element_type, sh ) )
 - 
 
1564 
    PROTO_T ( dg_type element_type X shape sh )
 1471 
(dg_type element_type, shape sh)
1565 
{
 1472 
{
1566 
    UNUSED ( element_type ) ;
 1473 
    UNUSED(element_type);
1567 
    UNUSED ( sh ) ;
 1474 
    UNUSED(sh);
1568 
    return ( f_dummy_dg_type ) ;
 1475 
    return(f_dummy_dg_type);
1569 
}
 1476 
}
1570 
 
 1477 
 
1571 
dg_type f_dg_spec_ref_type
 1478 
dg_type f_dg_spec_ref_type
1572 
    PROTO_N ( ( specification, type ) )
 - 
 
1573 
    PROTO_T ( dg_tag specification X dg_type type )
 1479 
(dg_tag specification, dg_type type)
1574 
{
 1480 
{
1575 
    UNUSED ( specification ) ;
 1481 
    UNUSED(specification);
1576 
    UNUSED ( type ) ;
 1482 
    UNUSED(type);
1577 
    return ( f_dummy_dg_type ) ;
 1483 
    return(f_dummy_dg_type);
1578 
}
 1484 
}
1579 
 
 1485 
 
1580 
dg_type f_dg_string_type
 1486 
dg_type f_dg_string_type
1581 
    PROTO_N ( ( character_type, lower_bound, length ) )
 - 
 
1582 
    PROTO_T ( dg_tag character_type X exp lower_bound X exp length )
 1487 
(dg_tag character_type, exp lower_bound, exp length)
1583 
{
 1488 
{
1584 
    UNUSED ( character_type ) ;
 1489 
    UNUSED(character_type);
1585 
    UNUSED ( lower_bound ) ;
 1490 
    UNUSED(lower_bound);
1586 
    UNUSED ( length ) ;
 1491 
    UNUSED(length);
1587 
    return ( f_dummy_dg_type ) ;
 1492 
    return(f_dummy_dg_type);
1588 
}
 1493 
}
1589 
 
 1494 
 
1590 
dg_type f_dg_struct_type
 1495 
dg_type f_dg_struct_type
1591 
    PROTO_N ( ( fields, sh, tagname, src_pos, varpart, is_union, new_type ) )
 - 
 
1592 
    PROTO_T ( dg_classmem_list fields X shape_option sh X dg_idname_option tagname X dg_sourcepos_option src_pos X dg_varpart_option varpart X bool is_union X bool new_type )
 1496 
(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)
1593 
{
 1497 
{
1594 
    UNUSED ( fields ) ;
 1498 
    UNUSED(fields);
1595 
    UNUSED ( sh ) ;
 1499 
    UNUSED(sh);
1596 
    UNUSED ( tagname ) ;
 1500 
    UNUSED(tagname);
1597 
    UNUSED ( src_pos ) ;
 1501 
    UNUSED(src_pos);
1598 
    UNUSED ( varpart ) ;
 1502 
    UNUSED(varpart);
1599 
    UNUSED ( is_union ) ;
 1503 
    UNUSED(is_union);
1600 
    UNUSED ( new_type ) ;
 1504 
    UNUSED(new_type);
1601 
    return ( f_dummy_dg_type ) ;
 1505 
    return(f_dummy_dg_type);
1602 
}
 1506 
}
1603 
 
 1507 
 
1604 
dg_type f_dg_subrange_type
 1508 
dg_type f_dg_subrange_type
1605 
    PROTO_N ( ( rep_type, low, high ) )
 - 
 
1606 
    PROTO_T ( dg_type rep_type X dg_bound low X dg_bound high )
 1509 
(dg_type rep_type, dg_bound low, dg_bound high)
1607 
{
 1510 
{
1608 
    UNUSED ( rep_type ) ;
 1511 
    UNUSED(rep_type);
1609 
    UNUSED ( low ) ;
 1512 
    UNUSED(low);
1610 
    UNUSED ( high ) ;
 1513 
    UNUSED(high);
1611 
    return ( f_dummy_dg_type ) ;
 1514 
    return(f_dummy_dg_type);
1612 
}
 1515 
}
1613 
 
 1516 
 
1614 
dg_type f_dg_synchronous_type
 1517 
dg_type f_dg_synchronous_type
1615 
    PROTO_N ( ( idname, whence, entries, socb, members, varpart, sh, new_type, elaboration ) )
 - 
 
1616 
    PROTO_T ( dg_idname idname X dg_sourcepos whence X dg_name_list entries X dg_tag socb X dg_classmem_list members X dg_varpart_option varpart X shape_option sh X bool new_type X dg_tag_option elaboration )
 1518 
(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)
1617 
{
 1519 
{
1618 
    UNUSED ( idname ) ;
 1520 
    UNUSED(idname);
1619 
    UNUSED ( whence ) ;
 1521 
    UNUSED(whence);
1620 
    UNUSED ( entries ) ;
 1522 
    UNUSED(entries);
1621 
    UNUSED ( socb ) ;
 1523 
    UNUSED(socb);
1622 
    UNUSED ( members ) ;
 1524 
    UNUSED(members);
1623 
    UNUSED ( varpart ) ;
 1525 
    UNUSED(varpart);
1624 
    UNUSED ( sh ) ;
 1526 
    UNUSED(sh);
1625 
    UNUSED ( new_type ) ;
 1527 
    UNUSED(new_type);
1626 
    UNUSED ( elaboration ) ;
 1528 
    UNUSED(elaboration);
1627 
    return ( f_dummy_dg_type ) ;
 1529 
    return(f_dummy_dg_type);
1628 
}
 1530 
}
1629 
 
 1531 
 
1630 
dg_type f_dg_task_type
 1532 
dg_type f_dg_task_type
1631 
    PROTO_N ( ( idname, whence, entries, task_id, tcb, members, varpart, sh, new_type, elaboration ) )
 - 
 
1632 
    PROTO_T ( dg_idname idname X dg_sourcepos whence X dg_name_list entries X dg_tag task_id X dg_tag tcb X dg_classmem_list members X dg_varpart_option varpart X shape_option sh X bool new_type X dg_tag_option elaboration )
 1533 
(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)
1633 
{
 1534 
{
1634 
    UNUSED ( idname ) ;
 1535 
    UNUSED(idname);
1635 
    UNUSED ( whence ) ;
 1536 
    UNUSED(whence);
1636 
    UNUSED ( entries ) ;
 1537 
    UNUSED(entries);
1637 
    UNUSED ( task_id ) ;
 1538 
    UNUSED(task_id);
1638 
    UNUSED ( tcb ) ;
 1539 
    UNUSED(tcb);
1639 
    UNUSED ( members ) ;
 1540 
    UNUSED(members);
1640 
    UNUSED ( varpart ) ;
 1541 
    UNUSED(varpart);
1641 
    UNUSED ( sh ) ;
 1542 
    UNUSED(sh);
1642 
    UNUSED ( new_type ) ;
 1543 
    UNUSED(new_type);
1643 
    UNUSED ( elaboration ) ;
 1544 
    UNUSED(elaboration);
1644 
    return ( f_dummy_dg_type ) ;
 1545 
    return(f_dummy_dg_type);
1645 
}
 1546 
}
1646 
 
 1547 
 
1647 
dg_type f_dg_unknown_type
 1548 
dg_type f_dg_unknown_type
1648 
    PROTO_N ( ( sh ) )
 - 
 
1649 
    PROTO_T ( shape sh )
 1549 
(shape sh)
1650 
{
 1550 
{
1651 
    UNUSED ( sh ) ;
 1551 
    UNUSED(sh);
1652 
    return ( f_dummy_dg_type ) ;
 1552 
    return(f_dummy_dg_type);
1653 
}
 1553 
}
1654 
 
 1554 
 
1655 
dg_type f_dg_void_type ;
 1555 
dg_type f_dg_void_type;
1656 
 
 1556 
 
1657 
dg_type f_dummy_dg_type ;
 1557 
dg_type f_dummy_dg_type;
1658 
 
 1558 
 
1659 
void init_dg_type
 1559 
void init_dg_type
1660 
    PROTO_Z ()
 1560 
(void)
1661 
{
 1561 
{
1662 
    return ;
 1562 
    return;
1663 
}
 1563 
}
1664 
 
 1564 
 
1665 
dg_type_list new_dg_type_list
 1565 
dg_type_list new_dg_type_list
1666 
    PROTO_N ( ( n ) )
 - 
 
1667 
    PROTO_T ( int n )
 1566 
(int n)
1668 
{
 1567 
{
1669 
    UNUSED ( n ) ;
 1568 
    UNUSED(n);
1670 
    return ( f_dummy_dg_type_list ) ;
 1569 
    return(f_dummy_dg_type_list);
1671 
}
 1570 
}
1672 
 
 1571 
 
1673 
dg_type_list add_dg_type_list
 1572 
dg_type_list add_dg_type_list
1674 
   PROTO_N ( ( list, elem, index ) )
 - 
 
1675 
   PROTO_T ( dg_type_list list X dg_type elem X int index )
 1573 
(dg_type_list list, dg_type elem, int index)
1676 
{
 1574 
{
1677 
    UNUSED ( list ) ;
 1575 
    UNUSED(list);
1678 
    UNUSED ( elem ) ;
 1576 
    UNUSED(elem);
1679 
    UNUSED ( index ) ;
 1577 
    UNUSED(index);
1680 
    return ( f_dummy_dg_type_list ) ;
 1578 
    return(f_dummy_dg_type_list);
1681 
}
 1579 
}
1682 
 
 1580 
 
1683 
void init_dg_type_list
 1581 
void init_dg_type_list
1684 
    PROTO_Z ()
 1582 
(void)
1685 
{
 1583 
{
1686 
    return ;
 1584 
    return;
1687 
}
 1585 
}
1688 
 
 1586 
 
1689 
dg_type_list_option no_dg_type_list_option ;
 1587 
dg_type_list_option no_dg_type_list_option;
1690 
 
 1588 
 
1691 
dg_type_list_option yes_dg_type_list_option
 1589 
dg_type_list_option yes_dg_type_list_option
1692 
    PROTO_N ( ( elem ) )
 - 
 
1693 
    PROTO_T ( dg_type_list elem )
 1590 
(dg_type_list elem)
1694 
{
 1591 
{
1695 
    UNUSED ( elem ) ;
 1592 
    UNUSED(elem);
1696 
    return ( f_dummy_dg_type_list_option ) ;
 1593 
    return(f_dummy_dg_type_list_option);
1697 
}
 1594 
}
1698 
 
 1595 
 
1699 
void init_dg_type_list_option
 1596 
void init_dg_type_list_option
1700 
    PROTO_Z ()
 1597 
(void)
1701 
{
 1598 
{
1702 
    return ;
 1599 
    return;
1703 
}
 1600 
}
1704 
 
 1601 
 
1705 
dg_type_option no_dg_type_option ;
 1602 
dg_type_option no_dg_type_option;
1706 
 
 1603 
 
1707 
dg_type_option yes_dg_type_option
 1604 
dg_type_option yes_dg_type_option
1708 
    PROTO_N ( ( elem ) )
 - 
 
1709 
    PROTO_T ( dg_type elem )
 1605 
(dg_type elem)
1710 
{
 1606 
{
1711 
    UNUSED ( elem ) ;
 1607 
    UNUSED(elem);
1712 
    return ( f_dummy_dg_type_option ) ;
 1608 
    return(f_dummy_dg_type_option);
1713 
}
 1609 
}
1714 
 
 1610 
 
1715 
void init_dg_type_option
 1611 
void init_dg_type_option
1716 
    PROTO_Z ()
 1612 
(void)
1717 
{
 1613 
{
1718 
    return ;
 1614 
    return;
1719 
}
 1615 
}
1720 
 
 1616 
 
1721 
dg_variant f_make_dg_variant
 1617 
dg_variant f_make_dg_variant
1722 
    PROTO_N ( ( discr, fields ) )
 - 
 
1723 
    PROTO_T ( dg_discrim_list discr X dg_classmem_list fields )
 1618 
(dg_discrim_list discr, dg_classmem_list fields)
1724 
{
 1619 
{
1725 
    UNUSED ( discr ) ;
 1620 
    UNUSED(discr);
1726 
    UNUSED ( fields ) ;
 1621 
    UNUSED(fields);
1727 
    return ( f_dummy_dg_variant ) ;
 1622 
    return(f_dummy_dg_variant);
1728 
}
 1623 
}
1729 
 
 1624 
 
1730 
dg_variant f_dummy_dg_variant ;
 1625 
dg_variant f_dummy_dg_variant;
1731 
 
 1626 
 
1732 
void init_dg_variant
 1627 
void init_dg_variant
1733 
    PROTO_Z ()
 1628 
(void)
1734 
{
 1629 
{
1735 
    return ;
 1630 
    return;
1736 
}
 1631 
}
1737 
 
 1632 
 
1738 
dg_variant_list new_dg_variant_list
 1633 
dg_variant_list new_dg_variant_list
1739 
    PROTO_N ( ( n ) )
 - 
 
1740 
    PROTO_T ( int n )
 1634 
(int n)
1741 
{
 1635 
{
1742 
    UNUSED ( n ) ;
 1636 
    UNUSED(n);
1743 
    return ( f_dummy_dg_variant_list ) ;
 1637 
    return(f_dummy_dg_variant_list);
1744 
}
 1638 
}
1745 
 
 1639 
 
1746 
dg_variant_list add_dg_variant_list
 1640 
dg_variant_list add_dg_variant_list
1747 
   PROTO_N ( ( list, elem, index ) )
 - 
 
1748 
   PROTO_T ( dg_variant_list list X dg_variant elem X int index )
 1641 
(dg_variant_list list, dg_variant elem, int index)
1749 
{
 1642 
{
1750 
    UNUSED ( list ) ;
 1643 
    UNUSED(list);
1751 
    UNUSED ( elem ) ;
 1644 
    UNUSED(elem);
1752 
    UNUSED ( index ) ;
 1645 
    UNUSED(index);
1753 
    return ( f_dummy_dg_variant_list ) ;
 1646 
    return(f_dummy_dg_variant_list);
1754 
}
 1647 
}
1755 
 
 1648 
 
1756 
void init_dg_variant_list
 1649 
void init_dg_variant_list
1757 
    PROTO_Z ()
 1650 
(void)
1758 
{
 1651 
{
1759 
    return ;
 1652 
    return;
1760 
}
 1653 
}
1761 
 
 1654 
 
1762 
dg_varpart f_dg_discrim_varpart
 1655 
dg_varpart f_dg_discrim_varpart
1763 
    PROTO_N ( ( discrim, variants ) )
 - 
 
1764 
    PROTO_T ( dg_classmem discrim X dg_variant_list variants )
 1656 
(dg_classmem discrim, dg_variant_list variants)
1765 
{
 1657 
{
1766 
    UNUSED ( discrim ) ;
 1658 
    UNUSED(discrim);
1767 
    UNUSED ( variants ) ;
 1659 
    UNUSED(variants);
1768 
    return ( f_dummy_dg_varpart ) ;
 1660 
    return(f_dummy_dg_varpart);
1769 
}
 1661 
}
1770 
 
 1662 
 
1771 
dg_varpart f_dg_sibl_discrim_varpart
 1663 
dg_varpart f_dg_sibl_discrim_varpart
1772 
    PROTO_N ( ( discrim, variants ) )
 - 
 
1773 
    PROTO_T ( dg_tag discrim X dg_variant_list variants )
 1664 
(dg_tag discrim, dg_variant_list variants)
1774 
{
 1665 
{
1775 
    UNUSED ( discrim ) ;
 1666 
    UNUSED(discrim);
1776 
    UNUSED ( variants ) ;
 1667 
    UNUSED(variants);
1777 
    return ( f_dummy_dg_varpart ) ;
 1668 
    return(f_dummy_dg_varpart);
1778 
}
 1669 
}
1779 
 
 1670 
 
1780 
dg_varpart f_dg_undiscrim_varpart
 1671 
dg_varpart f_dg_undiscrim_varpart
1781 
    PROTO_N ( ( tag_type, variants ) )
 - 
 
1782 
    PROTO_T ( dg_type tag_type X dg_variant_list variants )
 1672 
(dg_type tag_type, dg_variant_list variants)
1783 
{
 1673 
{
1784 
    UNUSED ( tag_type ) ;
 1674 
    UNUSED(tag_type);
1785 
    UNUSED ( variants ) ;
 1675 
    UNUSED(variants);
1786 
    return ( f_dummy_dg_varpart ) ;
 1676 
    return(f_dummy_dg_varpart);
1787 
}
 1677 
}
1788 
 
 1678 
 
1789 
dg_varpart f_dummy_dg_varpart ;
 1679 
dg_varpart f_dummy_dg_varpart;
1790 
 
 1680 
 
1791 
void init_dg_varpart
 1681 
void init_dg_varpart
1792 
    PROTO_Z ()
 1682 
(void)
1793 
{
 1683 
{
1794 
    return ;
 1684 
    return;
1795 
}
 1685 
}
1796 
 
 1686 
 
1797 
dg_varpart_option no_dg_varpart_option ;
 1687 
dg_varpart_option no_dg_varpart_option;
1798 
 
 1688 
 
1799 
dg_varpart_option yes_dg_varpart_option
 1689 
dg_varpart_option yes_dg_varpart_option
1800 
    PROTO_N ( ( elem ) )
 - 
 
1801 
    PROTO_T ( dg_varpart elem )
 1690 
(dg_varpart elem)
1802 
{
 1691 
{
1803 
    UNUSED ( elem ) ;
 1692 
    UNUSED(elem);
1804 
    return ( f_dummy_dg_varpart_option ) ;
 1693 
    return(f_dummy_dg_varpart_option);
1805 
}
 1694 
}
1806 
 
 1695 
 
1807 
void init_dg_varpart_option
 1696 
void init_dg_varpart_option
1808 
    PROTO_Z ()
 1697 
(void)
1809 
{
 1698 
{
1810 
    return ;
 1699 
    return;
1811 
}
 1700 
}
1812 
 
 1701 
 
1813 
dg_virtuality f_dg_abstract_virtuality ;
 1702 
dg_virtuality f_dg_abstract_virtuality;
1814 
 
 1703 
 
1815 
dg_virtuality f_dg_virtual_virtuality ;
 1704 
dg_virtuality f_dg_virtual_virtuality;
1816 
 
 1705 
 
1817 
dg_virtuality f_dummy_dg_virtuality ;
 1706 
dg_virtuality f_dummy_dg_virtuality;
1818 
 
 1707 
 
1819 
void init_dg_virtuality
 1708 
void init_dg_virtuality
1820 
    PROTO_Z ()
 1709 
(void)
1821 
{
 1710 
{
1822 
    return ;
 1711 
    return;
1823 
}
 1712 
}
1824 
 
 1713 
 
1825 
dg_virtuality_option no_dg_virtuality_option ;
 1714 
dg_virtuality_option no_dg_virtuality_option;
1826 
 
 1715 
 
1827 
dg_virtuality_option yes_dg_virtuality_option
 1716 
dg_virtuality_option yes_dg_virtuality_option
1828 
    PROTO_N ( ( elem ) )
 - 
 
1829 
    PROTO_T ( dg_virtuality elem )
 1717 
(dg_virtuality elem)
1830 
{
 1718 
{
1831 
    UNUSED ( elem ) ;
 1719 
    UNUSED(elem);
1832 
    return ( f_dummy_dg_virtuality_option ) ;
 1720 
    return(f_dummy_dg_virtuality_option);
1833 
}
 1721 
}
1834 
 
 1722 
 
1835 
void init_dg_virtuality_option
 1723 
void init_dg_virtuality_option
1836 
    PROTO_Z ()
 1724 
(void)
1837 
{
 1725 
{
1838 
    return ;
 1726 
    return;
1839 
}
 1727 
}
1840 
 
 1728 
 
1841 
shape_option no_shape_option ;
 1729 
shape_option no_shape_option;
1842 
 
 1730 
 
1843 
shape_option yes_shape_option
 1731 
shape_option yes_shape_option
1844 
    PROTO_N ( ( elem ) )
 - 
 
1845 
    PROTO_T ( shape elem )
 1732 
(shape elem)
1846 
{
 1733 
{
1847 
    UNUSED ( elem ) ;
 1734 
    UNUSED(elem);
1848 
    return ( f_dummy_shape_option ) ;
 1735 
    return(f_dummy_shape_option);
1849 
}
 1736 
}
1850 
 
 1737 
 
1851 
void init_shape_option
 1738 
void init_shape_option
1852 
    PROTO_Z ()
 1739 
(void)
1853 
{
 1740 
{
1854 
    return ;
 1741 
    return;
1855 
}
 1742 
}
1856 
 
 1743 
 
1857 
string_list new_string_list
 1744 
string_list new_string_list
1858 
    PROTO_N ( ( n ) )
 - 
 
1859 
    PROTO_T ( int n )
 1745 
(int n)
1860 
{
 1746 
{
1861 
    UNUSED ( n ) ;
 1747 
    UNUSED(n);
1862 
    return ( f_dummy_string_list ) ;
 1748 
    return(f_dummy_string_list);
1863 
}
 1749 
}
1864 
 
 1750 
 
1865 
string_list add_string_list
 1751 
string_list add_string_list
1866 
   PROTO_N ( ( list, elem, index ) )
 - 
 
1867 
   PROTO_T ( string_list list X string elem X int index )
 1752 
(string_list list, string elem, int index)
1868 
{
 1753 
{
1869 
    UNUSED ( list ) ;
 1754 
    UNUSED(list);
1870 
    UNUSED ( elem ) ;
 1755 
    UNUSED(elem);
1871 
    UNUSED ( index ) ;
 1756 
    UNUSED(index);
1872 
    return ( f_dummy_string_list ) ;
 1757 
    return(f_dummy_string_list);
1873 
}
 1758 
}
1874 
 
 1759 
 
1875 
void init_string_list
 1760 
void init_string_list
1876 
    PROTO_Z ()
 1761 
(void)
1877 
{
 1762 
{
1878 
    return ;
 1763 
    return;
1879 
}
 1764 
}
1880 
 
 1765 
 
1881 
string_option no_string_option ;
 1766 
string_option no_string_option;
1882 
 
 1767 
 
1883 
string_option yes_string_option
 1768 
string_option yes_string_option
1884 
    PROTO_N ( ( elem ) )
 - 
 
1885 
    PROTO_T ( string elem )
 1769 
(string elem)
1886 
{
 1770 
{
1887 
    UNUSED ( elem ) ;
 1771 
    UNUSED(elem);
1888 
    return ( f_dummy_string_option ) ;
 1772 
    return(f_dummy_string_option);
1889 
}
 1773 
}
1890 
 
 1774 
 
1891 
void init_string_option
 1775 
void init_string_option
1892 
    PROTO_Z ()
 1776 
(void)
1893 
{
 1777 
{
1894 
    return ;
 1778 
    return;
1895 
}
 1779 
}
1896 
 
 1780 
 
1897 
token_option no_token_option ;
 1781 
token_option no_token_option;
1898 
 
 1782 
 
1899 
token_option yes_token_option
 1783 
token_option yes_token_option
1900 
    PROTO_N ( ( elem ) )
 - 
 
1901 
    PROTO_T ( token elem )
 1784 
(token elem)
1902 
{
 1785 
{
1903 
    UNUSED ( elem ) ;
 1786 
    UNUSED(elem);
1904 
    return ( f_dummy_token_option ) ;
 1787 
    return(f_dummy_token_option);
1905 
}
 1788 
}
1906 
 
 1789 
 
1907 
void init_token_option
 1790 
void init_token_option
1908 
    PROTO_Z ()
 1791 
(void)
1909 
{
 1792 
{
1910 
    return ;
 1793 
    return;
1911 
}
 1794 
}