← Back to branch summary

~ubuntu-branches/ubuntu/feisty/cproto/feisty

« back to all changes in this revision

Viewing changes to testing/case15.ref

  • Committer: Bazaar Package Importer
  • Author(s): Carsten Leonhardt
  • Date: 2000-09-02 21:14:55 UTC
  • Revision ID: james.westby@ubuntu.com-20000902211455-ixe8p17zhnuk6jft
Tags: upstream-4.6d
Import upstream version 4.6d

Show diffs side-by-side

added added

removed removed

Lines of Context:
testing/case15.ref
 
1
/* LINTLIBRARY */
 
2
 
 
3
/* apollo.c */
 
4
#undef  COMPLETE_SR10_2
 
5
#ifdef  __STDC__
 
6
#ident  Standard LLIB
 
7
#else
 
8
#ident  Traditional LLIB
 
9
 
 
10
#include <apollo/base.h>
 
11
 
 
12
short   pm_$errout;
 
13
uid_$t  uid_$nil;
 
14
 
 
15
void    lib_$init_set(set, size)
 
16
                void    *set;
 
17
                short   size;
 
18
                { /* void */ }
 
19
 
 
20
void    lib_$add_to_set(set, size, element)
 
21
                void    *set;
 
22
                short   size;
 
23
                short   element;
 
24
                { /* void */ }
 
25
 
 
26
void    lib_$clr_from_set(set, size, element)
 
27
                void    *set;
 
28
                short   size;
 
29
                short   element;
 
30
                { /* void */ }
 
31
 
 
32
boolean lib_$member_of_set(set, size, element)
 
33
                void    *set;
 
34
                short   size;
 
35
                short   element;
 
36
                { return(*(boolean *)0); }
 
37
 
 
38
#include <apollo/aclm.h>
 
39
 
 
40
void    aclm_$up()
 
41
                { /* void */ }
 
42
 
 
43
void    aclm_$down()
 
44
                { /* void */ }
 
45
 
 
46
#include <apollo/cal.h>
 
47
 
 
48
void    cal_$decode_ascii_time(string, string_length, hour, minute, second, status)
 
49
                char    *string;
 
50
                short   string_length;
 
51
                short   *hour;
 
52
                short   *minute;
 
53
                short   *second;
 
54
                status_$t *status;
 
55
                { /* void */ }
 
56
 
 
57
void    cal_$decode_ascii_date(string, string_length, year, month, day, status)
 
58
                char    *string;
 
59
                short   string_length;
 
60
                short   *year;
 
61
                short   *month;
 
62
                short   *day;
 
63
                status_$t *status;
 
64
                { /* void */ }
 
65
 
 
66
void    cal_$decode_ascii_tzdif(string, string_length, tz_dif, tz_name, status)
 
67
                char    *string;
 
68
                short   string_length;
 
69
                short   *tz_dif;
 
70
                cal_$tz_name_t tz_name;
 
71
                status_$t *status;
 
72
                { /* void */ }
 
73
 
 
74
void    cal_$decode_time(clock, decoded_clock)
 
75
                time_$clock_t clock;
 
76
                cal_$timedate_rec_t *decoded_clock;
 
77
                { /* void */ }
 
78
 
 
79
void    cal_$encode_time(decoded_clock, clock)
 
80
                cal_$timedate_rec_t decoded_clock;
 
81
                time_$clock_t *clock;
 
82
                { /* void */ }
 
83
 
 
84
void    cal_$decode_local_time(decoded_clock)
 
85
                cal_$timedate_rec_t *decoded_clock;
 
86
                { /* void */ }
 
87
 
 
88
cal_$weekday_t cal_$weekday(year, month, day)
 
89
                short   year;
 
90
                short   month;
 
91
                short   day;
 
92
                { return(*(cal_$weekday_t *)0); }
 
93
 
 
94
void    cal_$apply_local_offset(clock)
 
95
                time_$clock_t *clock;
 
96
                { /* void */ }
 
97
 
 
98
void    cal_$remove_local_offset(clock)
 
99
                time_$clock_t *clock;
 
100
                { /* void */ }
 
101
 
 
102
void    cal_$get_local_time(clock)
 
103
                time_$clock_t *clock;
 
104
                { /* void */ }
 
105
 
 
106
void    cal_$write_timezone(timezone_info, status)
 
107
                cal_$timezone_rec_t timezone_info;
 
108
                status_$t *status;
 
109
                { /* void */ }
 
110
 
 
111
void    cal_$sec_to_clock(seconds, clock)
 
112
                unsigned long seconds;
 
113
                time_$clock_t *clock;
 
114
                { /* void */ }
 
115
 
 
116
unsigned long cal_$clock_to_sec(clock)
 
117
                time_$clock_t clock;
 
118
                { return(*(unsigned long *)0); }
 
119
 
 
120
void    cal_$get_info(timezone_info)
 
121
                cal_$timezone_rec_t *timezone_info;
 
122
                { /* void */ }
 
123
 
 
124
void    cal_$float_clock(clock, float_seconds)
 
125
                time_$clock_t clock;
 
126
                double  *float_seconds;
 
127
                { /* void */ }
 
128
 
 
129
void    cal_$add_clock(clock1, clock2)
 
130
                time_$clock_t *clock1;
 
131
                time_$clock_t clock2;
 
132
                { /* void */ }
 
133
 
 
134
boolean cal_$sub_clock(clock1, clock2)
 
135
                time_$clock_t *clock1;
 
136
                time_$clock_t clock2;
 
137
                { return(*(boolean *)0); }
 
138
 
 
139
short   cal_$cmp_clock(clock1, clock2)
 
140
                time_$clock_t clock1;
 
141
                time_$clock_t clock2;
 
142
                { return(*(short *)0); }
 
143
 
 
144
#include <apollo/error.h>
 
145
 
 
146
void    error_$find_text(status, sub_np, sub_nl, mod_np, mod_nl, err_p, err_l)
 
147
                status_$t status;
 
148
                char    **sub_np;
 
149
                short   *sub_nl;
 
150
                char    **mod_np;
 
151
                short   *mod_nl;
 
152
                char    **err_p;
 
153
                short   *err_l;
 
154
                { /* void */ }
 
155
 
 
156
void    error_$get_text(status, sub_n, sub_nl, mod_n, mod_nl, err_t, err_l)
 
157
                status_$t status;
 
158
                error_$string_t sub_n;
 
159
                short   *sub_nl;
 
160
                error_$string_t mod_n;
 
161
                short   *mod_nl;
 
162
                error_$string_t err_t;
 
163
                short   *err_l;
 
164
                { /* void */ }
 
165
 
 
166
void    error_$print(status)
 
167
                status_$t status;
 
168
                { /* void */ }
 
169
 
 
170
void    error_$print_name(status, name, namelen)
 
171
                status_$t status;
 
172
                char    *name;
 
173
                pinteger namelen;
 
174
                { /* void */ }
 
175
 
 
176
        /* VARARGS6 */
 
177
void    error_$print_format(status, strm, prechr, command, commlen, str)
 
178
                status_$t status;
 
179
                stream_$id_t strm;
 
180
                char    prechr;
 
181
                error_$string_t command;
 
182
                short   commlen;
 
183
                char    *str;
 
184
                { /* void */ }
 
185
 
 
186
void    error_$init_std_format(strm, prechr, command, commlen)
 
187
                stream_$id_t strm;
 
188
                char    prechr;
 
189
                char    *command;
 
190
                short   commlen;
 
191
                { /* void */ }
 
192
 
 
193
        /* VARARGS2 */
 
194
void    error_$std_format(status, str)
 
195
                status_$t status;
 
196
                char    *str;
 
197
                { /* void */ }
 
198
 
 
199
boolean error_$fail(status)
 
200
                status_$t status;
 
201
                { return(*(boolean *)0); }
 
202
 
 
203
short   error_$subsys(status)
 
204
                status_$t status;
 
205
                { return(*(short *)0); }
 
206
 
 
207
short   error_$module(status)
 
208
                status_$t status;
 
209
                { return(*(short *)0); }
 
210
 
 
211
short   error_$code(status)
 
212
                status_$t status;
 
213
                { return(*(short *)0); }
 
214
 
 
215
#include <apollo/ev.h>
 
216
 
 
217
boolean ev_$set_var(name, namelen, value, valuelen)
 
218
                char    *name;
 
219
                short   namelen;
 
220
                char    *value;
 
221
                short   valuelen;
 
222
                { return(*(boolean *)0); }
 
223
 
 
224
boolean ev_$get_var(name, namelen, value_ptr, valuelen)
 
225
                char    *name;
 
226
                short   namelen;
 
227
                char    **value_ptr;
 
228
                short   *valuelen;
 
229
                { return(*(boolean *)0); }
 
230
 
 
231
boolean ev_$exist_var(name, namelen)
 
232
                char    *name;
 
233
                short   namelen;
 
234
                { return(*(boolean *)0); }
 
235
 
 
236
boolean ev_$delete_var(name, namelen)
 
237
                char    *name;
 
238
                short   namelen;
 
239
                { return(*(boolean *)0); }
 
240
 
 
241
boolean ev_$read_var_entry(ix, name_ptr, namelen, value_ptr, valuelen)
 
242
                short   *ix;
 
243
                char    **name_ptr;
 
244
                short   *namelen;
 
245
                char    **value_ptr;
 
246
                short   *valuelen;
 
247
                { return(*(boolean *)0); }
 
248
 
 
249
#include <apollo/ios.h>
 
250
 
 
251
xoid_$t xoid_$nil;
 
252
 
 
253
ios_$id_t ios_$open(n, l, opts, st)
 
254
                char    *n;
 
255
                short   l;
 
256
                ios_$open_options_t opts;
 
257
                status_$t *st;
 
258
                { return(*(ios_$id_t *)0); }
 
259
 
 
260
void    ios_$create(name, name_len, type_uid, cmode, oopts, id, status)
 
261
                char    *name;
 
262
                short   name_len;
 
263
                uid_$t  type_uid;
 
264
                ios_$create_mode_t cmode;
 
265
                ios_$open_options_t oopts;
 
266
                ios_$id_t *id;
 
267
                status_$t *status;
 
268
                { /* void */ }
 
269
 
 
270
void    ios_$close(id, st)
 
271
                ios_$id_t id;
 
272
                status_$t *st;
 
273
                { /* void */ }
 
274
 
 
275
void    ios_$get_ec(id, key, ecp, st)
 
276
                ios_$id_t id;
 
277
                ios_$ec_key_t key;
 
278
                ec2_$ptr_t *ecp;
 
279
                status_$t *st;
 
280
                { /* void */ }
 
281
 
 
282
void    ios_$delete(id, st)
 
283
                ios_$id_t id;
 
284
                status_$t *st;
 
285
                { /* void */ }
 
286
 
 
287
void    ios_$truncate(id, st)
 
288
                ios_$id_t id;
 
289
                status_$t *st;
 
290
                { /* void */ }
 
291
 
 
292
long    ios_$get(id, opt, b, l, st)
 
293
                ios_$id_t id;
 
294
                ios_$put_get_opts_t opt;
 
295
                char    *b;
 
296
                long    l;
 
297
                status_$t *st;
 
298
                { return(*(long *)0); }
 
299
 
 
300
long    ios_$locate(id, opt, b, l, st)
 
301
                ios_$id_t id;
 
302
                ios_$put_get_opts_t opt;
 
303
                char    **b;
 
304
                long    l;
 
305
                status_$t *st;
 
306
                { return(*(long *)0); }
 
307
 
 
308
void    ios_$put(id, opt, b, l, st)
 
309
                ios_$id_t id;
 
310
                ios_$put_get_opts_t opt;
 
311
                char    *b;
 
312
                long    l;
 
313
                status_$t *st;
 
314
                { /* void */ }
 
315
 
 
316
long    ios_$putp(id, opt, b, l, st)
 
317
                ios_$id_t id;
 
318
                ios_$put_get_opts_t opt;
 
319
                char    *b;
 
320
                long    l;
 
321
                status_$t *st;
 
322
                { return(*(long *)0); }
 
323
 
 
324
long    ios_$inq_rec_remainder(id, st)
 
325
                ios_$id_t id;
 
326
                status_$t *st;
 
327
                { return(*(long *)0); }
 
328
 
 
329
ios_$mgr_flag_set ios_$inq_mgr_flags(id, st)
 
330
                ios_$id_t id;
 
331
                status_$t *st;
 
332
                { return(*(ios_$mgr_flag_set *)0); }
 
333
 
 
334
ios_$obj_flag_set ios_$inq_obj_flags(id, st)
 
335
                ios_$id_t id;
 
336
                status_$t *st;
 
337
                { return(*(ios_$obj_flag_set *)0); }
 
338
 
 
339
void    ios_$set_obj_flag(id, f, on_off, st)
 
340
                ios_$id_t id;
 
341
                ios_$obj_flag_t f;
 
342
                boolean on_off;
 
343
                status_$t *st;
 
344
                { /* void */ }
 
345
 
 
346
ios_$conn_flag_set ios_$inq_conn_flags(id, st)
 
347
                ios_$id_t id;
 
348
                status_$t *st;
 
349
                { return(*(ios_$conn_flag_set *)0); }
 
350
 
 
351
void    ios_$set_conn_flag(id, f, on_off, st)
 
352
                ios_$id_t id;
 
353
                ios_$conn_flag_t f;
 
354
                boolean on_off;
 
355
                status_$t *st;
 
356
                { /* void */ }
 
357
 
 
358
void    ios_$seek(id, abs_rel, seek_type, key, st)
 
359
                ios_$id_t id;
 
360
                ios_$abs_rel_t abs_rel;
 
361
                ios_$seek_type_t seek_type;
 
362
                long    key;
 
363
                status_$t *st;
 
364
                { /* void */ }
 
365
 
 
366
void    ios_$seek_full_key(id, key, status)
 
367
                ios_$id_t id;
 
368
                ios_$seek_key_t key;
 
369
                status_$t *status;
 
370
                { /* void */ }
 
371
 
 
372
void    ios_$seek_short_key(id, key, status)
 
373
                ios_$id_t id;
 
374
                long    key;
 
375
                status_$t *status;
 
376
                { /* void */ }
 
377
 
 
378
void    ios_$seek_to_bof(id, status)
 
379
                ios_$id_t id;
 
380
                status_$t *status;
 
381
                { /* void */ }
 
382
 
 
383
void    ios_$seek_to_eof(id, status)
 
384
                ios_$id_t id;
 
385
                status_$t *status;
 
386
                { /* void */ }
 
387
 
 
388
long    ios_$inq_short_key(id, pos_opt, status)
 
389
                ios_$id_t id;
 
390
                ios_$pos_opt_t pos_opt;
 
391
                status_$t *status;
 
392
                { return(*(long *)0); }
 
393
 
 
394
void    ios_$inq_full_key(id, pos_opt, key, status)
 
395
                ios_$id_t id;
 
396
                ios_$pos_opt_t pos_opt;
 
397
                ios_$seek_key_t *key;
 
398
                status_$t *status;
 
399
                { /* void */ }
 
400
 
 
401
long    ios_$inq_rec_pos(id, pos_opt, st)
 
402
                ios_$id_t id;
 
403
                ios_$pos_opt_t pos_opt;
 
404
                status_$t *st;
 
405
                { return(*(long *)0); }
 
406
 
 
407
long    ios_$inq_byte_pos(id, pos_opt, status)
 
408
                ios_$id_t id;
 
409
                ios_$pos_opt_t pos_opt;
 
410
                status_$t *status;
 
411
                { return(*(long *)0); }
 
412
 
 
413
long    ios_$inq_cur_rec_len(id, status)
 
414
                ios_$id_t id;
 
415
                status_$t *status;
 
416
                { return(*(long *)0); }
 
417
 
 
418
ios_$rtype_t ios_$inq_rec_type(id, status)
 
419
                ios_$id_t id;
 
420
                status_$t *status;
 
421
                { return(*(ios_$rtype_t *)0); }
 
422
 
 
423
void    ios_$set_rec_type(id, rec_type, rec_len, status)
 
424
                ios_$id_t id;
 
425
                ios_$rtype_t rec_type;
 
426
                long    rec_len;
 
427
                status_$t *status;
 
428
                { /* void */ }
 
429
 
 
430
void    ios_$force_write_file(id, status)
 
431
                ios_$id_t id;
 
432
                status_$t *status;
 
433
                { /* void */ }
 
434
 
 
435
void    ios_$inq_file_attr(id, dtc, dtm, dtu, blks, status)
 
436
                ios_$id_t id;
 
437
                time_$clockh_t *dtc;
 
438
                time_$clockh_t *dtm;
 
439
                time_$clockh_t *dtu;
 
440
                long    *blks;
 
441
                status_$t *status;
 
442
                { /* void */ }
 
443
 
 
444
void    ios_$inq_path_name_lc(strid, ntype, max_nl, name, nl, status)
 
445
                ios_$id_t strid;
 
446
                ios_$name_type_t ntype;
 
447
                short   max_nl;
 
448
                char    *name;
 
449
                short   *nl;
 
450
                status_$t *status;
 
451
                { /* void */ }
 
452
 
 
453
void    ios_$change_path_name(strid, new_name, new_nl, status)
 
454
                ios_$id_t strid;
 
455
                char    *new_name;
 
456
                short   new_nl;
 
457
                status_$t *status;
 
458
                { /* void */ }
 
459
 
 
460
void    ios_$inq_type_uid(strid, type_uid, status)
 
461
                ios_$id_t strid;
 
462
                uid_$t  *type_uid;
 
463
                status_$t *status;
 
464
                { /* void */ }
 
465
 
 
466
void    *ios_$get_handle(strid, type_uid, status)
 
467
                ios_$id_t strid;
 
468
                uid_$t  type_uid;
 
469
                status_$t *status;
 
470
                { /* void */ }
 
471
 
 
472
void    ios_$set_locate_buffer_size(id, size, status)
 
473
                ios_$id_t id;
 
474
                short   size;
 
475
                status_$t *status;
 
476
                { /* void */ }
 
477
 
 
478
ios_$id_t ios_$switch(strid1, strid2, status)
 
479
                ios_$id_t strid1;
 
480
                ios_$id_t strid2;
 
481
                status_$t *status;
 
482
                { return(*(ios_$id_t *)0); }
 
483
 
 
484
ios_$id_t ios_$replicate(strid1, strid2, status)
 
485
                ios_$id_t strid1;
 
486
                ios_$id_t strid2;
 
487
                status_$t *status;
 
488
                { return(*(ios_$id_t *)0); }
 
489
 
 
490
ios_$id_t ios_$dup(strid1, strid2, status)
 
491
                ios_$id_t strid1;
 
492
                ios_$id_t strid2;
 
493
                status_$t *status;
 
494
                { return(*(ios_$id_t *)0); }
 
495
 
 
496
boolean ios_$equal(strid1, strid2, status)
 
497
                ios_$id_t strid1;
 
498
                ios_$id_t strid2;
 
499
                status_$t *status;
 
500
                { return(*(boolean *)0); }
 
501
 
 
502
void    ios_$set_dir(pname, plen, dir, status)
 
503
                char    *pname;
 
504
                pinteger plen;
 
505
                ios_$dir_type_t dir;
 
506
                status_$t *status;
 
507
                { /* void */ }
 
508
 
 
509
void    ios_$get_dir_lc(dir, max_plen, pname, plen, status)
 
510
                ios_$dir_type_t dir;
 
511
                short   max_plen;
 
512
                char    *pname;
 
513
                short   *plen;
 
514
                status_$t *status;
 
515
                { /* void */ }
 
516
 
 
517
void    ios_$inq_path_name(strid, ntype, name, nl, status)
 
518
                ios_$id_t strid;
 
519
                ios_$name_type_t ntype;
 
520
                char    *name;
 
521
                short   *nl;
 
522
                status_$t *status;
 
523
                { /* void */ }
 
524
 
 
525
void    ios_$get_dir(dir, pname, plen, status)
 
526
                ios_$dir_type_t dir;
 
527
                char    *pname;
 
528
                short   *plen;
 
529
                status_$t *status;
 
530
                { /* void */ }
 
531
 
 
532
#include <apollo/name.h>
 
533
 
 
534
void    name_$get_wdir_lc(maxpathlen, pathname, name_length, status)
 
535
                unsigned short maxpathlen;
 
536
                char    *pathname;
 
537
                unsigned short *name_length;
 
538
                status_$t *status;
 
539
                { /* void */ }
 
540
 
 
541
void    name_$get_ndir_lc(maxpathlen, pathname, name_length, status)
 
542
                unsigned short maxpathlen;
 
543
                char    *pathname;
 
544
                unsigned short *name_length;
 
545
                status_$t *status;
 
546
                { /* void */ }
 
547
 
 
548
void    name_$create_file(filename, name_length, status)
 
549
                char    *filename;
 
550
                unsigned short name_length;
 
551
                status_$t *status;
 
552
                { /* void */ }
 
553
 
 
554
void    name_$delete_file(filename, name_length, status)
 
555
                char    *filename;
 
556
                unsigned short name_length;
 
557
                status_$t *status;
 
558
                { /* void */ }
 
559
 
 
560
void    name_$create_directory(directory_name, name_length, status)
 
561
                char    *directory_name;
 
562
                unsigned short name_length;
 
563
                status_$t *status;
 
564
                { /* void */ }
 
565
 
 
566
void    name_$delete_directory(directory_name, name_length, status)
 
567
                char    *directory_name;
 
568
                unsigned short name_length;
 
569
                status_$t *status;
 
570
                { /* void */ }
 
571
 
 
572
void    name_$read_dir_lc(dir_name, name_length, seek_to_bof, cursor, max_count, dirlistsize, dirlist, read_count, status)
 
573
                char    *dir_name;
 
574
                unsigned short name_length;
 
575
                boolean *seek_to_bof;
 
576
                name_$cursor_t *cursor;
 
577
                unsigned short max_count;
 
578
                unsigned long dirlistsize;
 
579
                char    *dirlist;
 
580
                unsigned short *read_count;
 
581
                status_$t *status;
 
582
                { /* void */ }
 
583
 
 
584
void    name_$add_link(linkname, name_length, link_text, text_length, status)
 
585
                char    *linkname;
 
586
                unsigned short name_length;
 
587
                char    *link_text;
 
588
                unsigned short text_length;
 
589
                status_$t *status;
 
590
                { /* void */ }
 
591
 
 
592
void    name_$read_link_lc(linkname, name_length, maxlinklen, link_text, text_length, status)
 
593
                char    *linkname;
 
594
                unsigned short name_length;
 
595
                unsigned short maxlinklen;
 
596
                char    *link_text;
 
597
                unsigned short *text_length;
 
598
                status_$t *status;
 
599
                { /* void */ }
 
600
 
 
601
void    name_$drop_link(linkname, name_length, status)
 
602
                char    *linkname;
 
603
                unsigned short name_length;
 
604
                status_$t *status;
 
605
                { /* void */ }
 
606
 
 
607
void    name_$extract_data_lc(dir_entry, entry_type, entry_length, max_entry_length, entry_name, status)
 
608
                name_$canonical_dir_entry_t dir_entry;
 
609
                short   *entry_type;
 
610
                unsigned short *entry_length;
 
611
                unsigned short max_entry_length;
 
612
                char    *entry_name;
 
613
                status_$t *status;
 
614
                { /* void */ }
 
615
 
 
616
void    name_$get_path_lc(in_name, in_len, maxpnamelen, out_name, out_len, status)
 
617
                char    *in_name;
 
618
                unsigned short in_len;
 
619
                unsigned short maxpnamelen;
 
620
                char    *out_name;
 
621
                unsigned short *out_len;
 
622
                status_$t *status;
 
623
                { /* void */ }
 
624
 
 
625
void    name_$cname(old_pathname, old_length, new_leaf, leaf_length, status)
 
626
                char    *old_pathname;
 
627
                unsigned short old_length;
 
628
                char    *new_leaf;
 
629
                unsigned short leaf_length;
 
630
                status_$t *status;
 
631
                { /* void */ }
 
632
 
 
633
void    name_$set_wdir(name, name_length, status)
 
634
                char    *name;
 
635
                unsigned short name_length;
 
636
                status_$t *status;
 
637
                { /* void */ }
 
638
 
 
639
void    name_$get_wdir(name, name_length, status)
 
640
                char    *name;
 
641
                unsigned short *name_length;
 
642
                status_$t *status;
 
643
                { /* void */ }
 
644
 
 
645
void    name_$get_wdir_cc(name, name_length, status)
 
646
                char    *name;
 
647
                unsigned short *name_length;
 
648
                status_$t *status;
 
649
                { /* void */ }
 
650
 
 
651
void    name_$set_ndir(name, name_length, status)
 
652
                char    *name;
 
653
                unsigned short name_length;
 
654
                status_$t *status;
 
655
                { /* void */ }
 
656
 
 
657
void    name_$get_ndir(name, name_length, status)
 
658
                char    *name;
 
659
                unsigned short *name_length;
 
660
                status_$t *status;
 
661
                { /* void */ }
 
662
 
 
663
void    name_$get_ndir_cc(name, name_length, status)
 
664
                char    *name;
 
665
                unsigned short *name_length;
 
666
                status_$t *status;
 
667
                { /* void */ }
 
668
 
 
669
void    name_$read_dir(dir_name, name_length, dirlist, index, max_count, read_count, status)
 
670
                char    *dir_name;
 
671
                unsigned short name_length;
 
672
                name_$dir_entry_t *dirlist;
 
673
                unsigned short *index;
 
674
                unsigned short max_count;
 
675
                unsigned short *read_count;
 
676
                status_$t *status;
 
677
                { /* void */ }
 
678
 
 
679
void    name_$read_dir_cc(dir_name, name_length, dirlist, index, max_count, read_count, status)
 
680
                char    *dir_name;
 
681
                unsigned short name_length;
 
682
                name_$dir_entry_t *dirlist;
 
683
                unsigned short *index;
 
684
                unsigned short max_count;
 
685
                unsigned short *read_count;
 
686
                status_$t *status;
 
687
                { /* void */ }
 
688
 
 
689
void    name_$read_link(linkname, name_length, link_text, text_length, status)
 
690
                char    *linkname;
 
691
                unsigned short name_length;
 
692
                char    *link_text;
 
693
                unsigned short *text_length;
 
694
                status_$t *status;
 
695
                { /* void */ }
 
696
 
 
697
void    name_$extract_data(dir_entry, entry_type, entry_length, entry_name)
 
698
                name_$dir_entry_t dir_entry;
 
699
                unsigned short *entry_type;
 
700
                unsigned short *entry_length;
 
701
                char    *entry_name;
 
702
                { /* void */ }
 
703
 
 
704
void    name_$get_path(in_name, in_len, out_name, out_len, status)
 
705
                char    *in_name;
 
706
                unsigned short in_len;
 
707
                char    *out_name;
 
708
                unsigned short *out_len;
 
709
                status_$t *status;
 
710
                { /* void */ }
 
711
 
 
712
void    name_$get_path_cc(in_name, in_len, out_name, out_len, status)
 
713
                char    *in_name;
 
714
                unsigned short in_len;
 
715
                char    *out_name;
 
716
                unsigned short *out_len;
 
717
                status_$t *status;
 
718
                { /* void */ }
 
719
 
 
720
#include <apollo/pad.h>
 
721
 
 
722
void    pad_$raw(sid, sts)
 
723
                short   sid;
 
724
                status_$t *sts;
 
725
                { /* void */ }
 
726
 
 
727
void    pad_$cooked(sid, sts)
 
728
                short   sid;
 
729
                status_$t *sts;
 
730
                { /* void */ }
 
731
 
 
732
void    pad_$create(n, l, ptype, rel_pad, side, options, size, rslt_stream, s)
 
733
                char    *n;
 
734
                unsigned short l;
 
735
                pad_$type_t ptype;
 
736
                stream_$id_t rel_pad;
 
737
                pad_$side_t side;
 
738
                pad_$cre_opt_t options;
 
739
                short   size;
 
740
                stream_$id_t *rslt_stream;
 
741
                status_$t *s;
 
742
                { /* void */ }
 
743
 
 
744
void    pad_$create_window(n, l, ptype, unit, window, rslt_stream, s)
 
745
                char    *n;
 
746
                unsigned short l;
 
747
                pad_$type_t ptype;
 
748
                short   unit;
 
749
                pad_$window_desc_t window;
 
750
                stream_$id_t *rslt_stream;
 
751
                status_$t *s;
 
752
                { /* void */ }
 
753
 
 
754
void    pad_$create_frame(sid, width, height, sts)
 
755
                stream_$id_t sid;
 
756
                short   width;
 
757
                short   height;
 
758
                status_$t *sts;
 
759
                { /* void */ }
 
760
 
 
761
void    pad_$delete_frame(sid, sts)
 
762
                stream_$id_t sid;
 
763
                status_$t *sts;
 
764
                { /* void */ }
 
765
 
 
766
void    pad_$clear_frame(sid, clr_key, sts)
 
767
                stream_$id_t sid;
 
768
                stream_$sk_t clr_key;
 
769
                status_$t *sts;
 
770
                { /* void */ }
 
771
 
 
772
void    pad_$close_frame(sid, sts)
 
773
                stream_$id_t sid;
 
774
                status_$t *sts;
 
775
                { /* void */ }
 
776
 
 
777
void    pad_$move(sid, rel_abs, x, y, sts)
 
778
                stream_$id_t sid;
 
779
                pad_$rel_abs_t rel_abs;
 
780
                short   x;
 
781
                short   y;
 
782
                status_$t *sts;
 
783
                { /* void */ }
 
784
 
 
785
void    pad_$set_scale(sid, xs, ys, sts)
 
786
                stream_$id_t sid;
 
787
                short   xs;
 
788
                short   ys;
 
789
                status_$t *sts;
 
790
                { /* void */ }
 
791
 
 
792
void    pad_$load_font(sid, fname, fnl, fontx, sts)
 
793
                stream_$id_t sid;
 
794
                char    *fname;
 
795
                short   fnl;
 
796
                short   *fontx;
 
797
                status_$t *sts;
 
798
                { /* void */ }
 
799
 
 
800
void    pad_$use_font(sid, fontx, sts)
 
801
                stream_$id_t sid;
 
802
                short   fontx;
 
803
                status_$t *sts;
 
804
                { /* void */ }
 
805
 
 
806
void    pad_$inq_font(sid, fwidth, fhite, fname, fnsize, fnlen, sts)
 
807
                stream_$id_t sid;
 
808
                short   *fwidth;
 
809
                short   *fhite;
 
810
                char    *fname;
 
811
                short   fnsize;
 
812
                short   *fnlen;
 
813
                status_$t *sts;
 
814
                { /* void */ }
 
815
 
 
816
void    pad_$inq_windows(sid, wlist, wlsize, wcnt, sts)
 
817
                stream_$id_t sid;
 
818
                pad_$window_desc_t *wlist;
 
819
                short   wlsize;
 
820
                short   *wcnt;
 
821
                status_$t *sts;
 
822
                { /* void */ }
 
823
 
 
824
void    pad_$inq_position(sid, y, x, sts)
 
825
                stream_$id_t sid;
 
826
                short   *y;
 
827
                short   *x;
 
828
                status_$t *sts;
 
829
                { /* void */ }
 
830
 
 
831
void    pad_$set_tabs(sid, tsb, cnt, sts)
 
832
                stream_$id_t sid;
 
833
                short   *tsb;
 
834
                short   cnt;
 
835
                status_$t *sts;
 
836
                { /* void */ }
 
837
 
 
838
void    pad_$cpr_enable(sid, cpr_type, sts)
 
839
                stream_$id_t sid;
 
840
                short   cpr_type;
 
841
                status_$t *sts;
 
842
                { /* void */ }
 
843
 
 
844
void    pad_$locate(sid, x, y, c, sts)
 
845
                stream_$id_t sid;
 
846
                short   *x;
 
847
                short   *y;
 
848
                char    *c;
 
849
                status_$t *sts;
 
850
                { /* void */ }
 
851
 
 
852
void    pad_$dm_cmd(sid, cmd, cmd_len, sts)
 
853
                stream_$id_t sid;
 
854
                char    *cmd;
 
855
                short   cmd_len;
 
856
                status_$t *sts;
 
857
                { /* void */ }
 
858
 
 
859
void    pad_$def_pfk(sid, key_name, def, def_len, sts)
 
860
                stream_$id_t sid;
 
861
                char    *key_name;
 
862
                char    *def;
 
863
                short   def_len;
 
864
                status_$t *sts;
 
865
                { /* void */ }
 
866
 
 
867
void    pad_$edit_wait(sid, sts)
 
868
                stream_$id_t sid;
 
869
                status_$t *sts;
 
870
                { /* void */ }
 
871
 
 
872
void    pad_$inq_disp_type(sid, dtype, unit, sts)
 
873
                stream_$id_t sid;
 
874
                pad_$display_type_t *dtype;
 
875
                short   *unit;
 
876
                status_$t *sts;
 
877
                { /* void */ }
 
878
 
 
879
void    pad_$inq_view(sid, window_no, line, eof_lnum, x_offset, y_offset, sts)
 
880
                stream_$id_t sid;
 
881
                short   window_no;
 
882
                long    *line;
 
883
                long    *eof_lnum;
 
884
                short   *x_offset;
 
885
                short   *y_offset;
 
886
                status_$t *sts;
 
887
                { /* void */ }
 
888
 
 
889
void    pad_$set_view(sid, window_no, line, x_offset, y_offset, sts)
 
890
                stream_$id_t sid;
 
891
                short   window_no;
 
892
                long    line;
 
893
                short   x_offset;
 
894
                short   y_offset;
 
895
                status_$t *sts;
 
896
                { /* void */ }
 
897
 
 
898
void    pad_$inq_kbd(sid, buf_size, kbd_suffix, len, sts)
 
899
                stream_$id_t sid;
 
900
                short   buf_size;
 
901
                char    *kbd_suffix;
 
902
                short   *len;
 
903
                status_$t *sts;
 
904
                { /* void */ }
 
905
 
 
906
void    pad_$pop_push_window(sid, window_no, pop_push, sts)
 
907
                stream_$id_t sid;
 
908
                short   window_no;
 
909
                boolean pop_push;
 
910
                status_$t *sts;
 
911
                { /* void */ }
 
912
 
 
913
void    pad_$set_border(sid, window_no, border, sts)
 
914
                stream_$id_t sid;
 
915
                short   window_no;
 
916
                boolean border;
 
917
                status_$t *sts;
 
918
                { /* void */ }
 
919
 
 
920
void    pad_$create_icon(n, l, ptype, unit, icon_pos, icon_font_char, window, rslt_stream, s)
 
921
                char    *n;
 
922
                unsigned short l;
 
923
                pad_$type_t ptype;
 
924
                short   unit;
 
925
                pad_$position_t icon_pos;
 
926
                char    icon_font_char;
 
927
                pad_$window_desc_t *window;
 
928
                stream_$id_t *rslt_stream;
 
929
                status_$t *s;
 
930
                { /* void */ }
 
931
 
 
932
void    pad_$make_icon(sid, window_no, font_char, sts)
 
933
                stream_$id_t sid;
 
934
                short   window_no;
 
935
                char    font_char;
 
936
                status_$t *sts;
 
937
                { /* void */ }
 
938
 
 
939
void    pad_$icon_wait(sid, window_no, icon_moved, icon_pos_if_moved, sts)
 
940
                stream_$id_t sid;
 
941
                short   window_no;
 
942
                boolean *icon_moved;
 
943
                pad_$position_t *icon_pos_if_moved;
 
944
                status_$t *sts;
 
945
                { /* void */ }
 
946
 
 
947
void    pad_$set_full_window(sid, window_no, window, sts)
 
948
                stream_$id_t sid;
 
949
                short   window_no;
 
950
                pad_$window_desc_t *window;
 
951
                status_$t *sts;
 
952
                { /* void */ }
 
953
 
 
954
void    pad_$inq_full_window(sid, window_no, window, sts)
 
955
                stream_$id_t sid;
 
956
                short   window_no;
 
957
                pad_$window_desc_t *window;
 
958
                status_$t *sts;
 
959
                { /* void */ }
 
960
 
 
961
void    pad_$set_icon_pos(sid, window_no, icon_pos, font_char, sts)
 
962
                stream_$id_t sid;
 
963
                short   window_no;
 
964
                pad_$position_t icon_pos;
 
965
                char    font_char;
 
966
                status_$t *sts;
 
967
                { /* void */ }
 
968
 
 
969
void    pad_$inq_icon(sid, window_no, icon_pos, font_char, sts)
 
970
                stream_$id_t sid;
 
971
                short   window_no;
 
972
                pad_$position_t *icon_pos;
 
973
                char    *font_char;
 
974
                status_$t *sts;
 
975
                { /* void */ }
 
976
 
 
977
void    pad_$make_invisible(sid, window_no, sts)
 
978
                stream_$id_t sid;
 
979
                short   window_no;
 
980
                status_$t *sts;
 
981
                { /* void */ }
 
982
 
 
983
void    pad_$select_window(sid, window_no, sts)
 
984
                stream_$id_t sid;
 
985
                short   window_no;
 
986
                status_$t *sts;
 
987
                { /* void */ }
 
988
 
 
989
void    pad_$set_auto_close(sid, window_no, auto_close, sts)
 
990
                stream_$id_t sid;
 
991
                short   window_no;
 
992
                boolean auto_close;
 
993
                status_$t *sts;
 
994
                { /* void */ }
 
995
 
 
996
void    pad_$inq_icon_font(sid, window_no, font_name, fnbs, fnlen, sts)
 
997
                stream_$id_t sid;
 
998
                short   window_no;
 
999
                char    *font_name;
 
1000
                short   fnbs;
 
1001
                short   *fnlen;
 
1002
                status_$t *sts;
 
1003
                { /* void */ }
 
1004
 
 
1005
void    pad_$set_icon_font(sid, window_no, font_name, fnlen, sts)
 
1006
                stream_$id_t sid;
 
1007
                short   window_no;
 
1008
                char    *font_name;
 
1009
                short   fnlen;
 
1010
                status_$t *sts;
 
1011
                { /* void */ }
 
1012
 
 
1013
boolean pad_$is_icon(sid, window_no, sts)
 
1014
                stream_$id_t sid;
 
1015
                short   window_no;
 
1016
                status_$t *sts;
 
1017
                { return(*(boolean *)0); }
 
1018
 
 
1019
void    pad_$force_prompt(sid, sts)
 
1020
                stream_$id_t sid;
 
1021
                status_$t *sts;
 
1022
                { /* void */ }
 
1023
 
 
1024
void    pad_$isa(sid, sts)
 
1025
                stream_$id_t sid;
 
1026
                status_$t *sts;
 
1027
                { /* void */ }
 
1028
 
 
1029
void    pad_$isa_dm_pad(sid, sts)
 
1030
                stream_$id_t sid;
 
1031
                status_$t *sts;
 
1032
                { /* void */ }
 
1033
 
 
1034
void    pad_$set_erase(sid, window_no, erase, sts)
 
1035
                stream_$id_t sid;
 
1036
                short   window_no;
 
1037
                boolean erase;
 
1038
                status_$t *sts;
 
1039
                { /* void */ }
 
1040
 
 
1041
#include <apollo/tty.h>
 
1042
 
 
1043
void    tty_$isa(id, st)
 
1044
                ios_$id_t id;
 
1045
                status_$t *st;
 
1046
                { /* void */ }
 
1047
 
 
1048
void    tty_$inq_size(id, height, width, st)
 
1049
                ios_$id_t id;
 
1050
                pinteger *height;
 
1051
                pinteger *width;
 
1052
                status_$t *st;
 
1053
                { /* void */ }
 
1054
 
 
1055
void    tty_$set_size(id, height, width, st)
 
1056
                ios_$id_t id;
 
1057
                pinteger height;
 
1058
                pinteger width;
 
1059
                status_$t *st;
 
1060
                { /* void */ }
 
1061
 
 
1062
void    tty_$set_input_flag(id, flag, val, st)
 
1063
                ios_$id_t id;
 
1064
                tty_$input_flag_t flag;
 
1065
                boolean val;
 
1066
                status_$t *st;
 
1067
                { /* void */ }
 
1068
 
 
1069
tty_$input_flag_set_t tty_$inq_input_flags(id, st)
 
1070
                ios_$id_t id;
 
1071
                status_$t *st;
 
1072
                { return(*(tty_$input_flag_set_t *)0); }
 
1073
 
 
1074
void    tty_$set_output_flag(id, flag, val, st)
 
1075
                ios_$id_t id;
 
1076
                tty_$output_flag_t flag;
 
1077
                boolean val;
 
1078
                status_$t *st;
 
1079
                { /* void */ }
 
1080
 
 
1081
tty_$output_flag_set_t tty_$inq_output_flags(id, st)
 
1082
                ios_$id_t id;
 
1083
                status_$t *st;
 
1084
                { return(*(tty_$output_flag_set_t *)0); }
 
1085
 
 
1086
void    tty_$set_echo_flag(id, flag, val, st)
 
1087
                ios_$id_t id;
 
1088
                tty_$echo_flag_t flag;
 
1089
                boolean val;
 
1090
                status_$t *st;
 
1091
                { /* void */ }
 
1092
 
 
1093
tty_$echo_flag_set_t tty_$inq_echo_flags(id, st)
 
1094
                ios_$id_t id;
 
1095
                status_$t *st;
 
1096
                { return(*(tty_$echo_flag_set_t *)0); }
 
1097
 
 
1098
void    tty_$set_func_char(id, func, ch, st)
 
1099
                ios_$id_t id;
 
1100
                tty_$func_t func;
 
1101
                char    ch;
 
1102
                status_$t *st;
 
1103
                { /* void */ }
 
1104
 
 
1105
void    tty_$inq_func_char(id, func, ch, st)
 
1106
                ios_$id_t id;
 
1107
                tty_$func_t func;
 
1108
                char    *ch;
 
1109
                status_$t *st;
 
1110
                { /* void */ }
 
1111
 
 
1112
void    tty_$enable_func(id, func, val, st)
 
1113
                ios_$id_t id;
 
1114
                tty_$func_t func;
 
1115
                boolean val;
 
1116
                status_$t *st;
 
1117
                { /* void */ }
 
1118
 
 
1119
tty_$func_set_t tty_$inq_func_enabled(id, st)
 
1120
                ios_$id_t id;
 
1121
                status_$t *st;
 
1122
                { return(*(tty_$func_set_t *)0); }
 
1123
 
 
1124
void    tty_$set_process_group(id, uid, st)
 
1125
                ios_$id_t id;
 
1126
                uid_$t  uid;
 
1127
                status_$t *st;
 
1128
                { /* void */ }
 
1129
 
 
1130
void    tty_$inq_process_group(id, uid, st)
 
1131
                ios_$id_t id;
 
1132
                uid_$t  *uid;
 
1133
                status_$t *st;
 
1134
                { /* void */ }
 
1135
 
 
1136
void    tty_$set_input_break_mode(id, mode, st)
 
1137
                ios_$id_t id;
 
1138
                tty_$input_break_mode_t *mode;
 
1139
                status_$t *st;
 
1140
                { /* void */ }
 
1141
 
 
1142
void    tty_$inq_input_break_mode(id, mode, st)
 
1143
                ios_$id_t id;
 
1144
                tty_$input_break_mode_t *mode;
 
1145
                status_$t *st;
 
1146
                { /* void */ }
 
1147
 
 
1148
void    tty_$drain_output(id, st)
 
1149
                ios_$id_t id;
 
1150
                status_$t *st;
 
1151
                { /* void */ }
 
1152
 
 
1153
void    tty_$discard_input(id, st)
 
1154
                ios_$id_t id;
 
1155
                status_$t *st;
 
1156
                { /* void */ }
 
1157
 
 
1158
void    tty_$discard_output(id, st)
 
1159
                ios_$id_t id;
 
1160
                status_$t *st;
 
1161
                { /* void */ }
 
1162
 
 
1163
void    tty_$simulate_input(id, ch, st)
 
1164
                ios_$id_t id;
 
1165
                char    ch;
 
1166
                status_$t *st;
 
1167
                { /* void */ }
 
1168
 
 
1169
void    tty_$set_delay(id, delay, val, st)
 
1170
                ios_$id_t id;
 
1171
                tty_$delay_t delay;
 
1172
                pinteger val;
 
1173
                status_$t *st;
 
1174
                { /* void */ }
 
1175
 
 
1176
pinteger tty_$inq_delay(id, delay, st)
 
1177
                ios_$id_t id;
 
1178
                tty_$delay_t delay;
 
1179
                status_$t *st;
 
1180
                { return(*(pinteger *)0); }
 
1181
 
 
1182
void    tty_$set_unix_mode(id, mode, val, st)
 
1183
                ios_$id_t id;
 
1184
                tty_$unix_mode_t mode;
 
1185
                boolean val;
 
1186
                status_$t *st;
 
1187
                { /* void */ }
 
1188
 
 
1189
tty_$unix_mode_set_t tty_$inq_unix_modes(id, st)
 
1190
                ios_$id_t id;
 
1191
                status_$t *st;
 
1192
                { return(*(tty_$unix_mode_set_t *)0); }
 
1193
 
 
1194
void    tty_$set_raw(id, val, st)
 
1195
                ios_$id_t id;
 
1196
                boolean val;
 
1197
                status_$t *st;
 
1198
                { /* void */ }
 
1199
 
 
1200
boolean tty_$inq_raw(id, st)
 
1201
                ios_$id_t id;
 
1202
                status_$t *st;
 
1203
                { return(*(boolean *)0); }
 
1204
 
 
1205
void    tty_$set_non_canon_break_mode(id, mode, st)
 
1206
                ios_$id_t id;
 
1207
                tty_$input_break_mode_t *mode;
 
1208
                status_$t *st;
 
1209
                { /* void */ }
 
1210
 
 
1211
#include <apollo/type_uids.h>
 
1212
 
 
1213
uid_$t  case_hm_$uid;
 
1214
uid_$t  cmpexe_$uid;
 
1215
uid_$t  coff_$uid;
 
1216
uid_$t  d3m_area_$uid;
 
1217
uid_$t  d3m_sch_$uid;
 
1218
uid_$t  directory_$uid;
 
1219
uid_$t  dm_edit_$uid;
 
1220
uid_$t  hdr_undef_$uid;
 
1221
uid_$t  input_pad_$uid;
 
1222
uid_$t  mbx_$uid;
 
1223
uid_$t  mt_$uid;
 
1224
uid_$t  nulldev_$uid;
 
1225
uid_$t  object_file_$uid;
 
1226
uid_$t  pad_$uid;
 
1227
uid_$t  pty_$slave_uid;
 
1228
uid_$t  pty_$uid;
 
1229
uid_$t  records_$uid;
 
1230
uid_$t  sio_$uid;
 
1231
uid_$t  tcp_$uid;
 
1232
uid_$t  uasc_$uid;
 
1233
uid_$t  unstruct_$uid;