Commit | Line | Data |
---|---|---|
805e021f CE |
1 | /* @(#)rpc_cout.c 1.1 87/11/04 3.9 RPCSRC */ |
2 | /* | |
3 | * Sun RPC is a product of Sun Microsystems, Inc. and is provided for | |
4 | * unrestricted use provided that this legend is included on all tape | |
5 | * media and as a part of the software program in whole or part. Users | |
6 | * may copy or modify Sun RPC without charge, but are not authorized | |
7 | * to license or distribute it to anyone else except as part of a product or | |
8 | * program developed by the user. | |
9 | * | |
10 | * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE | |
11 | * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR | |
12 | * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. | |
13 | * | |
14 | * Sun RPC is provided with no support and without any obligation on the | |
15 | * part of Sun Microsystems, Inc. to assist in its use, correction, | |
16 | * modification or enhancement. | |
17 | * | |
18 | * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE | |
19 | * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC | |
20 | * OR ANY PART THEREOF. | |
21 | * | |
22 | * In no event will Sun Microsystems, Inc. be liable for any lost revenue | |
23 | * or profits or other special, indirect and consequential damages, even if | |
24 | * Sun has been advised of the possibility of such damages. | |
25 | * | |
26 | * Sun Microsystems, Inc. | |
27 | * 2550 Garcia Avenue | |
28 | * Mountain View, California 94043 | |
29 | */ | |
30 | ||
31 | /* | |
32 | * rpc_cout.c, XDR routine outputter for the RPC protocol compiler | |
33 | * Copyright (C) 1987, Sun Microsystems, Inc. | |
34 | */ | |
35 | #include <afsconfig.h> | |
36 | #include <afs/param.h> | |
37 | ||
38 | #include <roken.h> | |
39 | ||
40 | #include "rpc_scan.h" | |
41 | #include "rpc_parse.h" | |
42 | #include "rpc_util.h" | |
43 | ||
44 | /* Static prototypes */ | |
45 | static int findtype(definition * def, char *type); | |
46 | static int undefined(char *type); | |
47 | static void print_header(definition * def); | |
48 | static void print_trailer(void); | |
49 | static void print_ifopen(int indent, char *name); | |
50 | static void print_ifarg(char *arg); | |
51 | static void print_ifarg_with_cast(int ptr_to, char *type, char *arg); | |
52 | static void print_ifsizeof(char *prefix, char *type); | |
53 | static void print_ifclose(int indent); | |
54 | static void space(void); | |
55 | static void print_ifstat(int indent, char *prefix, char *type, relation rel, | |
56 | char *amax, char *objname, char *name); | |
57 | static void emit_enum(definition * def); | |
58 | static void emit_union(definition * def); | |
59 | static void emit_struct(definition * def); | |
60 | static void emit_typedef(definition * def); | |
61 | static void print_stat(declaration * dec); | |
62 | static void print_hout(declaration * dec); | |
63 | static void print_cout(declaration * dec); | |
64 | static void print_rxifopen(char *typename); | |
65 | static void print_rxifarg(char *amp, char *arg, int costant); | |
66 | static void print_rxifsizeof(char *prefix, char *type); | |
67 | ||
68 | ||
69 | /* | |
70 | * Emit the C-routine for the given definition | |
71 | */ | |
72 | void | |
73 | emit(definition * def) | |
74 | { | |
75 | if (def->def_kind == DEF_CONST) { | |
76 | return; | |
77 | } | |
78 | print_header(def); | |
79 | switch (def->def_kind) { | |
80 | case DEF_UNION: | |
81 | emit_union(def); | |
82 | break; | |
83 | case DEF_ENUM: | |
84 | emit_enum(def); | |
85 | break; | |
86 | case DEF_STRUCT: | |
87 | emit_struct(def); | |
88 | break; | |
89 | case DEF_TYPEDEF: | |
90 | emit_typedef(def); | |
91 | break; | |
92 | default: | |
93 | break; | |
94 | } | |
95 | print_trailer(); | |
96 | } | |
97 | ||
98 | static int | |
99 | findtype(definition * def, char *type) | |
100 | { | |
101 | if (def->def_kind == DEF_CONST) { | |
102 | return (0); | |
103 | } else { | |
104 | return (streq(def->def_name, type)); | |
105 | } | |
106 | } | |
107 | ||
108 | static int | |
109 | undefined(char *type) | |
110 | { | |
111 | definition *def; | |
112 | ||
113 | def = (definition *) FINDVAL(defined, type, findtype); | |
114 | return (def == NULL); | |
115 | } | |
116 | ||
117 | ||
118 | static void | |
119 | print_header(definition * def) | |
120 | { | |
121 | space(); | |
122 | f_print(fout, "bool_t\n"); | |
123 | f_print(fout, "xdr_%s(XDR *xdrs, ", def->def_name); | |
124 | f_print(fout, "%s ", def->def_name); | |
125 | #if 0 | |
126 | if (def->def_kind != DEF_TYPEDEF | |
127 | || !isvectordef(def->def.ty.old_type, def->def.ty.rel)) { | |
128 | f_print(fout, "*"); | |
129 | } | |
130 | #else | |
131 | f_print(fout, "*"); | |
132 | #endif | |
133 | f_print(fout, "objp)\n"); | |
134 | f_print(fout, "{\n"); | |
135 | } | |
136 | ||
137 | static void | |
138 | print_trailer(void) | |
139 | { | |
140 | f_print(fout, "\treturn (TRUE);\n"); | |
141 | f_print(fout, "}\n"); | |
142 | space(); | |
143 | } | |
144 | ||
145 | ||
146 | static void | |
147 | print_ifopen(int indent, char *name) | |
148 | { | |
149 | tabify(fout, indent); | |
150 | f_print(fout, "if (!xdr_%s(xdrs", name); | |
151 | } | |
152 | ||
153 | ||
154 | static void | |
155 | print_ifarg(char *arg) | |
156 | { | |
157 | f_print(fout, ", %s", arg); | |
158 | } | |
159 | ||
160 | ||
161 | static void | |
162 | print_ifarg_with_cast(int ptr_to, char *type, char *arg) | |
163 | { | |
164 | if (streq(type, "bool")) { | |
165 | f_print(fout, ptr_to ? ", (bool_t *) %s" : ", (bool_t) %s", arg); | |
166 | } else { | |
167 | f_print(fout, ptr_to ? ", (%s *) %s" : ", (%s) %s", type, arg); | |
168 | } | |
169 | } | |
170 | ||
171 | static void | |
172 | print_ifsizeof(char *prefix, char *type) | |
173 | { | |
174 | if (streq(type, "bool")) { | |
175 | f_print(fout, ", sizeof(bool_t), (xdrproc_t) xdr_bool"); | |
176 | } else { | |
177 | f_print(fout, ", sizeof("); | |
178 | if (undefined(type) && prefix) { | |
179 | f_print(fout, "%s ", prefix); | |
180 | } | |
181 | f_print(fout, "%s), (xdrproc_t) xdr_%s", type, type); | |
182 | } | |
183 | } | |
184 | ||
185 | static void | |
186 | print_ifclose(int indent) | |
187 | { | |
188 | f_print(fout, ")) {\n"); | |
189 | tabify(fout, indent); | |
190 | f_print(fout, "\treturn (FALSE);\n"); | |
191 | tabify(fout, indent); | |
192 | f_print(fout, "}\n"); | |
193 | } | |
194 | ||
195 | static void | |
196 | space(void) | |
197 | { | |
198 | f_print(fout, "\n\n"); | |
199 | } | |
200 | ||
201 | static void | |
202 | print_ifarg_val(char *objname, char *name) | |
203 | { | |
204 | if (*objname == '&') { | |
205 | if (brief_flag) { | |
206 | f_print(fout, "%s.val", objname); | |
207 | } else { | |
208 | f_print(fout, "%s.%s_val", objname, name); | |
209 | } | |
210 | } else { | |
211 | if (brief_flag) { | |
212 | f_print(fout, "&%s->val", objname); | |
213 | } else { | |
214 | f_print(fout, "&%s->%s_val", objname, name); | |
215 | } | |
216 | } | |
217 | } | |
218 | ||
219 | static void | |
220 | print_ifarg_len(char *objname, char *name) | |
221 | { | |
222 | if (*objname == '&') { | |
223 | if (brief_flag) { | |
224 | f_print(fout, "%s.len", objname); | |
225 | } else { | |
226 | f_print(fout, "%s.%s_len", objname, name); | |
227 | } | |
228 | } else { | |
229 | if (brief_flag) { | |
230 | f_print(fout, "&%s->len", objname); | |
231 | } else { | |
232 | f_print(fout, "&%s->%s_len", objname, name); | |
233 | } | |
234 | } | |
235 | } | |
236 | ||
237 | static void | |
238 | print_ifstat(int indent, char *prefix, char *type, relation rel, char *amax, | |
239 | char *objname, char *name) | |
240 | { | |
241 | char *alt = NULL; | |
242 | char *altcast = NULL; | |
243 | ||
244 | switch (rel) { | |
245 | case REL_POINTER: | |
246 | print_ifopen(indent, "pointer"); | |
247 | print_ifarg_with_cast(1, "char *", objname); | |
248 | print_ifsizeof(prefix, type); | |
249 | break; | |
250 | case REL_VECTOR: | |
251 | if (streq(type, "string")) { | |
252 | alt = "string"; | |
253 | } else if (streq(type, "opaque")) { | |
254 | alt = "opaque"; | |
255 | altcast = "caddr_t"; | |
256 | } | |
257 | if (alt) { | |
258 | print_ifopen(indent, alt); | |
259 | if (altcast) { | |
260 | print_ifarg_with_cast(0, altcast, objname); | |
261 | } else { | |
262 | print_ifarg(objname); | |
263 | } | |
264 | } else { | |
265 | print_ifopen(indent, "vector"); | |
266 | print_ifarg_with_cast(1, "char", objname); | |
267 | } | |
268 | print_ifarg(amax); | |
269 | if (!alt) { | |
270 | print_ifsizeof(prefix, type); | |
271 | } | |
272 | break; | |
273 | case REL_ARRAY: | |
274 | if (streq(type, "string")) { | |
275 | alt = "string"; | |
276 | } else if (streq(type, "opaque")) { | |
277 | alt = "bytes"; | |
278 | tabify(fout, indent); | |
279 | f_print(fout, "{\n"); | |
280 | ++indent; | |
281 | tabify(fout, indent); | |
282 | f_print(fout, "u_int __len = (u_int) "); | |
283 | f_print(fout, "*("); | |
284 | print_ifarg_len(objname, name); | |
285 | f_print(fout, ");\n"); | |
286 | } | |
287 | if (streq(type, "string")) { | |
288 | print_ifopen(indent, alt); | |
289 | print_ifarg(objname); | |
290 | } else { | |
291 | if (alt) { | |
292 | print_ifopen(indent, alt); | |
293 | print_ifarg("(char **)"); | |
294 | } else { | |
295 | print_ifopen(indent, "array"); | |
296 | print_ifarg("(caddr_t *)"); | |
297 | } | |
298 | print_ifarg_val(objname, name); | |
299 | f_print(fout, ", "); | |
300 | if (streq(type, "opaque")) { | |
301 | f_print(fout, "&__len"); | |
302 | } else { | |
303 | print_ifarg_len(objname, name); | |
304 | } | |
305 | } | |
306 | print_ifarg(amax); | |
307 | if (!alt) { | |
308 | print_ifsizeof(prefix, type); | |
309 | } | |
310 | break; | |
311 | case REL_ALIAS: | |
312 | print_ifopen(indent, type); | |
313 | print_ifarg(objname); | |
314 | break; | |
315 | } | |
316 | print_ifclose(indent); | |
317 | if (rel == REL_ARRAY && streq(type, "opaque")) { | |
318 | tabify(fout, indent); | |
319 | f_print(fout, "*("); | |
320 | print_ifarg_len(objname, name); | |
321 | f_print(fout, ")"); | |
322 | f_print(fout, " = __len;\n"); | |
323 | --indent; | |
324 | tabify(fout, indent); | |
325 | f_print(fout, "}\n"); | |
326 | } | |
327 | ||
328 | } | |
329 | ||
330 | ||
331 | static void | |
332 | emit_enum(definition * def) | |
333 | { | |
334 | print_ifopen(1, "enum"); | |
335 | print_ifarg("(enum_t *)objp"); | |
336 | print_ifclose(1); | |
337 | } | |
338 | ||
339 | ||
340 | static void | |
341 | emit_union(definition * def) | |
342 | { | |
343 | declaration *dflt; | |
344 | case_list *cl; | |
345 | declaration *cs; | |
346 | char *object; | |
347 | char *format = "&objp->%s_u.%s"; | |
348 | char *briefformat = "&objp->u.%s"; | |
349 | ||
350 | print_stat(&def->def.un.enum_decl); | |
351 | f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name); | |
352 | for (cl = def->def.un.cases; cl != NULL; cl = cl->next) { | |
353 | cs = &cl->case_decl; | |
354 | f_print(fout, "\tcase %s:\n", cl->case_name); | |
355 | if (!streq(cs->type, "void")) { | |
356 | object = | |
357 | alloc(strlen(def->def_name) + strlen(format) + | |
358 | strlen(cs->name) + 1); | |
359 | ||
360 | if (brief_flag) | |
361 | s_print(object, briefformat, cs->name); | |
362 | else | |
363 | s_print(object, format, def->def_name, cs->name); | |
364 | ||
365 | print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max, | |
366 | object, cs->name); | |
367 | free(object); | |
368 | } | |
369 | f_print(fout, "\t\tbreak;\n"); | |
370 | } | |
371 | dflt = def->def.un.default_decl; | |
372 | if (dflt != NULL) { | |
373 | if (!streq(dflt->type, "void")) { | |
374 | f_print(fout, "\tdefault:\n"); | |
375 | object = | |
376 | alloc(strlen(def->def_name) + strlen(format) + | |
377 | strlen(dflt->name) + 1); | |
378 | s_print(object, format, def->def_name, dflt->name); | |
379 | print_ifstat(2, dflt->prefix, dflt->type, dflt->rel, | |
380 | dflt->array_max, object, dflt->name); | |
381 | free(object); | |
382 | f_print(fout, "\t\tbreak;\n"); | |
383 | } | |
384 | } else { | |
385 | f_print(fout, "\tdefault:\n"); | |
386 | f_print(fout, "\t\treturn (FALSE);\n"); | |
387 | } | |
388 | f_print(fout, "\t}\n"); | |
389 | } | |
390 | ||
391 | ||
392 | ||
393 | static void | |
394 | emit_struct(definition * def) | |
395 | { | |
396 | decl_list *dl; | |
397 | ||
398 | for (dl = def->def.st.decls; dl != NULL; dl = dl->next) { | |
399 | print_stat(&dl->decl); | |
400 | } | |
401 | } | |
402 | ||
403 | ||
404 | ||
405 | ||
406 | static void | |
407 | emit_typedef(definition * def) | |
408 | { | |
409 | char *prefix = def->def.ty.old_prefix; | |
410 | char *type = def->def.ty.old_type; | |
411 | char *amax = def->def.ty.array_max; | |
412 | relation rel = def->def.ty.rel; | |
413 | ||
414 | print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name); | |
415 | } | |
416 | ||
417 | ||
418 | ||
419 | ||
420 | ||
421 | static void | |
422 | print_stat(declaration * dec) | |
423 | { | |
424 | char *prefix = dec->prefix; | |
425 | char *type = dec->type; | |
426 | char *amax = dec->array_max; | |
427 | relation rel = dec->rel; | |
428 | char name[256]; | |
429 | ||
430 | if (isvectordef(type, rel)) { | |
431 | s_print(name, "objp->%s", dec->name); | |
432 | } else { | |
433 | s_print(name, "&objp->%s", dec->name); | |
434 | } | |
435 | print_ifstat(1, prefix, type, rel, amax, name, dec->name); | |
436 | } | |
437 | ||
438 | static void | |
439 | print_hout(declaration * dec) | |
440 | { | |
441 | char prefix[8]; | |
442 | ||
443 | if (hflag) { | |
444 | if (dec->prefix) | |
445 | s_print(prefix, "%s ", dec->prefix); | |
446 | else | |
447 | prefix[0] = 0; | |
448 | f_print(fout, "\ntypedef "); | |
449 | switch (dec->rel) { | |
450 | case REL_ARRAY: | |
451 | f_print(fout, "struct %s {\n", dec->name); | |
452 | if (brief_flag) { | |
453 | f_print(fout, "\tu_int %s_len;\n", dec->name); | |
454 | f_print(fout, "\t%s%s *%s_val;\n", prefix, | |
455 | dec->type, dec->name); | |
456 | } else { | |
457 | f_print(fout, "\tu_int %s_len;\n", dec->name); | |
458 | f_print(fout, "\t%s%s *%s_val;\n", prefix, | |
459 | dec->type, dec->name); | |
460 | } | |
461 | f_print(fout, "} %s", dec->name); | |
462 | break; | |
463 | default: | |
464 | break; | |
465 | } | |
466 | f_print(fout, ";\n"); | |
467 | f_print(fout, "bool_t xdr_%s(XDR *xdrs, %s *objp);\n", dec->name, | |
468 | dec->name); | |
469 | } | |
470 | } | |
471 | ||
472 | ||
473 | static void | |
474 | print_cout(declaration * dec) | |
475 | { | |
476 | if (cflag) { | |
477 | space(); | |
478 | f_print(fout, "bool_t\n"); | |
479 | f_print(fout, "xdr_%s(XDR *xdrs, %s *objp)\n", dec->name, dec->name); | |
480 | f_print(fout, "{\n"); | |
481 | print_ifstat(1, dec->prefix, dec->type, dec->rel, dec->array_max, | |
482 | "objp", dec->name); | |
483 | print_trailer(); | |
484 | } | |
485 | } | |
486 | ||
487 | ||
488 | static void | |
489 | print_rxifopen(char *typename) | |
490 | { | |
491 | sprintf(Proc_list->code, "xdr_%s(&z_xdrs", typename); | |
492 | sprintf(Proc_list->scode, "xdr_%s(z_xdrs", typename); | |
493 | } | |
494 | ||
495 | ||
496 | static void | |
497 | print_rxifarg(char *amp, char *arg, int costant) | |
498 | { | |
499 | char code[100], scode[100]; | |
500 | ||
501 | sprintf(code, ", %s%s", amp, arg); | |
502 | if (costant) | |
503 | sprintf(scode, ", %s", arg); | |
504 | else | |
505 | sprintf(scode, ", &%s", arg); | |
506 | strcat(Proc_list->code, code); | |
507 | strcat(Proc_list->scode, scode); | |
508 | } | |
509 | ||
510 | ||
511 | static void | |
512 | print_rxifsizeof(char *prefix, char *type) | |
513 | { | |
514 | char name[256]; | |
515 | ||
516 | if (streq(type, "bool")) { | |
517 | strcat(Proc_list->code, ", sizeof(bool_t), xdr_bool"); | |
518 | strcat(Proc_list->scode, ", sizeof(bool_t), xdr_bool"); | |
519 | } else { | |
520 | strcat(Proc_list->code, ", sizeof("); | |
521 | strcat(Proc_list->scode, ", sizeof("); | |
522 | if (undefined(type) && prefix) { | |
523 | sprintf(name, "%s ", prefix); | |
524 | strcat(Proc_list->code, name); | |
525 | strcat(Proc_list->scode, name); | |
526 | } | |
527 | sprintf(name, "%s), xdr_%s", type, type); | |
528 | strcat(Proc_list->code, name); | |
529 | strcat(Proc_list->scode, name); | |
530 | } | |
531 | } | |
532 | ||
533 | ||
534 | void | |
535 | print_param(declaration * dec) | |
536 | { | |
537 | char *prefix = dec->prefix; | |
538 | char *type = dec->type; | |
539 | char *amax = dec->array_max; | |
540 | relation rel = dec->rel; | |
541 | char *name = dec->name; | |
542 | char *alt = NULL; | |
543 | char temp[256]; | |
544 | char *objname, *amp = ""; | |
545 | ||
546 | if (rel == REL_POINTER) | |
547 | Proc_list->pl.param_flag |= INDIRECT_PARAM; | |
548 | else { | |
549 | amp = "&"; | |
550 | Proc_list->pl.param_flag &= ~INDIRECT_PARAM; | |
551 | } | |
552 | objname = Proc_list->pl.param_name; | |
553 | switch (rel) { | |
554 | case REL_POINTER: | |
555 | print_rxifopen(type); | |
556 | print_rxifarg(amp, objname, 0); | |
557 | /* | |
558 | print_rxifopen("pointer"); | |
559 | print_rxifarg(amp, "(char **)", 1); | |
560 | sprintf(temp, "%s", objname); | |
561 | strcat(Proc_list->code, temp); | |
562 | strcat(Proc_list->scode, temp); | |
563 | print_rxifsizeof(prefix, type); | |
564 | */ | |
565 | break; | |
566 | case REL_VECTOR: | |
567 | if (streq(type, "string")) { | |
568 | alt = "string"; | |
569 | } else if (streq(type, "opaque")) { | |
570 | alt = "opaque"; | |
571 | } | |
572 | if (alt) | |
573 | print_rxifopen(alt); | |
574 | else | |
575 | print_rxifopen("vector"); | |
576 | ||
577 | print_rxifarg(amp, "(char *)", 0); | |
578 | sprintf(temp, "%s", objname); | |
579 | strcat(Proc_list->code, temp); | |
580 | strcat(Proc_list->scode, temp); | |
581 | print_rxifarg("", amax, 1); | |
582 | if (!alt) { | |
583 | print_rxifsizeof(prefix, type); | |
584 | } | |
585 | break; | |
586 | case REL_ARRAY: | |
587 | if (streq(type, "string")) { | |
588 | alt = "string"; | |
589 | } else if (streq(type, "opaque")) { | |
590 | alt = "bytes"; | |
591 | } | |
592 | if (streq(type, "string")) { | |
593 | print_rxifopen(alt); | |
594 | if ((Proc_list->pl.param_kind == DEF_OUTPARAM) | |
595 | || (Proc_list->pl.param_kind == DEF_INOUTPARAM)) { | |
596 | Proc_list->pl.param_flag |= OUT_STRING; | |
597 | print_rxifarg("", objname, 0); | |
598 | } else | |
599 | print_rxifarg("(char **) &", objname, 0); | |
600 | /* print_rxifarg(amp, objname, 0); */ | |
601 | print_rxifarg("", amax, 1); | |
602 | if (!alt) { | |
603 | print_rxifsizeof(prefix, type); | |
604 | } | |
605 | } else { | |
606 | char typecontents[100]; | |
607 | ||
608 | print_hout(dec); | |
609 | print_cout(dec); | |
610 | strcpy(temp, dec->name); | |
611 | strcpy(typecontents, dec->name); | |
612 | strcat(typecontents, " *"); | |
613 | strcpy(Proc_list->pl.param_type, typecontents); | |
614 | sprintf(typecontents, "%s_%d", Proc_list->pl.param_name, | |
615 | ++PerProcCounter); | |
616 | strcpy(Proc_list->pl.param_name, typecontents); | |
617 | Proc_list->pl.param_flag |= FREETHIS_PARAM; | |
618 | print_rxifopen(temp); | |
619 | print_rxifarg(amp, name, 0); | |
620 | } | |
621 | /* | |
622 | if (alt) { | |
623 | print_rxifopen(alt); | |
624 | } else { | |
625 | print_rxifopen("array"); | |
626 | } | |
627 | print_rxifarg(amp, "(char **)", 1); | |
628 | if (*objname == '&') { | |
629 | sprintf(temp, "%s.%s_val, (u_int *)%s.%s_len", | |
630 | objname, name, objname, name); | |
631 | } else { | |
632 | sprintf(temp, "&%s->%s_val, (u_int *)&%s->%s_len", | |
633 | objname, name, objname, name); | |
634 | } | |
635 | strcat(Proc_list->code, temp); | |
636 | strcat(Proc_list->scode, temp); | |
637 | } | |
638 | print_rxifarg("", amax, 1); | |
639 | if (!alt) { | |
640 | print_rxifsizeof(prefix, type); | |
641 | } | |
642 | */ | |
643 | break; | |
644 | case REL_ALIAS: | |
645 | print_rxifopen(type); | |
646 | print_rxifarg(amp, objname, 0); | |
647 | break; | |
648 | } | |
649 | strcat(Proc_list->code, ")"); | |
650 | strcat(Proc_list->scode, ")"); | |
651 | } |