Bug Summary

File:rxgen/rpc_parse.c
Location:line 1435, column 3
Description:Dereference of null pointer (loaded from variable 'pntr')

Annotated Source Code

1/* @(#)rpc_parse.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_parse.c, Parser 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 <ctype.h>
41
42#include "rpc_scan.h"
43#include "rpc_parse.h"
44#include "rpc_util.h"
45
46list *proc_defined[MAX_PACKAGES10], *special_defined, *typedef_defined,
47 *uniondef_defined, *complex_defined;
48char *SplitStart = NULL((void *)0);
49char *SplitEnd = NULL((void *)0);
50char *MasterPrefix = NULL((void *)0);
51char *ServerPrefix = "";
52char *PackagePrefix[MAX_PACKAGES10];
53char *PackageStatIndex[MAX_PACKAGES10];
54int no_of_stat_funcs = 0; /*
55 * current function number in client interface
56 * starts at 0
57 */
58int no_of_stat_funcs_header[MAX_PACKAGES10]; /*
59 * Total number of functions in client
60 * interface
61 */
62int no_of_opcodes[MAX_PACKAGES10], master_no_of_opcodes = 0;
63int lowest_opcode[MAX_PACKAGES10], master_lowest_opcode = 99999;
64int highest_opcode[MAX_PACKAGES10], master_highest_opcode = 0;
65int master_opcodenumber = 99999;
66int opcodesnotallowed[MAX_PACKAGES10];
67int combinepackages = 0;
68int PackageIndex = -1;
69int PerProcCounter = 0;
70int Multi_Init = 0;
71
72/*
73 * Character arrays to keep list of function names as we process the file
74 */
75
76char function_list[MAX_PACKAGES10]
77 [MAX_FUNCTIONS_PER_PACKAGE500]
78 [MAX_FUNCTION_NAME_LEN200];
79int function_list_index;
80
81/* static prototypes */
82static void isdefined(definition * defp);
83static void def_struct(definition * defp);
84static void def_program(definition * defp);
85static void def_enum(definition * defp);
86static void def_const(definition * defp);
87static void def_union(definition * defp);
88static void def_typedef(definition * defp);
89static void get_declaration(declaration * dec, defkind dkind);
90static void get_type(char **prefixp, char **typep, defkind dkind);
91static void unsigned_dec(char **typep);
92static void def_package(definition * defp);
93static void def_prefix(definition * defp);
94static void def_statindex(definition * defp);
95static void def_startingopcode(definition * defp);
96static void def_split(definition * defp);
97static void customize_struct(definition * defp);
98static char *structname(char *name);
99static void def_special(declaration * dec, definition * defp);
100static void check_proc(definition * defp, token * tokp, int noname);
101static int InvalidConstant(char *name);
102static int opcodenum_is_defined(int opcode_num);
103static void analyze_ProcParams(definition * defp, token * tokp);
104static void generate_code(definition * defp, int proc_split_flag,
105 int multi_flag);
106static void handle_split_proc(definition * defp, int multi_flag);
107static void do_split(definition * defp, int direction, int *numofparams,
108 defkind param_kind, int restore_flag);
109static void hdle_param_tok(definition * defp, declaration * dec, token * tokp,
110 defkind par_kind);
111static void get1_param_type(definition * defp, declaration * dec,
112 char **param_type);
113static void get_param_type(definition * defp, declaration * dec,
114 char **param_type, char **typename);
115#ifdef undef
116static void hndle_param_tail(definition * defp, declaration * dec,
117 token * tokp, char *typename);
118#endif
119static void cs_Proc_CodeGeneration(definition * defp, int split_flag,
120 char *procheader);
121static void cs_ProcName_setup(definition * defp, char *procheader,
122 int split_flag);
123static void cs_ProcParams_setup(definition * defp, int split_flag);
124static void cs_ProcMarshallInParams_setup(definition * defp, int split_flag);
125static void cs_ProcSendPacket_setup(definition * defp, int split_flag);
126static void cs_ProcUnmarshallOutParams_setup(definition * defp);
127static void cs_ProcTail_setup(definition * defp, int split_flag);
128static void ucs_ProcName_setup(definition * defp, char *procheader,
129 int split_flag);
130static void ucs_ProcParams_setup(definition * defp, int split_flag);
131static void ucs_ProcTail_setup(definition * defp, int split_flag);
132static void ss_Proc_CodeGeneration(definition * defp);
133static void ss_ProcName_setup(definition * defp);
134static void ss_ProcParams_setup(definition * defp, int *somefrees);
135static void ss_ProcSpecial_setup(definition * defp, int *somefrees);
136static void ss_ProcUnmarshallInParams_setup(definition * defp);
137static void ss_ProcCallRealProc_setup(definition * defp);
138static void ss_ProcMarshallOutParams_setup(definition * defp);
139static void ss_ProcTail_setup(definition * defp, int somefrees);
140static int opcode_holes_exist(void);
141static void er_ProcDeclExterns_setup(void);
142static void er_ProcProcsArray_setup(void);
143static void er_ProcMainBody_setup(void);
144static void er_HeadofOldStyleProc_setup(void);
145static void er_BodyofOldStyleProc_setup(void);
146static void proc_er_case(definition * defp);
147static void er_TailofOldStyleProc_setup(void);
148
149
150
151/*
152 * return the next definition you see
153 */
154definition *
155get_definition(void)
156{
157 definition *defp;
158 token tok;
159
160 defp = ALLOC(definition)(definition *) malloc(sizeof(definition));
161 memset(defp, 0, sizeof(definition));
162 get_token(&tok);
163 switch (tok.kind) {
164 case TOK_STRUCT:
165 def_struct(defp);
166 break;
167 case TOK_UNION:
168 def_union(defp);
169 break;
170 case TOK_TYPEDEF:
171 def_typedef(defp);
172 break;
173 case TOK_ENUM:
174 def_enum(defp);
175 break;
176 case TOK_PROGRAM:
177 def_program(defp);
178 break;
179 case TOK_CONST:
180 def_const(defp);
181 break;
182 case TOK_EOF:
183 return (NULL((void *)0));
184 case TOK_PACKAGE:
185 def_package(defp);
186 break;
187 case TOK_PREFIX:
188 def_prefix(defp);
189 break;
190 case TOK_STATINDEX:
191 def_statindex(defp);
192 break;
193 case TOK_SPECIAL:
194 {
195 declaration dec;
196 def_special(&dec, defp);
197 break;
198 }
199 case TOK_STARTINGOPCODE:
200 def_startingopcode(defp);
201 break;
202 case TOK_CUSTOMIZED:
203 get_token(&tok);
204 def_struct(defp);
205 customize_struct(defp);
206 break;
207 case TOK_SPLITPREFIX:
208 def_split(defp);
209 break;
210 case TOK_PROC:
211 get_token(&tok);
212 if (tok.kind == TOK_LPAREN) {
213 unget_token(&tok);
214 check_proc(defp, &tok, 1);
215 } else
216 check_proc(defp, &tok, 0);
217 break;
218 case TOK_IDENT:
219 check_proc(defp, &tok, 0);
220 break;
221 case TOK_LPAREN:
222 unget_token(&tok);
223 check_proc(defp, &tok, 1);
224 break;
225 default:
226 error("definition keyword expected");
227 }
228 if (!IsRxgenToken(&tok)) {
229 scan(TOK_SEMICOLON, &tok);
230 isdefined(defp);
231 } else
232 pushed = 0;
233 return (defp);
234}
235
236static void
237isdefined(definition * defp)
238{
239 STOREVAL(&defined, defp)storeval(&defined,(char *)defp);
240}
241
242
243static void
244def_struct(definition * defp)
245{
246 token tok;
247 declaration dec;
248 decl_list *decls;
249 decl_list **tailp;
250 int special = 0;
251
252 defp->def_kind = DEF_STRUCT;
253
254 scan(TOK_IDENT, &tok);
255 defp->def_name = tok.str;
256 scan(TOK_LBRACE, &tok);
257 tailp = &defp->def.st.decls;
258 do {
259 get_declaration(&dec, DEF_STRUCT);
260 /* If a structure contains an array, then we're going
261 * to need to be clever about freeing it */
262 if (dec.rel == REL_ARRAY) {
263 special = 1;
264 }
265 decls = ALLOC(decl_list)(decl_list *) malloc(sizeof(decl_list));
266 decls->decl = dec;
267 *tailp = decls;
268 tailp = &decls->next;
269 scan(TOK_SEMICOLON, &tok);
270 peek(&tok);
271 } while (tok.kind != TOK_RBRACE);
272 get_token(&tok);
273 *tailp = NULL((void *)0);
274
275 if (special)
276 STOREVAL(&complex_defined, defp)storeval(&complex_defined,(char *)defp);
277}
278
279static void
280def_program(definition * defp)
281{
282 token tok;
283 version_list *vlist;
284 version_list **vtailp;
285 proc_list *plist;
286 proc_list **ptailp;
287
288 defp->def_kind = DEF_PROGRAM;
289 scan(TOK_IDENT, &tok);
290 defp->def_name = tok.str;
291 scan(TOK_LBRACE, &tok);
292 vtailp = &defp->def.pr.versions;
293 scan(TOK_VERSION, &tok);
294 do {
295 scan(TOK_IDENT, &tok);
296 vlist = ALLOC(version_list)(version_list *) malloc(sizeof(version_list));
297 vlist->vers_name = tok.str;
298 scan(TOK_LBRACE, &tok);
299 ptailp = &vlist->procs;
300 do {
301 plist = ALLOC(proc_list)(proc_list *) malloc(sizeof(proc_list));
302 get_type(&plist->res_prefix, &plist->res_type, DEF_PROGRAM);
303 if (streq(plist->res_type, "opaque")) {
304 error("illegal result type");
305 }
306 scan(TOK_IDENT, &tok);
307 plist->proc_name = tok.str;
308 scan(TOK_LPAREN, &tok);
309 get_type(&plist->arg_prefix, &plist->arg_type, DEF_PROGRAM);
310 if (streq(plist->arg_type, "opaque")) {
311 error("illegal argument type");
312 }
313 scan(TOK_RPAREN, &tok);
314 scan(TOK_EQUAL, &tok);
315 scan_num(&tok);
316 scan(TOK_SEMICOLON, &tok);
317 plist->proc_num = tok.str;
318 *ptailp = plist;
319 ptailp = &plist->next;
320 peek(&tok);
321 } while (tok.kind != TOK_RBRACE);
322 *vtailp = vlist;
323 vtailp = &vlist->next;
324 scan(TOK_RBRACE, &tok);
325 scan(TOK_EQUAL, &tok);
326 scan_num(&tok);
327 vlist->vers_num = tok.str;
328 scan(TOK_SEMICOLON, &tok);
329 scan2(TOK_VERSION, TOK_RBRACE, &tok);
330 } while (tok.kind == TOK_VERSION);
331 scan(TOK_EQUAL, &tok);
332 scan_num(&tok);
333 defp->def.pr.prog_num = tok.str;
334 *vtailp = NULL((void *)0);
335}
336
337static void
338def_enum(definition * defp)
339{
340 token tok;
341 enumval_list *elist;
342 enumval_list **tailp;
343
344 defp->def_kind = DEF_ENUM;
345 scan(TOK_IDENT, &tok);
346 defp->def_name = tok.str;
347 scan(TOK_LBRACE, &tok);
348 tailp = &defp->def.en.vals;
349 do {
350 scan(TOK_IDENT, &tok);
351 elist = ALLOC(enumval_list)(enumval_list *) malloc(sizeof(enumval_list));
352 elist->name = tok.str;
353 elist->assignment = NULL((void *)0);
354 scan3(TOK_COMMA, TOK_RBRACE, TOK_EQUAL, &tok);
355 if (tok.kind == TOK_EQUAL) {
356 scan_num(&tok);
357 elist->assignment = tok.str;
358 scan2(TOK_COMMA, TOK_RBRACE, &tok);
359 }
360 *tailp = elist;
361 tailp = &elist->next;
362 } while (tok.kind != TOK_RBRACE);
363 *tailp = NULL((void *)0);
364}
365
366static void
367def_const(definition * defp)
368{
369 token tok;
370
371 defp->def_kind = DEF_CONST;
372 scan(TOK_IDENT, &tok);
373 defp->def_name = tok.str;
374 scan(TOK_EQUAL, &tok);
375 scan2(TOK_IDENT, TOK_STRCONST, &tok);
376 defp->def.co = tok.str;
377}
378
379static void
380def_union(definition * defp)
381{
382 token tok;
383 declaration dec;
384 case_list *cases;
385 case_list **tailp;
386
387 defp->def_kind = DEF_UNION;
388 scan(TOK_IDENT, &tok);
389 defp->def_name = tok.str;
390 scan(TOK_SWITCH, &tok);
391 scan(TOK_LPAREN, &tok);
392 get_declaration(&dec, DEF_UNION);
393 defp->def.un.enum_decl = dec;
394 tailp = &defp->def.un.cases;
395 scan(TOK_RPAREN, &tok);
396 scan(TOK_LBRACE, &tok);
397 scan(TOK_CASE, &tok);
398 while (tok.kind == TOK_CASE) {
399 scan(TOK_IDENT, &tok);
400 cases = ALLOC(case_list)(case_list *) malloc(sizeof(case_list));
401 cases->case_name = tok.str;
402 scan(TOK_COLON, &tok);
403 get_declaration(&dec, DEF_UNION);
404 cases->case_decl = dec;
405 *tailp = cases;
406 tailp = &cases->next;
407 scan(TOK_SEMICOLON, &tok);
408 scan3(TOK_CASE, TOK_DEFAULT, TOK_RBRACE, &tok);
409 }
410 *tailp = NULL((void *)0);
411 if (tok.kind == TOK_DEFAULT) {
412 scan(TOK_COLON, &tok);
413 get_declaration(&dec, DEF_UNION);
414 defp->def.un.default_decl = ALLOC(declaration)(declaration *) malloc(sizeof(declaration));
415 *defp->def.un.default_decl = dec;
416 scan(TOK_SEMICOLON, &tok);
417 scan(TOK_RBRACE, &tok);
418 } else {
419 defp->def.un.default_decl = NULL((void *)0);
420 }
421}
422
423
424static void
425def_typedef(definition * defp)
426{
427 declaration dec;
428
429 defp->def_kind = DEF_TYPEDEF;
430 get_declaration(&dec, DEF_TYPEDEF);
431 defp->def_name = dec.name;
432 defp->def.ty.old_prefix = dec.prefix;
433 defp->def.ty.old_type = dec.type;
434 defp->def.ty.rel = dec.rel;
435 defp->def.ty.array_max = dec.array_max;
436}
437
438
439static void
440get_declaration(declaration * dec, defkind dkind)
441{
442 token tok;
443
444 get_type(&dec->prefix, &dec->type, dkind);
445 dec->rel = REL_ALIAS;
446 if (streq(dec->type, "void")) {
447 return;
448 }
449 scan2(TOK_STAR, TOK_IDENT, &tok);
450 if (tok.kind == TOK_STAR) {
451 dec->rel = REL_POINTER;
452 scan(TOK_IDENT, &tok);
453 }
454 dec->name = tok.str;
455 if (peekscan(TOK_LBRACKET, &tok)) {
456 if (dec->rel == REL_POINTER) {
457 error("no array-of-pointer declarations -- use typedef");
458 }
459 dec->rel = REL_VECTOR;
460 scan_num(&tok);
461 dec->array_max = tok.str;
462 scan(TOK_RBRACKET, &tok);
463 } else if (peekscan(TOK_LANGLE, &tok)) {
464 if (dec->rel == REL_POINTER) {
465 error("no array-of-pointer declarations -- use typedef");
466 }
467 dec->rel = REL_ARRAY;
468 if (peekscan(TOK_RANGLE, &tok)) {
469 dec->array_max = "~0"; /* unspecified size, use max */
470 } else {
471 scan_num(&tok);
472 dec->array_max = tok.str;
473 scan(TOK_RANGLE, &tok);
474 }
475 }
476 if (streq(dec->type, "opaque")) {
477 if (dec->rel != REL_ARRAY && dec->rel != REL_VECTOR) {
478 error("array declaration expected");
479 }
480 } else if (streq(dec->type, "string")) {
481 if (dec->rel != REL_ARRAY) {
482 error(" variable-length array declaration expected");
483 }
484 }
485}
486
487
488static void
489get_type(char **prefixp, char **typep, defkind dkind)
490{
491 token tok;
492
493 *prefixp = NULL((void *)0);
494 get_token(&tok);
495 switch (tok.kind) {
496 case TOK_IDENT:
497 *typep = tok.str;
498 break;
499 case TOK_STRUCT:
500 case TOK_ENUM:
501 case TOK_UNION:
502 *prefixp = tok.str;
503 scan(TOK_IDENT, &tok);
504 *typep = tok.str;
505 break;
506 case TOK_UNSIGNED:
507 unsigned_dec(typep);
508 break;
509 case TOK_SHORT:
510 *typep = "short";
511 (void)peekscan(TOK_INT, &tok);
512 break;
513 case TOK_INT32:
514 *typep = "afs_int32";
515 (void)peekscan(TOK_INT, &tok);
516 break;
517 case TOK_VOID:
518 if (dkind != DEF_UNION && dkind != DEF_PROGRAM) {
519 error("voids allowed only inside union and program definitions");
520 }
521 *typep = tok.str;
522 break;
523 case TOK_STRING:
524 case TOK_OPAQUE:
525 case TOK_CHAR:
526 case TOK_INT:
527 case TOK_FLOAT:
528 case TOK_DOUBLE:
529 case TOK_BOOL:
530 case TOK_AFSUUID:
531 *typep = tok.str;
532 break;
533 default:
534 error("expected type specifier");
535 }
536}
537
538
539static void
540unsigned_dec(char **typep)
541{
542 token tok;
543
544 peek(&tok);
545 switch (tok.kind) {
546 case TOK_CHAR:
547 get_token(&tok);
548 *typep = "u_char";
549 break;
550 case TOK_SHORT:
551 get_token(&tok);
552 *typep = "u_short";
553 (void)peekscan(TOK_INT, &tok);
554 break;
555 case TOK_INT32:
556 get_token(&tok);
557 *typep = "afs_uint32";
558 (void)peekscan(TOK_INT, &tok);
559 break;
560 case TOK_INT:
561 get_token(&tok);
562 *typep = "u_int";
563 break;
564 default:
565 *typep = "u_int";
566 break;
567 }
568}
569
570
571static void
572def_package(definition * defp)
573{
574 token tok;
575
576 defp->def_kind = DEF_PACKAGE;
577 scan(TOK_IDENT, &tok);
578 defp->def_name = tok.str;
579 no_of_stat_funcs = 0;
580 if (PackageIndex++ >= MAX_PACKAGES10)
581 error("Exceeded upper limit of package statements\n");
582 function_list_index = 0;
583 PackagePrefix[PackageIndex] = tok.str;
584 if (MasterPrefix == NULL((void *)0))
585 MasterPrefix = tok.str;
586 no_of_opcodes[PackageIndex] = highest_opcode[PackageIndex] =
587 opcodesnotallowed[PackageIndex] = 0;
588 lowest_opcode[PackageIndex] = 99999;
589 proc_defined[PackageIndex] = NULL((void *)0);
590 PackageStatIndex[PackageIndex] = NULL((void *)0);
591}
592
593static void
594def_prefix(definition * defp)
595{
596 token tok;
597
598 defp->def_kind = DEF_PREFIX;
599 scan(TOK_IDENT, &tok);
600 defp->def_name = tok.str;
601 ServerPrefix = tok.str;
602}
603
604static void
605def_statindex(definition * defp)
606{
607 token tok;
608 char *name;
609
610 defp->def_kind = DEF_CONST;
611 scan_num(&tok);
612 if (PackageIndex < 0)
613 error("'statindex' command must follow 'package' command!\n");
614 if (PackageStatIndex[PackageIndex])
615 error("Cannot have more then one 'statindex' per package!\n");
616 if (InvalidConstant(tok.str))
617 error("Index in 'statindex' command must be a constant!");
618 name =
619 alloc(strlen(PackagePrefix[PackageIndex]) + strlen("STATINDEX") + 1)malloc((unsigned)(strlen(PackagePrefix[PackageIndex]) + strlen
("STATINDEX") + 1));
620 strcpy(name, PackagePrefix[PackageIndex]);
621 strcat(name, "STATINDEX");
622 defp->def_name = name;
623 defp->def.co = tok.str;
624 PackageStatIndex[PackageIndex] = name;
625}
626
627static void
628def_startingopcode(definition * defp)
629{
630 token tok;
631
632 defp->def_kind = DEF_STARTINGOPCODE;
633 scan(TOK_IDENT, &tok);
634 defp->def_name = tok.str;
635 if (InvalidConstant(defp->def_name))
636 error("Opcode in 'startingopcode' command must be a constant!");
637 lowest_opcode[PackageIndex] = master_lowest_opcode = atoi(tok.str);
638 if (lowest_opcode[PackageIndex] < 0
639 || lowest_opcode[PackageIndex] > 99999)
640 error
641 ("startingopcode number is out of bounds (must be >= 0 < 100000)");
642 master_opcodenumber = lowest_opcode[PackageIndex];
643 opcodesnotallowed[PackageIndex] = 1;
644}
645
646static void
647def_split(definition * defp)
648{
649 token tok;
650
651 defp->def_kind = DEF_SPLITPREFIX;
652 do {
653 get_token(&tok);
654 switch (tok.kind) {
655 case TOK_IN:
656 scan(TOK_EQUAL, &tok);
657 scan(TOK_IDENT, &tok);
658 SplitStart = tok.str;
659 break;
660 case TOK_OUT:
661 scan(TOK_EQUAL, &tok);
662 scan(TOK_IDENT, &tok);
663 SplitEnd = tok.str;
664 break;
665 case TOK_SEMICOLON:
666 break;
667 default:
668 error("syntax error in the 'splitprefix' line");
669 }
670 } while (tok.kind != TOK_SEMICOLON);
671 if (!SplitStart && !SplitEnd)
672 error("At least one param should be passed to 'splitprefix' cmd");
673}
674
675
676static void
677customize_struct(definition * defp)
678{
679 decl_list *listp;
680 declaration *dec;
681 definition *defp1 = ALLOC(definition)(definition *) malloc(sizeof(definition));
682 spec_list *specs, **tailp;
683
684 defp->def_kind = DEF_CUSTOMIZED;
685 defp1->def_kind = DEF_SPECIAL;
686 tailp = &defp1->def.sd.specs;
687 for (listp = defp->def.st.decls; listp; listp = listp->next) {
688 dec = &listp->decl;
689 if (streq(dec->type, "string") || (dec->rel == REL_POINTER)) {
690 specs = ALLOC(spec_list)(spec_list *) malloc(sizeof(spec_list));
691 specs->sdef.string_name = dec->name;
692 specs->sdef.string_value = defp->def_name;
693 *tailp = specs;
694 tailp = &specs->next;
695 }
696 }
697 tailp = NULL((void *)0);
698 STOREVAL(&special_defined, defp1)storeval(&special_defined,(char *)defp1);
699}
700
701static char *
702structname(char *name)
703{
704 static char namecontents[150];
705 char *pnt, *pnt1;
706
707 strcpy(namecontents, name);
708 pnt = namecontents;
709 if (!strncmp(pnt, "struct", 6))
710 pnt += 6;
711 while (isspace(*pnt)__sbistype((*pnt), 0x00004000L))
712 pnt++;
713 pnt1 = pnt;
714 while (*pnt != ' ' && *pnt != '\0')
715 pnt++;
716 *pnt = '\0';
717 return pnt1;
718}
719
720
721static void
722def_special(declaration * dec, definition * defp)
723{
724 char *typename;
725 spec_list *specs, **tailp;
726 token tok;
727
728 defp->def_kind = DEF_SPECIAL;
729 get_type(&dec->prefix, &dec->type, DEF_SPECIAL);
730 dec->rel = REL_POINTER;
731 scan(TOK_IDENT, &tok);
732 tailp = &defp->def.sd.specs;
733 do {
734 specs = ALLOC(spec_list)(spec_list *) malloc(sizeof(spec_list));
735 specs->sdef.string_name = tok.str;
736 get_param_type(defp, dec, &specs->sdef.string_value, &typename);
737 *tailp = specs;
738 tailp = &specs->next;
739 scan2(TOK_COMMA, TOK_SEMICOLON, &tok);
740 if (tok.kind == TOK_SEMICOLON)
741 break;
742 get_token(&tok);
743 } while (tok.kind == TOK_IDENT);
744 tailp = NULL((void *)0);
745 STOREVAL(&special_defined, defp)storeval(&special_defined,(char *)defp);
746}
747
748
749proc1_list *Proc_list, **Proc_listp;
750
751static void
752check_proc(definition * defp, token * tokp, int noname)
753{
754 token tok;
755 int proc_split = 0;
756 int proc_multi = 0;
757
758 if (PackageIndex < 0)
759 error("Procedure must be in a package!\n");
760
761 tokp->kind = TOK_PROC;
762 defp->def_kind = DEF_PROC;
763 if (noname)
764 defp->pc.proc_name = "";
765 else
766 defp->pc.proc_name = tokp->str;
767 PerProcCounter = 0;
768 defp->pc.proc_prefix = alloc(strlen(PackagePrefix[PackageIndex]) + 1)malloc((unsigned)(strlen(PackagePrefix[PackageIndex]) + 1));
769 strcpy(defp->pc.proc_prefix, PackagePrefix[PackageIndex]);
770 scan2(TOK_LPAREN, TOK_IDENT, &tok);
771 defp->pc.proc_serverstub = NULL((void *)0);
772 if (tok.kind == TOK_IDENT) {
773 defp->pc.proc_serverstub = tok.str;
774 scan(TOK_LPAREN, &tok);
775 }
776 analyze_ProcParams(defp, &tok);
777 defp->pc.proc_opcodenum = -1;
778 scan4(TOK_SPLIT, TOK_MULTI, TOK_EQUAL, TOK_SEMICOLON, &tok);
779 if (tok.kind == TOK_MULTI) {
780 proc_multi = 1;
781 defp->pc.multi_flag = 1;
782 scan2(TOK_EQUAL, TOK_SEMICOLON, &tok);
783 } else {
784 defp->pc.multi_flag = 0;
785 }
786 if (tok.kind == TOK_SPLIT) {
787 proc_split = 1;
788 defp->pc.split_flag = 1;
789 scan2(TOK_EQUAL, TOK_SEMICOLON, &tok);
790 } else {
791 defp->pc.split_flag = 0;
792 }
793 if (tok.kind == TOK_EQUAL) {
794 if (opcodesnotallowed[PackageIndex])
795 error("Opcode assignment isn't allowed here!");
796 scan_num(&tok);
797 if (InvalidConstant(tok.str))
798 error("Illegal Opcode assignment (Must be a constant opcode!)");
799 if (opcodenum_is_defined(atoi(tok.str)))
800 error("The opcode number is already used by a previous proc");
801 defp->pc.proc_opcodename = tok.str;
802 defp->pc.proc_opcodenum = atoi(tok.str);
803 if (defp->pc.proc_opcodenum < lowest_opcode[PackageIndex])
804 lowest_opcode[PackageIndex] = defp->pc.proc_opcodenum;
805 if (defp->pc.proc_opcodenum < master_lowest_opcode)
806 master_lowest_opcode = defp->pc.proc_opcodenum;
807 if (defp->pc.proc_opcodenum > highest_opcode[PackageIndex])
808 highest_opcode[PackageIndex] = defp->pc.proc_opcodenum;
809 if (defp->pc.proc_opcodenum > master_highest_opcode)
810 master_highest_opcode = defp->pc.proc_opcodenum;
811 scan(TOK_SEMICOLON, &tok);
812 } else {
813 if (master_opcodenumber == 99999)
814 master_opcodenumber = 0;
815 defp->pc.proc_opcodenum = master_opcodenumber++;
816 if (defp->pc.proc_opcodenum < lowest_opcode[PackageIndex])
817 lowest_opcode[PackageIndex] = defp->pc.proc_opcodenum;
818 if (defp->pc.proc_opcodenum > highest_opcode[PackageIndex])
819 highest_opcode[PackageIndex] = defp->pc.proc_opcodenum;
820 if (defp->pc.proc_opcodenum > master_highest_opcode)
821 master_highest_opcode = defp->pc.proc_opcodenum;
822 opcodesnotallowed[PackageIndex] = 1; /* force it */
823 }
824 no_of_opcodes[PackageIndex]++, master_no_of_opcodes++;
825 if (proc_multi) {
826 generate_code(defp, 0, 1);
827 if (Cflag || cflag) {
828 generate_code(defp, 1, 1);
829 }
830 generate_multi_macros(defp);
831 } else {
832 generate_code(defp, proc_split, 0);
833 }
834
835 if (function_list_index >= MAX_FUNCTIONS_PER_INTERFACE(500 * 10)) {
836 error("too many functions in interface, "
837 "increase MAX_FUNCTIONS_PER_INTERFACE");
838 }
839 sprintf(function_list[PackageIndex][function_list_index], "%s%s%s",
840 prefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
841
842 function_list_index++;
843 no_of_stat_funcs_header[PackageIndex]++;
844 no_of_stat_funcs++;
845 *Proc_listp = NULL((void *)0);
846}
847
848
849#define LEGALNUMS"0123456789" "0123456789"
850static int
851InvalidConstant(char *name)
852{
853 char *map;
854 int slen;
855
856 map = LEGALNUMS"0123456789";
857 slen = (int)strlen(name);
858 return (slen != strspn(name, map));
859}
860
861static int
862opcodenum_is_defined(int opcode_num)
863{
864 list *listp;
865 definition *defp;
866
867 for (listp = proc_defined[PackageIndex]; listp != NULL((void *)0);
868 listp = listp->next) {
869 defp = (definition *) listp->val;
870 if (opcode_num == defp->pc.proc_opcodenum)
871 return 1;
872 }
873 return 0;
874}
875
876
877static void
878analyze_ProcParams(definition * defp, token * tokp)
879{
880 declaration dec;
881 decl_list *decls, **tailp;
882
883 Proc_listp = &defp->pc.plists;
884 tailp = &defp->def.st.decls;
885 do {
886 get_token(tokp);
887 Proc_list = ALLOC(proc1_list)(proc1_list *) malloc(sizeof(proc1_list));
888 memset(Proc_list, 0, sizeof(proc1_list));
889 Proc_list->pl.param_flag = 0;
890 switch (tokp->kind) {
891 case TOK_IN:
892 hdle_param_tok(defp, &dec, tokp, DEF_INPARAM);
893 break;
894 case TOK_OUT:
895 hdle_param_tok(defp, &dec, tokp, DEF_OUTPARAM);
896 break;
897 case TOK_INOUT:
898 hdle_param_tok(defp, &dec, tokp, DEF_INOUTPARAM);
899 break;
900 case TOK_RPAREN:
901 break;
902 default:
903 unget_token(tokp);
904 hdle_param_tok(defp, &dec, tokp, DEF_NULL);
905 break;
906 }
907 *Proc_listp = Proc_list;
908 Proc_listp = &Proc_list->next;
909 decls = ALLOC(decl_list)(decl_list *) malloc(sizeof(decl_list));
910 memset(decls, 0, sizeof(decl_list));
911 if (tokp->kind != TOK_RPAREN)
912 decls->decl = dec;
913 *tailp = decls;
914 tailp = &decls->next;
915 } while (tokp->kind != TOK_RPAREN);
916 *tailp = NULL((void *)0);
917}
918
919
920static void
921generate_code(definition * defp, int proc_split_flag, int multi_flag)
922{
923 if (proc_split_flag)
924 handle_split_proc(defp, multi_flag);
925 else {
926 if (Cflag || cflag) {
927 cs_Proc_CodeGeneration(defp, 0, "");
928 }
929 if (Sflag || cflag)
930 ss_Proc_CodeGeneration(defp);
931 }
932 if (Sflag || (cflag && xflag && !proc_split_flag))
933 STOREVAL(&proc_defined[PackageIndex], defp)storeval(&proc_defined[PackageIndex],(char *)defp);
934}
935
936
937static void
938handle_split_proc(definition * defp, int multi_flag)
939{
940 char *startname = SplitStart, *endname = SplitEnd;
941 int numofparams = 0;
942
943 if (!startname)
944 startname = "Start";
945 if (!endname)
946 endname = "End";
947 if (Cflag || cflag) {
948 if (!cflag) {
949 do_split(defp, OUT1, &numofparams, DEF_OUTPARAM, 0);
950 }
951 cs_Proc_CodeGeneration(defp, 1, startname);
952 if (!cflag) {
953 do_split(defp, OUT1, &numofparams, DEF_OUTPARAM, 1);
954 do_split(defp, IN0, &numofparams, DEF_INPARAM, 0);
955 }
956 cs_Proc_CodeGeneration(defp, (multi_flag ? 3 : 2), endname);
957 if (!cflag) {
958 do_split(defp, IN0, &numofparams, DEF_INPARAM, 1);
959 }
960 }
961 if (Sflag || cflag)
962 ss_Proc_CodeGeneration(defp);
963}
964
965
966static void
967do_split(definition * defp, int direction, int *numofparams,
968 defkind param_kind, int restore_flag)
969{
970 proc1_list *plist;
971
972 if (restore_flag) {
973 defp->pc.paramtypes[direction] = *numofparams;
974 for (plist = defp->pc.plists; plist; plist = plist->next) {
975 if (plist->component_kind == DEF_NULL
976 && plist->pl.param_kind == param_kind)
977 plist->component_kind = DEF_PARAM;
978 }
979 } else {
980 *numofparams = defp->pc.paramtypes[direction];
981 defp->pc.paramtypes[direction] = 0;
982 for (plist = defp->pc.plists; plist; plist = plist->next) {
983 if (plist->component_kind == DEF_PARAM
984 && plist->pl.param_kind == param_kind)
985 plist->component_kind = DEF_NULL;
986 }
987 }
988}
989
990
991static void
992hdle_param_tok(definition * defp, declaration * dec, token * tokp,
993 defkind par_kind)
994{
995 static defkind last_param_kind = DEF_NULL;
996
997 if (par_kind == DEF_NULL)
998 Proc_list->pl.param_kind = last_param_kind;
999 else
1000 Proc_list->pl.param_kind = par_kind;
1001 last_param_kind = Proc_list->pl.param_kind;
1002 defp->pc.paramtypes[(int)last_param_kind]++;
1003 Proc_list->component_kind = DEF_PARAM;
1004 Proc_list->code = alloc(250)malloc((unsigned)(250));
1005 Proc_list->scode = alloc(250)malloc((unsigned)(250));
1006 get_declaration(dec, DEF_PARAM);
1007 Proc_list->pl.param_name = dec->name;
1008 get1_param_type(defp, dec, &Proc_list->pl.param_type);
1009 print_param(dec);
1010 scan2(TOK_COMMA, TOK_RPAREN, tokp);
1011 if (tokp->kind == TOK_COMMA)
1012 peek(tokp);
1013}
1014
1015
1016static void
1017get1_param_type(definition * defp, declaration * dec, char **param_type)
1018{
1019 char typecontents[100];
1020
1021 if (streq(dec->type, "string")) {
1022 *param_type = "char *";
1023 } else {
1024 if (dec->prefix) {
1025 strcpy(typecontents, dec->prefix);
1026 strcat(typecontents, " ");
1027 strcat(typecontents, dec->type);
1028 strcat(typecontents, " *");
1029 } else if (dec->rel == REL_POINTER) {
1030 strcpy(typecontents, dec->type);
1031 strcat(typecontents, " *");
1032 } else
1033 strcpy(typecontents, dec->type);
1034 *param_type = alloc(100)malloc((unsigned)(100));
1035 strcpy(*param_type, typecontents);
1036 }
1037}
1038
1039
1040static void
1041get_param_type(definition * defp, declaration * dec, char **param_type,
1042 char **typename)
1043{
1044 char typecontents[100];
1045
1046 if (streq(dec->type, "string")) {
1047 *typename = "wrapstring";
1048 *param_type = "char *";
1049 } else {
1050 *typename = dec->type;
1051 if (dec->prefix) {
1052 strcpy(typecontents, dec->prefix);
1053 strcat(typecontents, " ");
1054 strcat(typecontents, dec->type);
1055 strcat(typecontents, " *");
1056 dec->rel = REL_POINTER;
1057 } else if (dec->rel == REL_POINTER) {
1058 strcpy(typecontents, dec->type);
1059 strcat(typecontents, " *");
1060 } else
1061 strcpy(typecontents, dec->type);
1062 *param_type = alloc(100)malloc((unsigned)(100));
1063 strcpy(*param_type, typecontents);
1064 }
1065}
1066
1067
1068#ifdef undef
1069static void
1070hndle_param_tail(definition * defp, declaration * dec, token * tokp,
1071 char *typename)
1072{
1073 char *amp;
1074
1075 if (dec->rel == REL_POINTER)
1076 Proc_list->pl.param_flag |= INDIRECT_PARAM1;
1077 else
1078 Proc_list->pl.param_flag &= ~INDIRECT_PARAM1;
1079 amp = "";
1080 if (!(Proc_list->pl.param_flag & INDIRECT_PARAM1))
1081 amp = "&";
1082
1083 sprintf(Proc_list->code, "xdr_%s(&z_xdrs, %s%s)", typename, amp,
1084 Proc_list->pl.param_name);
1085 sprintf(Proc_list->scode, "xdr_%s(z_xdrs, &%s)", typename,
1086 Proc_list->pl.param_name);
1087 scan2(TOK_COMMA, TOK_RPAREN, tokp);
1088 if (tokp->kind == TOK_COMMA)
1089 peek(tokp);
1090}
1091#endif
1092
1093
1094static void
1095cs_Proc_CodeGeneration(definition * defp, int split_flag, char *procheader)
1096{
1097 defp->can_fail = 0;
1098 cs_ProcName_setup(defp, procheader, split_flag);
1099 if (!cflag) {
1100 cs_ProcParams_setup(defp, split_flag);
1101 cs_ProcMarshallInParams_setup(defp, split_flag);
1102 if (split_flag != 1) {
1103 cs_ProcSendPacket_setup(defp, split_flag);
1104 cs_ProcUnmarshallOutParams_setup(defp);
1105 }
1106 cs_ProcTail_setup(defp, split_flag);
1107 }
1108
1109 if (!kflag && !split_flag && uflag) {
1110 ucs_ProcName_setup(defp, "ubik_", split_flag);
1111 if (!cflag) {
1112 ucs_ProcParams_setup(defp, split_flag);
1113 ucs_ProcTail_setup(defp, split_flag);
1114 }
1115 }
1116}
1117
1118static void
1119cs_ProcName_setup(definition * defp, char *procheader, int split_flag)
1120{
1121 proc1_list *plist;
1122 char *first_arg;
1123
1124 if (ansic_flag) {
1125 if (split_flag) {
1126 first_arg = "struct rx_call *z_call";
1127 } else {
1128 first_arg = "struct rx_connection *z_conn";
1129 }
1130 } else {
1131 if (split_flag) {
1132 first_arg = "z_call";
1133 } else {
1134 first_arg = "z_conn";
1135 }
1136 }
1137
1138 if (!cflag) {
1139 f_printif (scan_print) (void) fprintf(fout, "int %s%s%s%s(%s", procheader, prefix,
1140 PackagePrefix[PackageIndex], defp->pc.proc_name, first_arg);
1141 }
1142 if ((strlen(procheader) + strlen(prefix) +
1143 strlen(PackagePrefix[PackageIndex]) + strlen(defp->pc.proc_name)) >=
1144 MAX_FUNCTION_NAME_LEN200) {
1145 error("function name is too long, increase MAX_FUNCTION_NAME_LEN");
1146 }
1147 if (!cflag) {
1148 for (plist = defp->pc.plists; plist; plist = plist->next) {
1149 if (plist->component_kind == DEF_PARAM) {
1150 if (ansic_flag) {
1151 if (plist->pl.param_flag & OUT_STRING32) {
1152 f_printif (scan_print) (void) fprintf(fout, ",%s *%s", plist->pl.param_type,
1153 plist->pl.param_name);
1154 } else {
1155 f_printif (scan_print) (void) fprintf(fout, ",%s %s", plist->pl.param_type,
1156 plist->pl.param_name);
1157 }
1158 } else {
1159 f_printif (scan_print) (void) fprintf(fout, ", %s", plist->pl.param_name);
1160 plist->pl.param_flag &= ~PROCESSED_PARAM2;
1161 }
1162 }
1163 }
1164 f_printif (scan_print) (void) fprintf(fout, ")\n");
1165 }
1166}
1167
1168static void
1169cs_ProcParams_setup(definition * defp, int split_flag)
1170{
1171 proc1_list *plist, *plist1;
1172
1173 if (ansic_flag)
1174 return;
1175
1176 if (!split_flag)
1177 f_printif (scan_print) (void) fprintf(fout, "\tstruct rx_connection *z_conn;\n");
1178 if (split_flag) {
1179 f_printif (scan_print) (void) fprintf(fout, "\tstruct rx_call *z_call;\n");
1180 }
1181 for (plist = defp->pc.plists; plist; plist = plist->next) {
1182 if (plist->component_kind == DEF_PARAM
1183 && !(plist->pl.param_flag & PROCESSED_PARAM2)) {
1184 if (plist->pl.param_flag & OUT_STRING32) {
1185 f_printif (scan_print) (void) fprintf(fout, "\t%s *%s", plist->pl.param_type,
1186 plist->pl.param_name);
1187 } else {
1188 f_printif (scan_print) (void) fprintf(fout, "\t%s %s", plist->pl.param_type,
1189 plist->pl.param_name);
1190 }
1191 plist->pl.param_flag |= PROCESSED_PARAM2;
1192 for (plist1 = defp->pc.plists; plist1; plist1 = plist1->next) {
1193 if ((plist1->component_kind == DEF_PARAM)
1194 && streq(plist->pl.param_type, plist1->pl.param_type)
1195 && !(plist1->pl.param_flag & PROCESSED_PARAM2)) {
1196 char *star = "";
1197 char *pntr = strchr(plist1->pl.param_type, '*');
1198 if (pntr)
1199 star = "*";
1200 if (plist1->pl.param_flag & OUT_STRING32) {
1201 f_printif (scan_print) (void) fprintf(fout, ", *%s%s", star, plist1->pl.param_name);
1202 } else {
1203 f_printif (scan_print) (void) fprintf(fout, ", %s%s", star, plist1->pl.param_name);
1204 }
1205 plist1->pl.param_flag |= PROCESSED_PARAM2;
1206 }
1207 }
1208 f_printif (scan_print) (void) fprintf(fout, ";\n");
1209 }
1210 }
1211}
1212
1213
1214static void
1215cs_ProcMarshallInParams_setup(definition * defp, int split_flag)
1216{
1217 int noofparams, i = 0;
1218 proc1_list *plist;
1219 decl_list *dl;
1220 int noofallparams =
1221 defp->pc.paramtypes[IN0] + defp->pc.paramtypes[INOUT2] +
1222 defp->pc.paramtypes[OUT1];
1223
1224 f_printif (scan_print) (void) fprintf(fout, "{\n");
1225 if (!split_flag)
1226 f_printif (scan_print) (void) fprintf(fout, "\tstruct rx_call *z_call = rx_NewCall(z_conn);\n");
1227 if ((!split_flag) || (split_flag == 1)) {
1228 if (opcodesnotallowed[PackageIndex]) {
1229 f_printif (scan_print) (void) fprintf(fout, "\tstatic int z_op = %d;\n",
1230 defp->pc.proc_opcodenum);
1231 } else {
1232 f_printif (scan_print) (void) fprintf(fout, "\tstatic int z_op = %s;\n",
1233 defp->pc.proc_opcodename);
1234 }
1235 }
1236 f_printif (scan_print) (void) fprintf(fout, "\tint z_result;\n");
1237 if (!(split_flag > 1) || (noofallparams != 0)) {
1238 f_printif (scan_print) (void) fprintf(fout, "\tXDR z_xdrs;\n");
1239 }
1240 /*
1241 * Print out client side stat gathering call
1242 */
1243 if (xflag && split_flag != 1) {
1244 f_printif (scan_print) (void) fprintf(fout, "\tstruct clock __QUEUE, __EXEC;\n");
1245 }
1246
1247 if ((!split_flag) || (split_flag == 1)) {
1248 f_printif (scan_print) (void) fprintf(fout, "\txdrrx_create(&z_xdrs, z_call, XDR_ENCODE);\n");
1249 f_printif (scan_print) (void) fprintf(fout, "\n\t/* Marshal the arguments */\n");
1250 f_printif (scan_print) (void) fprintf(fout, "\tif ((!xdr_int(&z_xdrs, &z_op))");
1251 noofparams = defp->pc.paramtypes[IN0] + defp->pc.paramtypes[INOUT2];
1252 for (plist = defp->pc.plists, dl = defp->def.st.decls; plist;
1253 plist = plist->next, dl = dl->next) {
1254 if (plist->component_kind == DEF_PARAM
1255 && (plist->pl.param_kind == DEF_INPARAM
1256 || plist->pl.param_kind == DEF_INOUTPARAM)) {
1257 f_printif (scan_print) (void) fprintf(fout, "\n\t || (!%s)", plist->code);
1258 if (++i == noofparams) {
1259 f_printif (scan_print) (void) fprintf(fout,
1260 ") {\n\t\tz_result = RXGEN_CC_MARSHAL;\n\t\tgoto fail;\n\t}\n\n");
1261 defp->can_fail = 1;
1262 }
1263 }
1264 }
1265 if (!i) {
1266 f_printif (scan_print) (void) fprintf(fout,
1267 ") {\n\t\tz_result = RXGEN_CC_MARSHAL;\n\t\tgoto fail;\n\t}\n\n");
1268 defp->can_fail = 1;
1269 }
1270 }
1271}
1272
1273
1274static void
1275cs_ProcSendPacket_setup(definition * defp, int split_flag)
1276{
1277 int noofoutparams = defp->pc.paramtypes[INOUT2] + defp->pc.paramtypes[OUT1];
1278
1279 if (noofoutparams) {
1280 f_printif (scan_print) (void) fprintf(fout, "\t/* Un-marshal the reply arguments */\n");
1281 if (split_flag) {
1282 f_printif (scan_print) (void) fprintf(fout, "\txdrrx_create(&z_xdrs, z_call, XDR_DECODE);\n");
1283 } else {
1284 f_printif (scan_print) (void) fprintf(fout, "\tz_xdrs.x_op = XDR_DECODE;\n");
1285 }
1286 }
1287}
1288
1289
1290static void
1291cs_ProcUnmarshallOutParams_setup(definition * defp)
1292{
1293 int noofparams, i;
1294 proc1_list *plist;
1295 decl_list *dl;
1296
1297 noofparams = defp->pc.paramtypes[INOUT2] + defp->pc.paramtypes[OUT1];
1298 if (noofparams)
1299 for (plist = defp->pc.plists, dl = defp->def.st.decls, i = 0; plist;
1300 plist = plist->next, dl = dl->next) {
1301 if (plist->component_kind == DEF_PARAM
1302 && (plist->pl.param_kind == DEF_OUTPARAM
1303 || plist->pl.param_kind == DEF_INOUTPARAM)) {
1304 if (!i) {
1305 f_printif (scan_print) (void) fprintf(fout, "\tif ((!%s)", plist->code);
1306 } else {
1307 f_printif (scan_print) (void) fprintf(fout, "\n\t || (!%s)", plist->code);
1308 }
1309 if (++i == noofparams) {
1310 f_printif (scan_print) (void) fprintf(fout,
1311 ") {\n\t\tz_result = RXGEN_CC_UNMARSHAL;\n\t\tgoto fail;\n\t}\n\n");
1312 defp->can_fail = 1;
1313 }
1314 }
1315 }
1316}
1317
1318
1319static void
1320cs_ProcTail_setup(definition * defp, int split_flag)
1321{
1322 f_printif (scan_print) (void) fprintf(fout, "\tz_result = RXGEN_SUCCESS;\n");
1323 if (defp->can_fail) {
1324 f_printif (scan_print) (void) fprintf(fout, "fail:\n");
1325 }
1326 if (!split_flag) {
1327 f_printif (scan_print) (void) fprintf(fout, "\tz_result = rx_EndCall(z_call, z_result);\n");
1328 }
1329 if (xflag && split_flag != 1) {
1330 f_printif (scan_print) (void) fprintf(fout, "\tif (rx_enable_stats) {\n");
1331 f_printif (scan_print) (void) fprintf(fout, "\t clock_GetTime(&__EXEC);\n");
1332 f_printif (scan_print) (void) fprintf(fout, "\t clock_Sub(&__EXEC, &z_call->startTime);\n");
1333 f_printif (scan_print) (void) fprintf(fout, "\t __QUEUE = z_call->startTime;\n");
1334 f_printif (scan_print) (void) fprintf(fout, "\t clock_Sub(&__QUEUE, &z_call->queueTime);\n");
1335 if (PackageStatIndex[PackageIndex]) {
1336 if (!split_flag) {
1337 f_printif (scan_print) (void) fprintf(fout,
1338 "\t rx_IncrementTimeAndCount(z_conn->peer, %s,\n",
1339 PackageStatIndex[PackageIndex]);
1340 } else {
1341 f_printif (scan_print) (void) fprintf(fout,
1342 "\t rx_IncrementTimeAndCount(z_call->conn->peer, %s,\n",
1343 PackageStatIndex[PackageIndex]);
1344 }
1345 } else {
1346 if (!split_flag) {
1347 f_printif (scan_print) (void) fprintf(fout,
1348 "\t rx_IncrementTimeAndCount(z_conn->peer,\n"
1349 "\t\t(((afs_uint32)(ntohs(z_conn->serviceId) << 16)) \n"
1350 "\t\t| ((afs_uint32)ntohs(z_conn->peer->port))),\n");
1351 } else {
1352 f_printif (scan_print) (void) fprintf(fout,
1353 "\t rx_IncrementTimeAndCount(z_call->conn->peer,\n"
1354 "\t\t(((afs_uint32)(ntohs(z_call->conn->serviceId) << 16)) |\n"
1355 "\t\t((afs_uint32)ntohs(z_call->conn->peer->port))),\n");
1356 }
1357 }
1358 if (xflag) {
1359 f_printif (scan_print) (void) fprintf(fout, "\t\t%d, %sNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,\n",
1360 no_of_stat_funcs, PackagePrefix[PackageIndex]);
1361 f_printif (scan_print) (void) fprintf(fout,
1362 "\t\t&z_call->bytesSent, &z_call->bytesRcvd, 1);\n");
1363 }
1364 f_printif (scan_print) (void) fprintf(fout, "\t}\n\n");
1365 }
1366 f_printif (scan_print) (void) fprintf(fout, "\treturn z_result;\n}\n\n");
1367}
1368
1369
1370static void
1371ss_Proc_CodeGeneration(definition * defp)
1372{
1373 int somefrees = 0;
1374
1375 defp->can_fail = 0;
1376 ss_ProcName_setup(defp);
1377 if (!cflag) {
1378 ss_ProcParams_setup(defp, &somefrees);
1379 ss_ProcSpecial_setup(defp, &somefrees);
1380 ss_ProcUnmarshallInParams_setup(defp);
1381 ss_ProcCallRealProc_setup(defp);
1382 ss_ProcMarshallOutParams_setup(defp);
1383 ss_ProcTail_setup(defp, somefrees);
1384 }
1385}
1386
1387
1388static void
1389ss_ProcName_setup(definition * defp)
1390{
1391 proc1_list *plist;
1392
1393 if ((strlen(prefix) + strlen(PackagePrefix[PackageIndex]) +
1394 strlen(defp->pc.proc_name)) >= MAX_FUNCTION_NAME_LEN200) {
1395 error("function name is too long, increase MAX_FUNCTION_NAME_LEN");
1396 }
1397
1398 if (!cflag) {
1399 f_printif (scan_print) (void) fprintf(fout, "static afs_int32 _%s%s%s(", prefix,
1400 PackagePrefix[PackageIndex], defp->pc.proc_name);
1401 f_printif (scan_print) (void) fprintf(fout, "struct rx_call *z_call, XDR *z_xdrs)\n{\n");
1402 f_printif (scan_print) (void) fprintf(fout, "\t" "afs_int32 z_result;\n");
1403 if (xflag) {
1404 f_printif (scan_print) (void) fprintf(fout, "\tstruct clock __QUEUE, __EXEC;\n");
1405 }
1406
1407 for (plist = defp->pc.plists; plist; plist = plist->next)
1408 if (plist->component_kind == DEF_PARAM) {
1409 plist->pl.param_flag &= ~(PROCESSED_PARAM2);
1410 plist->pl.string_name = NULL((void *)0);
1411 }
1412 }
1413}
1414
1415
1416static void
1417ss_ProcParams_setup(definition * defp, int *somefrees)
1418{
1419 proc1_list *plist, *plist1;
1420 list *listp;
1421 definition *defp1;
1422
1423 for (plist = defp->pc.plists; plist; plist = plist->next) {
1
Loop condition is true. Entering loop body
3
Loop condition is true. Entering loop body
5
Loop condition is true. Entering loop body
1424 if ((plist->component_kind == DEF_PARAM)
2
Taking false branch
4
Taking false branch
6
Taking true branch
1425 && !(plist->pl.param_flag & PROCESSED_PARAM2)) {
1426 if (plist->pl.param_flag & INDIRECT_PARAM1) {
7
Taking true branch
1427 char pres = '\0', *pntr = strchr(plist->pl.param_type, '*');
1428 if (pntr) {
8
Taking false branch
1429 --pntr;
1430 pres = *pntr;
1431 *pntr = (char)0;
1432 }
1433 f_printif (scan_print) (void) fprintf(fout, "\t%s %s", plist->pl.param_type,
1434 plist->pl.param_name);
1435 *pntr = pres;
9
Dereference of null pointer (loaded from variable 'pntr')
1436 } else if (strchr(plist->pl.param_type, '*') == 0) {
1437 f_printif (scan_print) (void) fprintf(fout, "\t%s %s", plist->pl.param_type,
1438 plist->pl.param_name);
1439 } else {
1440 plist->pl.param_flag |= FREETHIS_PARAM16;
1441 *somefrees = 1;
1442 f_printif (scan_print) (void) fprintf(fout, "\t%s %s=(%s)0", plist->pl.param_type,
1443 plist->pl.param_name, plist->pl.param_type);
1444 }
1445 plist->pl.param_flag |= PROCESSED_PARAM2;
1446 for (plist1 = defp->pc.plists; plist1; plist1 = plist1->next) {
1447 if ((plist1->component_kind == DEF_PARAM)
1448 && streq(plist->pl.param_type, plist1->pl.param_type)
1449 && !(plist1->pl.param_flag & PROCESSED_PARAM2)) {
1450 if (plist1->pl.param_flag & INDIRECT_PARAM1) {
1451 f_printif (scan_print) (void) fprintf(fout, ", %s", plist1->pl.param_name);
1452 } else if (strchr(plist1->pl.param_type, '*') == 0) {
1453 f_printif (scan_print) (void) fprintf(fout, ", %s", plist1->pl.param_name);
1454 } else {
1455 plist1->pl.param_flag |= FREETHIS_PARAM16;
1456 *somefrees = 1;
1457 f_printif (scan_print) (void) fprintf(fout, ", *%s=(%s)0", plist1->pl.param_name,
1458 plist1->pl.param_type);
1459 }
1460 plist1->pl.param_flag |= PROCESSED_PARAM2;
1461 }
1462 }
1463 f_printif (scan_print) (void) fprintf(fout, ";\n");
1464 }
1465 }
1466 for (listp = typedef_defined; listp != NULL((void *)0); listp = listp->next) {
1467 defp1 = (definition *) listp->val;
1468 for (plist = defp->pc.plists; plist; plist = plist->next) {
1469 if (plist->component_kind == DEF_PARAM
1470 && (plist->pl.param_kind == DEF_OUTPARAM
1471 || plist->pl.param_kind == DEF_INOUTPARAM)
1472 && !(plist->pl.param_flag & FREETHIS_PARAM16)) {
1473 if (streq(defp1->def_name, structname(plist->pl.param_type))) {
1474 switch (defp1->pc.rel) {
1475 case REL_ARRAY:
1476 case REL_POINTER:
1477 default:
1478 break;
1479 }
1480 }
1481 }
1482 }
1483 }
1484 fprintf(fout, "\n");
1485}
1486
1487
1488static void
1489ss_ProcSpecial_setup(definition * defp, int *somefrees)
1490{
1491 proc1_list *plist;
1492 definition *defp1;
1493 list *listp;
1494
1495 for (listp = special_defined; listp != NULL((void *)0); listp = listp->next) {
1496 defp1 = (definition *) listp->val;
1497
1498 for (plist = defp->pc.plists; plist; plist = plist->next) {
1499 if (plist->component_kind == DEF_PARAM
1500 && (plist->pl.param_kind == DEF_INPARAM
1501 || plist->pl.param_kind == DEF_INOUTPARAM)) {
1502 spec_list *spec = defp1->def.sd.specs;
1503 char string[40];
1504 strcpy(string, structname(spec->sdef.string_value));
1505 if (streq(string, structname(plist->pl.param_type))) {
1506 plist->pl.string_name = spec->sdef.string_name;
1507 plist->pl.param_flag |= FREETHIS_PARAM16;
1508 *somefrees = 1;
1509 fprintf(fout, "\n\t%s.%s = 0;", plist->pl.param_name,
1510 spec->sdef.string_name);
1511 }
1512 }
1513 }
1514 }
1515 if (!*somefrees)
1516 fprintf(fout, "\n");
1517 for (listp = typedef_defined; listp != NULL((void *)0); listp = listp->next) {
1518 defp1 = (definition *) listp->val;
1519 for (plist = defp->pc.plists; plist; plist = plist->next) {
1520 if (plist->component_kind == DEF_PARAM) {
1521 if (streq(defp1->def_name, structname(plist->pl.param_type))) {
1522 plist->pl.param_flag |= FREETHIS_PARAM16;
1523 *somefrees = 1;
1524 switch (defp1->pc.rel) {
1525 case REL_ARRAY:
1526 plist->pl.string_name = alloc(40)malloc((unsigned)(40));
1527 if (brief_flag) {
1528 f_printif (scan_print) (void) fprintf(fout, "\n\t%s.val = 0;",
1529 plist->pl.param_name);
1530 f_printif (scan_print) (void) fprintf(fout, "\n\t%s.len = 0;",
1531 plist->pl.param_name);
1532 s_print(void) sprintf(plist->pl.string_name, "val");
1533 } else {
1534 f_printif (scan_print) (void) fprintf(fout, "\n\t%s.%s_val = 0;",
1535 plist->pl.param_name, defp1->def_name);
1536 f_printif (scan_print) (void) fprintf(fout, "\n\t%s.%s_len = 0;",
1537 plist->pl.param_name, defp1->def_name);
1538 s_print(void) sprintf(plist->pl.string_name, "%s_val",
1539 defp1->def_name);
1540 }
1541 break;
1542 case REL_POINTER:
1543 f_printif (scan_print) (void) fprintf(fout, "\n\t%s = 0;", plist->pl.param_name);
1544 plist->pl.string_name = NULL((void *)0);
1545 break;
1546 default:
1547 break;
1548 }
1549 }
1550 }
1551 }
1552 }
1553 for (listp = complex_defined; listp != NULL((void *)0); listp = listp->next) {
1554 defp1 = (definition *) listp->val;
1555 for (plist = defp->pc.plists; plist; plist = plist->next) {
1556 if (plist->component_kind == DEF_PARAM) {
1557 if (streq(defp1->def_name, structname(plist->pl.param_type))) {
1558 plist->pl.param_flag |= FREETHIS_PARAM16;
1559 *somefrees = 1;
1560 fprintf(fout, "\n\tmemset(&%s, 0, sizeof(%s));",
1561 plist->pl.param_name, defp1->def_name);
1562 }
1563 }
1564 }
1565 }
1566
1567 f_printif (scan_print) (void) fprintf(fout, "\n");
1568}
1569
1570
1571static void
1572ss_ProcUnmarshallInParams_setup(definition * defp)
1573{
1574 int noofparams, noofoutparams, i;
1575 proc1_list *plist;
1576
1577 noofparams = defp->pc.paramtypes[IN0] + defp->pc.paramtypes[INOUT2];
1578 noofoutparams = defp->pc.paramtypes[INOUT2] + defp->pc.paramtypes[OUT1];
1579 for (plist = defp->pc.plists, i = 0; plist; plist = plist->next) {
1580 if (plist->component_kind == DEF_PARAM
1581 && (plist->pl.param_kind == DEF_INPARAM
1582 || plist->pl.param_kind == DEF_INOUTPARAM)) {
1583 if (!i) {
1584 f_printif (scan_print) (void) fprintf(fout, "\n\tif ((!%s)",
1585 (plist->scode ? plist->scode : plist->code));
1586 } else {
1587 f_printif (scan_print) (void) fprintf(fout, "\n\t || (!%s)",
1588 (plist->scode ? plist->scode : plist->code));
1589 }
1590 if (++i == noofparams) {
1591 if (!noofoutparams) {
1592 f_printif (scan_print) (void) fprintf(fout, ") {\n");
1593 } else {
1594 f_printif (scan_print) (void) fprintf(fout, ") {\n");
1595 }
1596 f_printif (scan_print) (void) fprintf(fout,
1597 "\t\tz_result = RXGEN_SS_UNMARSHAL;\n\t\tgoto fail;\n\t}\n\n");
1598 defp->can_fail = 1;
1599 }
1600 }
1601 }
1602}
1603
1604
1605static void
1606ss_ProcCallRealProc_setup(definition * defp)
1607{
1608 extern char zflag;
1609 proc1_list *plist;
1610
1611 f_printif (scan_print) (void) fprintf(fout, "\tz_result = %s%s%s%s(z_call", prefix, ServerPrefix,
1612 PackagePrefix[PackageIndex], defp->pc.proc_name);
1613 for (plist = defp->pc.plists; plist; plist = plist->next) {
1614 if (plist->component_kind == DEF_PARAM) {
1615 if (plist->pl.param_flag & INDIRECT_PARAM1) {
1616 f_printif (scan_print) (void) fprintf(fout, ", &%s", plist->pl.param_name);
1617 } else {
1618 if (plist->pl.param_flag & OUT_STRING32) {
1619 f_printif (scan_print) (void) fprintf(fout, ", &%s", plist->pl.param_name);
1620 } else {
1621 f_printif (scan_print) (void) fprintf(fout, ", %s", plist->pl.param_name);
1622 }
1623 }
1624 }
1625 }
1626 f_printif (scan_print) (void) fprintf(fout, ");\n");
1627 if (zflag) {
1628 f_printif (scan_print) (void) fprintf(fout, "\tif (z_result)\n\t\treturn z_result;\n");
1629 }
1630}
1631
1632
1633static void
1634ss_ProcMarshallOutParams_setup(definition * defp)
1635{
1636 proc1_list *plist;
1637 int noofparams, i;
1638
1639 noofparams = defp->pc.paramtypes[INOUT2] + defp->pc.paramtypes[OUT1];
1640 if (noofparams)
1641 f_printif (scan_print) (void) fprintf(fout, "\tz_xdrs->x_op = XDR_ENCODE;\n");
1642 if (noofparams) {
1643 for (plist = defp->pc.plists, i = 0; plist; plist = plist->next) {
1644 if (plist->component_kind == DEF_PARAM
1645 && (plist->pl.param_kind == DEF_OUTPARAM
1646 || plist->pl.param_kind == DEF_INOUTPARAM)) {
1647 if (!i) {
1648 f_printif (scan_print) (void) fprintf(fout, "\tif ((!%s)",
1649 (plist->scode ? plist->scode : plist->code));
1650 } else {
1651 f_printif (scan_print) (void) fprintf(fout, "\n\t || (!%s)",
1652 (plist->scode ? plist->scode : plist->code));
1653 }
1654 if (++i == noofparams) {
1655 f_printif (scan_print) (void) fprintf(fout, ")\n\t\tz_result = RXGEN_SS_MARSHAL;\n");
1656 }
1657 }
1658 }
1659 }
1660}
1661
1662
1663static void
1664ss_ProcTail_setup(definition * defp, int somefrees)
1665{
1666 proc1_list *plist;
1667 definition *defp1;
1668 list *listp;
1669 int firsttime = 0;
1670
1671 if (defp->can_fail) {
1672 f_printif (scan_print) (void) fprintf(fout, "fail:\n");
1673 }
1674 for (plist = defp->pc.plists; plist; plist = plist->next) {
1675 if (plist->component_kind == DEF_PARAM
1676 && (plist->pl.param_flag & FREETHIS_PARAM16))
1677 somefrees = 1;
1678 }
1679 if (somefrees)
1680 f_printif (scan_print) (void) fprintf(fout, "\tz_xdrs->x_op = XDR_FREE;\n");
1681 for (plist = defp->pc.plists; plist; plist = plist->next) {
1682 if (plist->component_kind == DEF_PARAM
1683 && (plist->pl.param_flag & FREETHIS_PARAM16))
1684 f_printif (scan_print) (void) fprintf(fout, "\tif (!%s) goto fail1;\n", plist->scode);
1685 }
1686 for (listp = typedef_defined; listp != NULL((void *)0); listp = listp->next) {
1687 defp1 = (definition *) listp->val;
1688 for (plist = defp->pc.plists; plist; plist = plist->next) {
1689 if (plist->component_kind == DEF_PARAM
1690 && (plist->pl.param_kind == DEF_OUTPARAM
1691 || plist->pl.param_kind == DEF_INOUTPARAM)
1692 && !(plist->pl.param_flag & FREETHIS_PARAM16)) {
1693 if (streq(defp1->def_name, structname(plist->pl.param_type))) {
1694 switch (defp1->pc.rel) {
1695 case REL_ARRAY:
1696 case REL_POINTER:
1697 if (!somefrees && !firsttime) {
1698 firsttime = 1;
1699 f_printif (scan_print) (void) fprintf(fout, "\tz_xdrs->x_op = XDR_FREE;\n");
1700 }
1701 somefrees = 1;
1702 f_printif (scan_print) (void) fprintf(fout, "\tif (!%s) goto fail1;\n",
1703 plist->scode);
1704 break;
1705 default:
1706 break;
1707 }
1708 }
1709 }
1710 }
1711 }
1712 for (listp = uniondef_defined; listp != NULL((void *)0); listp = listp->next) {
1713 defp1 = (definition *) listp->val;
1714 for (plist = defp->pc.plists; plist; plist = plist->next) {
1715 if (plist->component_kind == DEF_PARAM
1716 && (plist->pl.param_kind == DEF_OUTPARAM
1717 || plist->pl.param_kind == DEF_INOUTPARAM)
1718 && !(plist->pl.param_flag & FREETHIS_PARAM16)) {
1719 if (streq(defp1->def_name, structname(plist->pl.param_type))) {
1720 if (plist->pl.param_flag & INDIRECT_PARAM1) {
1721 if (!somefrees && !firsttime) {
1722 firsttime = 1;
1723 f_printif (scan_print) (void) fprintf(fout, "\tz_xdrs->x_op = XDR_FREE;\n");
1724 }
1725 somefrees = 1;
1726 f_printif (scan_print) (void) fprintf(fout, "\tif (!%s) goto fail1;\n",
1727 plist->scode);
1728 }
1729 }
1730 }
1731 }
1732 }
1733
1734 if (xflag) {
1735 f_printif (scan_print) (void) fprintf(fout, "\tif (rx_enable_stats) {\n");
1736 f_printif (scan_print) (void) fprintf(fout, "\t clock_GetTime(&__EXEC);\n");
1737 f_printif (scan_print) (void) fprintf(fout, "\t clock_Sub(&__EXEC, &z_call->startTime);\n");
1738 f_printif (scan_print) (void) fprintf(fout, "\t __QUEUE = z_call->startTime;\n");
1739 f_printif (scan_print) (void) fprintf(fout, "\t clock_Sub(&__QUEUE, &z_call->queueTime);\n");
1740 f_printif (scan_print) (void) fprintf(fout, "\t rx_IncrementTimeAndCount(z_call->conn->peer,");
1741 if (PackageStatIndex[PackageIndex]) {
1742 f_printif (scan_print) (void) fprintf(fout, " %s,\n", PackageStatIndex[PackageIndex]);
1743 } else {
1744 f_printif (scan_print) (void) fprintf(fout,
1745 "\n\t\t(((afs_uint32)(ntohs(z_call->conn->serviceId) << 16)) |\n"
1746 "\t\t((afs_uint32)ntohs(z_call->conn->service->servicePort))),\n");
1747 }
1748 f_printif (scan_print) (void) fprintf(fout, "\t\t%d, %sNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,\n",
1749 no_of_stat_funcs, PackagePrefix[PackageIndex]);
1750 f_printif (scan_print) (void) fprintf(fout, "\t\t&z_call->bytesSent, &z_call->bytesRcvd, 0);\n");
1751 f_printif (scan_print) (void) fprintf(fout, "\t}\n\n");
1752 }
1753
1754 f_printif (scan_print) (void) fprintf(fout, "\treturn z_result;\n");
1755 if (somefrees) {
1756 f_printif (scan_print) (void) fprintf(fout, "fail1:\n");
1757
1758 if (xflag) {
1759 f_printif (scan_print) (void) fprintf(fout, "\tif (rx_enable_stats) {\n");
1760 f_printif (scan_print) (void) fprintf(fout, "\t clock_GetTime(&__EXEC);\n");
1761 f_printif (scan_print) (void) fprintf(fout, "\t clock_Sub(&__EXEC, &z_call->startTime);\n");
1762 f_printif (scan_print) (void) fprintf(fout, "\t __QUEUE = z_call->startTime;\n");
1763 f_printif (scan_print) (void) fprintf(fout, "\t clock_Sub(&__QUEUE, &z_call->queueTime);\n");
1764 f_printif (scan_print) (void) fprintf(fout,
1765 "\t rx_IncrementTimeAndCount(z_call->conn->peer,");
1766 if (PackageStatIndex[PackageIndex]) {
1767 f_printif (scan_print) (void) fprintf(fout, " %s,\n", PackageStatIndex[PackageIndex]);
1768 } else {
1769 f_printif (scan_print) (void) fprintf(fout,
1770 "\n\t\t(((afs_uint32)(ntohs(z_call->conn->serviceId) << 16)) |\n"
1771 "\t\t((afs_uint32)ntohs(z_call->conn->service->servicePort))),\n");
1772 }
1773 f_printif (scan_print) (void) fprintf(fout, "\t\t%d, %sNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,\n",
1774 no_of_stat_funcs, PackagePrefix[PackageIndex]);
1775 f_printif (scan_print) (void) fprintf(fout,
1776 "\t\t&z_call->bytesSent, &z_call->bytesRcvd, 0);\n");
1777 f_printif (scan_print) (void) fprintf(fout, "\t}\n\n");
1778 }
1779
1780 f_printif (scan_print) (void) fprintf(fout, "\treturn RXGEN_SS_XDRFREE;\n}\n\n");
1781 } else {
1782 f_printif (scan_print) (void) fprintf(fout, "}\n\n");
1783 }
1784}
1785
1786
1787static void
1788ucs_ProcName_setup(definition * defp, char *procheader, int split_flag)
1789{
1790 proc1_list *plist;
1791
1792 if (!cflag) {
1793 if (ansic_flag) {
1794 f_printif (scan_print) (void) fprintf(fout, "int %s%s%s%s(struct ubik_client *aclient, afs_int32 aflags",
1795 procheader, prefix, PackagePrefix[PackageIndex],
1796 defp->pc.proc_name);
1797 } else {
1798 f_printif (scan_print) (void) fprintf(fout, "int %s%s%s%s(aclient, aflags", procheader, prefix,
1799 PackagePrefix[PackageIndex], defp->pc.proc_name);
1800 }
1801 }
1802 if ((strlen(procheader) + strlen(prefix) +
1803 strlen(PackagePrefix[PackageIndex]) + strlen(defp->pc.proc_name)) >=
1804 MAX_FUNCTION_NAME_LEN200) {
1805 error("function name is too long, increase MAX_FUNCTION_NAME_LEN");
1806 }
1807 if (!cflag) {
1808 for (plist = defp->pc.plists; plist; plist = plist->next) {
1809 if (plist->component_kind == DEF_PARAM) {
1810 if (ansic_flag) {
1811 if (plist->pl.param_flag & OUT_STRING32) {
1812 f_printif (scan_print) (void) fprintf(fout, ",%s *%s", plist->pl.param_type,
1813 plist->pl.param_name);
1814 } else {
1815 f_printif (scan_print) (void) fprintf(fout, ",%s %s", plist->pl.param_type,
1816 plist->pl.param_name);
1817 }
1818 } else {
1819 plist->pl.param_flag &= ~PROCESSED_PARAM2;
1820 f_printif (scan_print) (void) fprintf(fout, ", %s", plist->pl.param_name);
1821 }
1822 }
1823 }
1824 f_printif (scan_print) (void) fprintf(fout, ")\n");
1825 }
1826}
1827
1828
1829static void
1830ucs_ProcParams_setup(definition * defp, int split_flag)
1831{
1832 proc1_list *plist, *plist1;
1833
1834 if (ansic_flag)
1835 return;
1836
1837 f_printif (scan_print) (void) fprintf(fout, "\tstruct ubik_client *aclient;\n\tafs_int32 aflags;\n");
1838 for (plist = defp->pc.plists; plist; plist = plist->next) {
1839 if (plist->component_kind == DEF_PARAM
1840 && !(plist->pl.param_flag & PROCESSED_PARAM2)) {
1841 if (plist->pl.param_flag & OUT_STRING32) {
1842 f_printif (scan_print) (void) fprintf(fout, "\t%s *%s", plist->pl.param_type,
1843 plist->pl.param_name);
1844 } else {
1845 f_printif (scan_print) (void) fprintf(fout, "\t%s %s", plist->pl.param_type,
1846 plist->pl.param_name);
1847 }
1848 plist->pl.param_flag |= PROCESSED_PARAM2;
1849 for (plist1 = defp->pc.plists; plist1; plist1 = plist1->next) {
1850 if ((plist1->component_kind == DEF_PARAM)
1851 && streq(plist->pl.param_type, plist1->pl.param_type)
1852 && !(plist1->pl.param_flag & PROCESSED_PARAM2)) {
1853 char *star = "";
1854 char *pntr = strchr(plist1->pl.param_type, '*');
1855 if (pntr)
1856 star = "*";
1857 if (plist1->pl.param_flag & OUT_STRING32) {
1858 f_printif (scan_print) (void) fprintf(fout, ", *%s%s", star, plist1->pl.param_name);
1859 } else {
1860 f_printif (scan_print) (void) fprintf(fout, ", %s%s", star, plist1->pl.param_name);
1861 }
1862 plist1->pl.param_flag |= PROCESSED_PARAM2;
1863 }
1864 }
1865 f_printif (scan_print) (void) fprintf(fout, ";\n");
1866 }
1867 }
1868}
1869
1870static void
1871ucs_ProcTail_setup(definition * defp, int split_flag)
1872{
1873 proc1_list *plist;
1874
1875 f_printif (scan_print) (void) fprintf(fout, "{\tafs_int32 rcode, code, newHost, thisHost, i, _ucount;\n");
1876 f_printif (scan_print) (void) fprintf(fout, "\tint chaseCount, pass, needsync;\n");
1877#if 0 /* goes with block below */
1878 f_printif (scan_print) (void) fprintf(fout, "\tint j, inlist;\n");
1879#endif
1880 f_printif (scan_print) (void) fprintf(fout, "\tstruct rx_connection *tc;\n");
1881 f_printif (scan_print) (void) fprintf(fout, "\tstruct rx_peer *rxp;\n");
1882 f_printif (scan_print) (void) fprintf(fout, "\tshort origLevel;\n\n");
1883 f_printif (scan_print) (void) fprintf(fout, "\tif (!aclient)\n");
1884 f_printif (scan_print) (void) fprintf(fout, "\t\treturn UNOENT;\n");
1885 f_printif (scan_print) (void) fprintf(fout, "\tLOCK_UBIK_CLIENT(aclient);\n\n");
1886 f_printif (scan_print) (void) fprintf(fout, "\t restart:\n");
1887 f_printif (scan_print) (void) fprintf(fout, "\torigLevel = aclient->initializationState;\n");
1888 f_printif (scan_print) (void) fprintf(fout, "\trcode = UNOSERVERS;\n");
1889 f_printif (scan_print) (void) fprintf(fout, "\tchaseCount = needsync = 0;\n\n");
1890#if 0 /* We should do some sort of caching algorithm for this, but I need to think about it - shadow 26 jun 06 */
1891 f_printif (scan_print) (void) fprintf(fout, "\tinlist = 0;\n");
1892 f_printif (scan_print) (void) fprintf(fout, "\tLOCK_UCLNT_CACHE;\n");
1893 f_printif (scan_print) (void) fprintf(fout, "\tfor (j = 0; ((j < SYNCCOUNT) && calls_needsync[j]); j++) {\n");
1894 f_printif (scan_print) (void) fprintf(fout, "\t\tif (calls_needsync[j] == (int *)%s%s%s) {\n", prefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
1895 f_printif (scan_print) (void) fprintf(fout, "\t\t\tinlist = needsync = 1;\n");
1896 f_printif (scan_print) (void) fprintf(fout, "\t\t\tbreak;\n");
1897 f_printif (scan_print) (void) fprintf(fout, "\t\t}\n");
1898 f_printif (scan_print) (void) fprintf(fout, "\t}\n");
1899 f_printif (scan_print) (void) fprintf(fout, "\tUNLOCK_UCLNT_CACHE;\n");
1900#endif
1901 f_printif (scan_print) (void) fprintf(fout, "\t/* \n\t* First pass, we try all servers that are up.\n\t* Second pass, we try all servers.\n\t*/\n");
1902 f_printif (scan_print) (void) fprintf(fout, "\tfor (pass = 0; pass < 2; pass++) { /*p */\n");
1903 f_printif (scan_print) (void) fprintf(fout, "\t\t/* For each entry in our servers list */\n");
1904 f_printif (scan_print) (void) fprintf(fout, "\t\tfor (_ucount = 0;; _ucount++) { /*s */\n\n");
1905 f_printif (scan_print) (void) fprintf(fout, "\t\tif (needsync) {\n");
1906 f_printif (scan_print) (void) fprintf(fout, "\t\t\t/* Need a sync site. Lets try to quickly find it */\n");
1907 f_printif (scan_print) (void) fprintf(fout, "\t\t\tif (aclient->syncSite) {\n");
1908 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tnewHost = aclient->syncSite; /* already in network order */\n");
1909 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\taclient->syncSite = 0; /* Will reset if it works */\n");
1910 f_printif (scan_print) (void) fprintf(fout, "\t\t\t} else if (aclient->conns[3]) {\n");
1911 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t/* If there are fewer than four db servers in a cell,\n");
1912 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t* there's no point in making the GetSyncSite call.\n");
1913 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t* At best, it's a wash. At worst, it results in more\n");
1914 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t* RPCs than you would otherwise make.\n");
1915 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t*/\n");
1916 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\ttc = aclient->conns[_ucount];\n");
1917 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tif (tc && rx_ConnError(tc)) {\n");
1918 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\taclient->conns[_ucount] = tc = ubik_RefreshConn(tc);\n");
1919 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t}\n");
1920 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tif (!tc)\n");
1921 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\tbreak;\n");
1922 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tcode = VOTE_GetSyncSite(tc, &newHost);\n");
1923 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tif (aclient->initializationState != origLevel)\n");
1924 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\tgoto restart; /* somebody did a ubik_ClientInit */\n");
1925 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tif (code)\n");
1926 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\tnewHost = 0;\n");
1927 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tnewHost = htonl(newHost); /* convert to network order */\n");
1928 f_printif (scan_print) (void) fprintf(fout, "\t\t\t} else {\n");
1929 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tnewHost = 0;\n");
1930 f_printif (scan_print) (void) fprintf(fout, "\t\t\t}\n");
1931 f_printif (scan_print) (void) fprintf(fout, "\t\t\tif (newHost) {\n");
1932 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t/* position count at the appropriate slot in the client\n");
1933 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t* structure and retry. If we can't find in slot, we'll\n");
1934 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t* just continue through the whole list \n");
1935 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t*/\n");
1936 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tfor (i = 0; i < MAXSERVERS && aclient->conns[i]; i++) {\n");
1937 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\trxp = rx_PeerOf(aclient->conns[i]);\n");
1938 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\tthisHost = rx_HostOf(rxp);\n");
1939 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\tif (!thisHost)\n");
1940 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\t\tbreak;\n");
1941 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\tif (thisHost == newHost) {\n");
1942 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\t\tif (chaseCount++ > 2)\n");
1943 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\t\t\tbreak; /* avoid loop asking */\n");
1944 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\t\t_ucount = i; /* this index is the sync site */\n");
1945 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\t\tbreak;\n");
1946 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n");
1947 f_printif (scan_print) (void) fprintf(fout, "\t\t/*needsync */\n");
1948 f_printif (scan_print) (void) fprintf(fout, "\t\ttc = aclient->conns[_ucount];\n");
1949 f_printif (scan_print) (void) fprintf(fout, "\t\tif (tc && rx_ConnError(tc)) {\n");
1950 f_printif (scan_print) (void) fprintf(fout, "\t\t\taclient->conns[_ucount] = tc = ubik_RefreshConn(tc);\n");
1951 f_printif (scan_print) (void) fprintf(fout, "\t\t}\n");
1952 f_printif (scan_print) (void) fprintf(fout, "\t\tif (!tc)\n");
1953 f_printif (scan_print) (void) fprintf(fout, "\t\t\tbreak;\n\n");
1954 f_printif (scan_print) (void) fprintf(fout, "\t\tif ((pass == 0) && (aclient->states[_ucount] & CFLastFailed)) {\n");
1955 f_printif (scan_print) (void) fprintf(fout, "\t\t\tcontinue; /* this guy's down */\n");
1956 f_printif (scan_print) (void) fprintf(fout, "\t\t}\n");
1957
1958 f_printif (scan_print) (void) fprintf(fout, "\t\trcode = %s%s%s(tc\n", prefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
1959 for (plist = defp->pc.plists; plist; plist = plist->next) {
1960 if (plist->component_kind == DEF_PARAM) {
1961 plist->pl.param_flag &= ~PROCESSED_PARAM2;
1962 f_printif (scan_print) (void) fprintf(fout, ", %s", plist->pl.param_name);
1963 }
1964 }
1965 f_printif (scan_print) (void) fprintf(fout, ");\n");
1966 f_printif (scan_print) (void) fprintf(fout, "\t\tif (aclient->initializationState != origLevel) {\n");
1967 f_printif (scan_print) (void) fprintf(fout, "\t\t\t/* somebody did a ubik_ClientInit */\n");
1968 f_printif (scan_print) (void) fprintf(fout, "\t\t\tif (rcode)\n");
1969 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tgoto restart; /* call failed */\n");
1970 f_printif (scan_print) (void) fprintf(fout, "\t\t\telse\n");
1971 f_printif (scan_print) (void) fprintf(fout, "\t\t\t\tgoto done; /* call suceeded */\n");
1972 f_printif (scan_print) (void) fprintf(fout, "\t\t}\n");
1973 f_printif (scan_print) (void) fprintf(fout, "\t\tif (rcode < 0) { /* network errors */\n");
1974 f_printif (scan_print) (void) fprintf(fout, "\t\t\taclient->states[_ucount] |= CFLastFailed; /* Mark server down */\n");
1975 f_printif (scan_print) (void) fprintf(fout, "\t\t} else if (rcode == UNOTSYNC) {\n");
1976 f_printif (scan_print) (void) fprintf(fout, "\t\t\tneedsync = 1;\n");
1977 f_printif (scan_print) (void) fprintf(fout, "\t\t} else if (rcode != UNOQUORUM) {\n");
1978 f_printif (scan_print) (void) fprintf(fout, "\t\t\t/* either misc ubik code, or misc appl code, or success. */\n");
1979 f_printif (scan_print) (void) fprintf(fout, "\t\t\taclient->states[_ucount] &= ~CFLastFailed; /* mark server up*/\n");
1980 f_printif (scan_print) (void) fprintf(fout, "\t\t\tgoto done; /* all done */\n");
1981 f_printif (scan_print) (void) fprintf(fout, "\t\t}\n");
1982 f_printif (scan_print) (void) fprintf(fout, "\t\t} /*s */\n");
1983 f_printif (scan_print) (void) fprintf(fout, "\t} /*p */\n\n");
1984 f_printif (scan_print) (void) fprintf(fout, "\tdone:\n");
1985 f_printif (scan_print) (void) fprintf(fout, "\tif (needsync) {\n");
1986
1987#if 0 /* We should do some sort of caching algorithm for this, but I need to think about it - shadow 26 jun 06 */
1988 f_printif (scan_print) (void) fprintf(fout, "\t\tif (!inlist) { /* Remember proc call that needs sync site */\n");
1989 f_printif (scan_print) (void) fprintf(fout, "\t\t\tLOCK_UCLNT_CACHE;\n");
1990 f_printif (scan_print) (void) fprintf(fout, "\t\t\tcalls_needsync[synccount % SYNCCOUNT] = (int *)%s%s%s;\n", prefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
1991 f_printif (scan_print) (void) fprintf(fout, "\t\t\tsynccount++;\n");
1992 f_printif (scan_print) (void) fprintf(fout, "\t\t\tUNLOCK_UCLNT_CACHE;\n");
1993 f_printif (scan_print) (void) fprintf(fout, "\t\t\tinlist = 1;\n");
1994 f_printif (scan_print) (void) fprintf(fout, "\t\t}\n");
1995#endif
1996 f_printif (scan_print) (void) fprintf(fout, "\t\tif (!rcode) { /* Remember the sync site - cmd successful */\n");
1997 f_printif (scan_print) (void) fprintf(fout, "\t\t\trxp = rx_PeerOf(aclient->conns[_ucount]);\n");
1998 f_printif (scan_print) (void) fprintf(fout, "\t\t\taclient->syncSite = rx_HostOf(rxp);\n");
1999 f_printif (scan_print) (void) fprintf(fout, "\t\t}\n");
2000 f_printif (scan_print) (void) fprintf(fout, "\t}\n");
2001 f_printif (scan_print) (void) fprintf(fout, "\tUNLOCK_UBIK_CLIENT(aclient);\n");
2002 f_printif (scan_print) (void) fprintf(fout, "\treturn rcode;\n}\n\n");
2003}
2004
2005
2006static int
2007opcode_holes_exist(void)
2008{
2009 int i;
2010
2011 for (i = lowest_opcode[PackageIndex]; i < highest_opcode[PackageIndex];
2012 i++) {
2013 if (!opcodenum_is_defined(i))
2014 return 1;
2015 }
2016 return 0;
2017}
2018
2019
2020void
2021er_Proc_CodeGeneration(void)
2022{
2023 int temp;
2024
2025 temp = PackageIndex;
2026 if (!combinepackages)
2027 PackageIndex = 0;
2028 for (; PackageIndex <= temp; PackageIndex++) {
2029 if (proc_defined[PackageIndex] == NULL((void *)0))
2030 continue;
2031 if (combinepackages || opcode_holes_exist()) {
2032 er_HeadofOldStyleProc_setup();
2033 er_BodyofOldStyleProc_setup();
2034 er_TailofOldStyleProc_setup();
2035 } else {
2036 er_ProcDeclExterns_setup();
2037 er_ProcProcsArray_setup();
2038 er_ProcMainBody_setup();
2039 }
2040 }
2041 PackageIndex = temp;
2042}
2043
2044
2045static void
2046er_ProcDeclExterns_setup(void)
2047{
2048 list *listp;
2049 definition *defp;
2050
2051 if ( !Sflag )
2052 return;
2053
2054 f_printif (scan_print) (void) fprintf(fout, "\n");
2055 for (listp = proc_defined[PackageIndex]; listp != NULL((void *)0);
2056 listp = listp->next) {
2057 defp = (definition *) listp->val;
2058 if (defp->pc.proc_serverstub) {
2059 f_printif (scan_print) (void) fprintf(fout, "afs_int32 %s();\n", defp->pc.proc_serverstub);
2060 }
2061 }
2062}
2063
2064
2065static void
2066er_ProcProcsArray_setup(void)
2067{
2068 list *listp;
2069 definition *defp;
2070
2071 if ((listp = proc_defined[PackageIndex])) {
2072 defp = (definition *) listp->val;
2073 if ( cflag ) {
2074 f_printif (scan_print) (void) fprintf(fout, "\nstatic char *opnames%d[] = {\"%s%s\"",
2075 PackageIndex, defp->pc.proc_prefix, defp->pc.proc_name);
2076 }
2077 else {
2078 if (defp->pc.proc_serverstub) {
2079 f_printif (scan_print) (void) fprintf(fout, "\nstatic afs_int32 (*StubProcsArray%d[])() = {%s",
2080 PackageIndex, defp->pc.proc_serverstub);
2081 } else {
2082 f_printif (scan_print) (void) fprintf(fout,
2083 "\nstatic afs_int32 (*StubProcsArray%d[])(struct rx_call *z_call, XDR *z_xdrs) = {_%s%s%s",
2084 PackageIndex, prefix, defp->pc.proc_prefix,
2085 ((definition *) listp->val)->pc.proc_name);
2086 defp = (definition *) listp->val;
2087 }
2088 }
2089 listp = listp->next;
2090 }
2091 for (; listp != NULL((void *)0); listp = listp->next) {
2092 defp = (definition *) listp->val;
2093 if ( cflag ) {
2094 f_printif (scan_print) (void) fprintf(fout, ", \"%s%s\"",defp->pc.proc_prefix,defp->pc.proc_name);
2095 }
2096 else {
2097 if (defp->pc.proc_serverstub) {
2098 f_printif (scan_print) (void) fprintf(fout, ",%s", defp->pc.proc_serverstub);
2099 } else {
2100 f_printif (scan_print) (void) fprintf(fout, ", _%s%s%s", prefix, defp->pc.proc_prefix,
2101 defp->pc.proc_name);
2102 }
2103 }
2104 }
2105 f_printif (scan_print) (void) fprintf(fout, "};\n\n");
2106}
2107
2108
2109static void
2110er_ProcMainBody_setup(void)
2111{
2112 if ( cflag ) {
2113 f_printif (scan_print) (void) fprintf(fout, "char *%sTranslateOpCode(int op)\n{\n",
2114 PackagePrefix[PackageIndex]);
2115 f_printif (scan_print) (void) fprintf(fout, "\tif (op < %sLOWEST_OPCODE || op > %sHIGHEST_OPCODE)\n\t\treturn NULL;\n",
2116 PackagePrefix[PackageIndex], PackagePrefix[PackageIndex]);
2117 f_printif (scan_print) (void) fprintf(fout, "\treturn opnames%d[op - %sLOWEST_OPCODE];\n}\n",
2118 PackageIndex, PackagePrefix[PackageIndex]);
2119 return;
2120 }
2121 f_printif (scan_print) (void) fprintf(fout, "int %s%sExecuteRequest(struct rx_call *z_call)\n",
2122 prefix, PackagePrefix[PackageIndex]);
2123 f_printif (scan_print) (void) fprintf(fout, "{\n\tint op;\n");
2124 f_printif (scan_print) (void) fprintf(fout, "\tXDR z_xdrs;\n");
2125 f_printif (scan_print) (void) fprintf(fout, "\t" "afs_int32 z_result;\n\n");
2126 f_printif (scan_print) (void) fprintf(fout, "\txdrrx_create(&z_xdrs, z_call, XDR_DECODE);\n");
2127 f_printif (scan_print) (void) fprintf(fout,
2128 "\tif (!xdr_int(&z_xdrs, &op))\n\t\tz_result = RXGEN_DECODE;\n");
2129 f_printif (scan_print) (void) fprintf(fout,
2130 "\telse if (op < %sLOWEST_OPCODE || op > %sHIGHEST_OPCODE)\n\t\tz_result = RXGEN_OPCODE;\n",
2131 PackagePrefix[PackageIndex], PackagePrefix[PackageIndex]);
2132 f_printif (scan_print) (void) fprintf(fout,
2133 "\telse\n\t\tz_result = (*StubProcsArray%d[op - %sLOWEST_OPCODE])(z_call, &z_xdrs);\n",
2134 PackageIndex, PackagePrefix[PackageIndex]);
2135 f_printif (scan_print) (void) fprintf(fout, "\treturn hton_syserr_conv(z_result);\n}\n");
2136}
2137
2138
2139static void
2140er_HeadofOldStyleProc_setup(void)
2141{
2142 if ( cflag ) {
2143 f_printif (scan_print) (void) fprintf(fout, "char *%sTranslateOpCode(int op)\n{\n",
2144 (combinepackages ? MasterPrefix : PackagePrefix[PackageIndex]));
2145 }
2146 else {
2147 f_printif (scan_print) (void) fprintf(fout,
2148 "\nint %s%sExecuteRequest (struct rx_call *z_call)\n",
2149 prefix,
2150 (combinepackages ? MasterPrefix : PackagePrefix[PackageIndex]));
2151 f_printif (scan_print) (void) fprintf(fout, "{\n");
2152 f_printif (scan_print) (void) fprintf(fout, "\tint op;\n");
2153 f_printif (scan_print) (void) fprintf(fout, "\tXDR z_xdrs;\n");
2154 f_printif (scan_print) (void) fprintf(fout, "\t" "afs_int32 z_result;\n\n");
2155 f_printif (scan_print) (void) fprintf(fout, "\txdrrx_create(&z_xdrs, z_call, XDR_DECODE);\n");
2156 f_printif (scan_print) (void) fprintf(fout, "\tz_result = RXGEN_DECODE;\n");
2157 f_printif (scan_print) (void) fprintf(fout, "\tif (!xdr_int(&z_xdrs, &op)) goto fail;\n");
2158 }
2159 f_printif (scan_print) (void) fprintf(fout, "\tswitch (op) {\n");
2160}
2161
2162static void
2163er_BodyofOldStyleProc_setup(void)
2164{
2165 list *listp;
2166
2167 if (combinepackages) {
2168 int temp = PackageIndex;
2169 for (PackageIndex = 0; PackageIndex <= temp; PackageIndex++) {
2170 for (listp = proc_defined[PackageIndex]; listp != NULL((void *)0);
2171 listp = listp->next)
2172 proc_er_case((definition *) listp->val);
2173 }
2174 PackageIndex = temp;
2175 } else {
2176 for (listp = proc_defined[PackageIndex]; listp != NULL((void *)0);
2177 listp = listp->next)
2178 proc_er_case((definition *) listp->val);
2179 }
2180}
2181
2182
2183static void
2184proc_er_case(definition * defp)
2185{
2186 if ( cflag ) {
2187 f_printif (scan_print) (void) fprintf(fout, "\t\tcase %d:", defp->pc.proc_opcodenum);
2188 f_printif (scan_print) (void) fprintf(fout, "\treturn \"%s%s\";\n",
2189 defp->pc.proc_prefix, defp->pc.proc_name);
2190 return;
2191 }
2192 if (opcodesnotallowed[PackageIndex]) {
2193 f_printif (scan_print) (void) fprintf(fout, "\t\tcase %d:\n", defp->pc.proc_opcodenum);
2194 } else {
2195 f_printif (scan_print) (void) fprintf(fout, "\t\tcase %s:\n", defp->pc.proc_opcodename);
2196 }
2197 if (defp->pc.proc_serverstub) {
2198 f_printif (scan_print) (void) fprintf(fout, "\t\t\tz_result = %s(z_call, &z_xdrs);\n",
2199 defp->pc.proc_serverstub);
2200 } else {
2201 f_printif (scan_print) (void) fprintf(fout, "\t\t\tz_result = _%s%s%s(z_call, &z_xdrs);\n", prefix,
2202 defp->pc.proc_prefix, defp->pc.proc_name);
2203 }
2204 f_printif (scan_print) (void) fprintf(fout, "\t\t\tbreak;\n");
2205}
2206
2207
2208static void
2209er_TailofOldStyleProc_setup(void)
2210{
2211 f_printif (scan_print) (void) fprintf(fout, "\t\tdefault:\n");
2212 if ( cflag ) {
2213 f_printif (scan_print) (void) fprintf(fout, "\t\t\treturn NULL;\n\t}\n}\n");
2214 return;
2215 }
2216 f_printif (scan_print) (void) fprintf(fout, "\t\t\tz_result = RXGEN_OPCODE;\n");
2217 f_printif (scan_print) (void) fprintf(fout, "\t\t\tbreak;\n\t}\n");
2218 f_printif (scan_print) (void) fprintf(fout, "fail:\n");
2219 f_printif (scan_print) (void) fprintf(fout, "\treturn z_result;\n}\n");
2220}
2221
2222static void
2223h_ProcMainBody_setup(void)
2224{
2225 f_printif (scan_print) (void) fprintf(fout,"\nextern int %s%sExecuteRequest(struct rx_call *);\n",
2226 prefix, PackagePrefix[PackageIndex]);
2227}
2228
2229static void
2230h_HeadofOldStyleProc_setup(void)
2231{
2232 f_printif (scan_print) (void) fprintf(fout,"\nextern int %s%sExecuteRequest(struct rx_call *);\n",
2233 prefix,
2234 (combinepackages ? MasterPrefix : PackagePrefix[PackageIndex]));
2235}
2236
2237void
2238h_Proc_CodeGeneration(void)
2239{
2240 int temp;
2241
2242 temp = PackageIndex;
2243 if (!combinepackages)
2244 PackageIndex = 0;
2245 for (; PackageIndex <= temp; PackageIndex++) {
2246 if (combinepackages || opcode_holes_exist()) {
2247 h_HeadofOldStyleProc_setup();
2248 } else {
2249 h_ProcMainBody_setup();
2250 }
2251 }
2252 PackageIndex = temp;
2253}
2254
2255void
2256h_opcode_stats(void)
2257{
2258 if (combinepackages) {
2259 f_printif (scan_print) (void) fprintf(fout,
2260 "\n/* Opcode-related useful stats for Master package: %s */\n",
2261 MasterPrefix);
2262 f_printif (scan_print) (void) fprintf(fout, "#define %sLOWEST_OPCODE %d\n", MasterPrefix,
2263 master_lowest_opcode);
2264 f_printif (scan_print) (void) fprintf(fout, "#define %sHIGHEST_OPCODE %d\n", MasterPrefix,
2265 master_highest_opcode);
2266 f_printif (scan_print) (void) fprintf(fout, "#define %sNUMBER_OPCODES %d\n\n", MasterPrefix,
2267 master_no_of_opcodes);
2268 if (xflag) {
2269 f_printif (scan_print) (void) fprintf(fout, "#define %sNO_OF_STAT_FUNCS\t%d\n\n", MasterPrefix,
2270 no_of_stat_funcs_header[0]);
2271 f_printif (scan_print) (void) fprintf(fout, "AFS_RXGEN_EXPORT\n");
2272 f_printif (scan_print) (void) fprintf(fout, "extern const char *%sfunction_names[];\n\n",
2273 MasterPrefix);
2274 }
2275 } else {
2276 int i;
2277 for (i = 0; i <= PackageIndex; i++) {
2278 f_printif (scan_print) (void) fprintf(fout,
2279 "\n/* Opcode-related useful stats for package: %s */\n",
2280 PackagePrefix[i]);
2281 f_printif (scan_print) (void) fprintf(fout, "#define %sLOWEST_OPCODE %d\n", PackagePrefix[i],
2282 lowest_opcode[i]);
2283 f_printif (scan_print) (void) fprintf(fout, "#define %sHIGHEST_OPCODE %d\n",
2284 PackagePrefix[i], highest_opcode[i]);
2285 f_printif (scan_print) (void) fprintf(fout, "#define %sNUMBER_OPCODES %d\n\n",
2286 PackagePrefix[i], no_of_opcodes[i]);
2287 if (xflag) {
2288 f_printif (scan_print) (void) fprintf(fout, "#define %sNO_OF_STAT_FUNCS\t%d\n\n",
2289 PackagePrefix[i], no_of_stat_funcs_header[i]);
2290 f_printif (scan_print) (void) fprintf(fout, "AFS_RXGEN_EXPORT\n");
2291 f_printif (scan_print) (void) fprintf(fout, "extern const char *%sfunction_names[];\n\n",
2292 PackagePrefix[i]);
2293 }
2294 }
2295 }
2296}
2297
2298
2299void
2300generate_multi_macros(definition * defp)
2301{
2302 char *startname = SplitStart, *endname = SplitEnd;
2303 proc1_list *plist;
2304 int numofparams;
2305 int first = 0;
2306
2307 if (!hflag)
2308 return;
2309 if (!Multi_Init) {
2310 Multi_Init = 1;
2311 f_printif (scan_print) (void) fprintf(fout, "\n#include <rx/rx_multi.h>");
2312 }
2313 f_printif (scan_print) (void) fprintf(fout, "\n#define multi_%s%s(", PackagePrefix[PackageIndex],
2314 defp->pc.proc_name);
2315 for (plist = defp->pc.plists; plist; plist = plist->next) {
2316 if (plist->component_kind == DEF_PARAM) {
2317 if (!first) {
2318 first = 1;
2319 f_printif (scan_print) (void) fprintf(fout, "%s", plist->pl.param_name);
2320 } else {
2321 f_printif (scan_print) (void) fprintf(fout, ", %s", plist->pl.param_name);
2322 }
2323 }
2324 }
2325 f_printif (scan_print) (void) fprintf(fout, ") \\\n");
2326 if (!startname)
2327 startname = "Start";
2328 if (!endname)
2329 endname = "End";
2330 f_printif (scan_print) (void) fprintf(fout, "\tmulti_Body(%s%s%s(multi_call", startname,
2331 PackagePrefix[PackageIndex], defp->pc.proc_name);
2332 do_split(defp, OUT1, &numofparams, DEF_OUTPARAM, 0);
2333 for (plist = defp->pc.plists; plist; plist = plist->next) {
2334 if (plist->component_kind == DEF_PARAM)
2335 f_printif (scan_print) (void) fprintf(fout, ", %s", plist->pl.param_name);
2336 }
2337 do_split(defp, OUT1, &numofparams, DEF_OUTPARAM, 1);
2338 f_printif (scan_print) (void) fprintf(fout, "), %s%s%s(multi_call", endname,
2339 PackagePrefix[PackageIndex], defp->pc.proc_name);
2340 do_split(defp, IN0, &numofparams, DEF_INPARAM, 0);
2341 for (plist = defp->pc.plists; plist; plist = plist->next) {
2342 if (plist->component_kind == DEF_PARAM) {
2343 f_printif (scan_print) (void) fprintf(fout, ", %s", plist->pl.param_name);
2344 }
2345 }
2346 do_split(defp, IN0, &numofparams, DEF_INPARAM, 1);
2347 f_printif (scan_print) (void) fprintf(fout, "))\n\n");
2348}
2349
2350
2351int
2352IsRxgenToken(token * tokp)
2353{
2354 if (tokp->kind == TOK_PACKAGE || tokp->kind == TOK_PREFIX
2355 || tokp->kind == TOK_SPECIAL || tokp->kind == TOK_STARTINGOPCODE
2356 || tokp->kind == TOK_SPLITPREFIX || tokp->kind == TOK_PROC
2357 || tokp->kind == TOK_STATINDEX)
2358 return 1;
2359 return 0;
2360}
2361
2362int
2363IsRxgenDefinition(definition * def)
2364{
2365 if (def->def_kind == DEF_PACKAGE || def->def_kind == DEF_PREFIX
2366 || def->def_kind == DEF_SPECIAL || def->def_kind == DEF_STARTINGOPCODE
2367 || def->def_kind == DEF_SPLITPREFIX || def->def_kind == DEF_PROC)
2368 return 1;
2369 return 0;
2370}