]>
Commit | Line | Data |
---|---|---|
28f540f4 | 1 | /* |
a7ab6ec8 | 2 | * From: @(#)rpc_hout.c 1.12 89/02/22 |
cb636bb2 | 3 | * |
a7ab6ec8 UD |
4 | * Copyright (c) 2010, Oracle America, Inc. |
5 | * Redistribution and use in source and binary forms, with or without | |
6 | * modification, are permitted provided that the following conditions are | |
7 | * met: | |
0d204b0a | 8 | * |
a7ab6ec8 UD |
9 | * * Redistributions of source code must retain the above copyright |
10 | * notice, this list of conditions and the following disclaimer. | |
11 | * * Redistributions in binary form must reproduce the above | |
12 | * copyright notice, this list of conditions and the following | |
13 | * disclaimer in the documentation and/or other materials | |
14 | * provided with the distribution. | |
15 | * * Neither the name of the "Oracle America, Inc." nor the names of its | |
16 | * contributors may be used to endorse or promote products derived | |
17 | * from this software without specific prior written permission. | |
0d204b0a | 18 | * |
a7ab6ec8 UD |
19 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
20 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
21 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS | |
22 | * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE | |
23 | * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, | |
24 | * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
25 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE | |
26 | * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
27 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |
28 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
29 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
0d204b0a | 31 | */ |
28f540f4 RM |
32 | |
33 | /* | |
880f421f | 34 | * rpc_hout.c, Header file outputter for the RPC protocol compiler |
28f540f4 RM |
35 | */ |
36 | #include <stdio.h> | |
37 | #include <ctype.h> | |
28f540f4 | 38 | #include "rpc_parse.h" |
0d204b0a UD |
39 | #include "rpc_util.h" |
40 | #include "proto.h" | |
28f540f4 | 41 | |
880f421f UD |
42 | static void pconstdef (definition * def); |
43 | static void pargdef (definition * def); | |
44 | static void pstructdef (definition * def); | |
45 | static void puniondef (definition * def); | |
46 | static void pdefine (const char *name, const char *num); | |
880f421f UD |
47 | static int define_printed (proc_list * stop, version_list * start); |
48 | static void pprogramdef (definition * def); | |
49 | static void parglist (proc_list * proc, const char *addargtype); | |
50 | static void penumdef (definition * def); | |
51 | static void ptypedef (definition * def); | |
52 | static int undefined2 (const char *type, const char *stop); | |
53 | ||
54 | /* store away enough information to allow the XDR functions to be spat | |
55 | out at the end of the file */ | |
56 | ||
fa39f7f7 | 57 | static void |
880f421f UD |
58 | storexdrfuncdecl (const char *name, int pointerp) |
59 | { | |
60 | xdrfunc * xdrptr; | |
61 | ||
62 | xdrptr = (xdrfunc *) malloc(sizeof (struct xdrfunc)); | |
63 | ||
64 | xdrptr->name = (char *)name; | |
65 | xdrptr->pointerp = pointerp; | |
66 | xdrptr->next = NULL; | |
67 | ||
68 | if (xdrfunc_tail == NULL) | |
69 | { | |
70 | xdrfunc_head = xdrptr; | |
71 | xdrfunc_tail = xdrptr; | |
72 | } | |
73 | else | |
74 | { | |
75 | xdrfunc_tail->next = xdrptr; | |
76 | xdrfunc_tail = xdrptr; | |
77 | } | |
78 | } | |
28f540f4 RM |
79 | |
80 | /* | |
880f421f | 81 | * Print the C-version of an xdr definition |
28f540f4 RM |
82 | */ |
83 | void | |
880f421f | 84 | print_datadef (definition *def) |
28f540f4 | 85 | { |
0d204b0a | 86 | |
880f421f UD |
87 | if (def->def_kind == DEF_PROGRAM) /* handle data only */ |
88 | return; | |
89 | ||
90 | if (def->def_kind != DEF_CONST) | |
91 | { | |
92 | f_print (fout, "\n"); | |
93 | } | |
94 | switch (def->def_kind) | |
95 | { | |
96 | case DEF_STRUCT: | |
97 | pstructdef (def); | |
98 | break; | |
99 | case DEF_UNION: | |
100 | puniondef (def); | |
101 | break; | |
102 | case DEF_ENUM: | |
103 | penumdef (def); | |
104 | break; | |
105 | case DEF_TYPEDEF: | |
106 | ptypedef (def); | |
107 | break; | |
108 | case DEF_PROGRAM: | |
109 | pprogramdef (def); | |
110 | break; | |
111 | case DEF_CONST: | |
112 | pconstdef (def); | |
113 | break; | |
114 | } | |
115 | if (def->def_kind != DEF_PROGRAM && def->def_kind != DEF_CONST) | |
116 | { | |
117 | storexdrfuncdecl(def->def_name, | |
118 | def->def_kind != DEF_TYPEDEF || | |
119 | !isvectordef(def->def.ty.old_type, | |
120 | def->def.ty.rel)); | |
121 | } | |
0d204b0a UD |
122 | } |
123 | ||
124 | ||
125 | void | |
880f421f | 126 | print_funcdef (definition *def) |
0d204b0a | 127 | { |
880f421f UD |
128 | switch (def->def_kind) |
129 | { | |
130 | case DEF_PROGRAM: | |
131 | f_print (fout, "\n"); | |
132 | pprogramdef (def); | |
133 | break; | |
134 | default: | |
8da8e2db | 135 | break; |
880f421f UD |
136 | /* ?... shouldn't happen I guess */ |
137 | } | |
28f540f4 RM |
138 | } |
139 | ||
0d204b0a | 140 | void |
880f421f | 141 | print_xdr_func_def (char *name, int pointerp, int i) |
0d204b0a | 142 | { |
880f421f UD |
143 | if (i == 2) |
144 | { | |
145 | f_print (fout, "extern bool_t xdr_%s ();\n", name); | |
146 | return; | |
147 | } | |
148 | else | |
149 | f_print(fout, "extern bool_t xdr_%s (XDR *, %s%s);\n", name, | |
150 | name, pointerp ? "*" : ""); | |
0d204b0a UD |
151 | } |
152 | ||
0d204b0a | 153 | static void |
880f421f | 154 | pconstdef (definition *def) |
28f540f4 | 155 | { |
880f421f | 156 | pdefine (def->def_name, def->def.co); |
28f540f4 RM |
157 | } |
158 | ||
880f421f UD |
159 | /* print out the definitions for the arguments of functions in the |
160 | header file | |
161 | */ | |
0d204b0a | 162 | static void |
880f421f | 163 | pargdef (definition * def) |
0d204b0a | 164 | { |
880f421f UD |
165 | decl_list *l; |
166 | version_list *vers; | |
167 | const char *name; | |
168 | proc_list *plist; | |
169 | ||
170 | for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) | |
171 | { | |
172 | for (plist = vers->procs; plist != NULL; | |
173 | plist = plist->next) | |
174 | { | |
175 | ||
176 | if (!newstyle || plist->arg_num < 2) | |
177 | { | |
178 | continue; /* old style or single args */ | |
179 | } | |
180 | name = plist->args.argname; | |
181 | f_print (fout, "struct %s {\n", name); | |
182 | for (l = plist->args.decls; | |
183 | l != NULL; l = l->next) | |
184 | { | |
185 | pdeclaration (name, &l->decl, 1, ";\n"); | |
186 | } | |
187 | f_print (fout, "};\n"); | |
188 | f_print (fout, "typedef struct %s %s;\n", name, name); | |
ecb65164 | 189 | storexdrfuncdecl (name, 1); |
880f421f UD |
190 | f_print (fout, "\n"); |
191 | } | |
192 | } | |
0d204b0a UD |
193 | |
194 | } | |
195 | ||
0d204b0a | 196 | static void |
880f421f | 197 | pstructdef (definition *def) |
28f540f4 | 198 | { |
880f421f UD |
199 | decl_list *l; |
200 | const char *name = def->def_name; | |
201 | ||
202 | f_print (fout, "struct %s {\n", name); | |
203 | for (l = def->def.st.decls; l != NULL; l = l->next) | |
204 | { | |
205 | pdeclaration (name, &l->decl, 1, ";\n"); | |
206 | } | |
207 | f_print (fout, "};\n"); | |
208 | f_print (fout, "typedef struct %s %s;\n", name, name); | |
28f540f4 RM |
209 | } |
210 | ||
0d204b0a | 211 | static void |
880f421f | 212 | puniondef (definition *def) |
28f540f4 | 213 | { |
880f421f UD |
214 | case_list *l; |
215 | const char *name = def->def_name; | |
216 | declaration *decl; | |
217 | ||
218 | f_print (fout, "struct %s {\n", name); | |
219 | decl = &def->def.un.enum_decl; | |
220 | if (streq (decl->type, "bool")) | |
221 | { | |
222 | f_print (fout, "\tbool_t %s;\n", decl->name); | |
223 | } | |
224 | else | |
225 | { | |
226 | f_print (fout, "\t%s %s;\n", decl->type, decl->name); | |
227 | } | |
228 | f_print (fout, "\tunion {\n"); | |
229 | for (l = def->def.un.cases; l != NULL; l = l->next) | |
230 | { | |
231 | if (l->contflag == 0) | |
232 | pdeclaration (name, &l->case_decl, 2, ";\n"); | |
233 | } | |
234 | decl = def->def.un.default_decl; | |
235 | if (decl && !streq (decl->type, "void")) | |
236 | { | |
237 | pdeclaration (name, decl, 2, ";\n"); | |
238 | } | |
239 | f_print (fout, "\t} %s_u;\n", name); | |
240 | f_print (fout, "};\n"); | |
241 | f_print (fout, "typedef struct %s %s;\n", name, name); | |
28f540f4 RM |
242 | } |
243 | ||
0d204b0a | 244 | static void |
880f421f | 245 | pdefine (const char *name, const char *num) |
28f540f4 | 246 | { |
880f421f | 247 | f_print (fout, "#define %s %s\n", name, num); |
28f540f4 RM |
248 | } |
249 | ||
0d204b0a | 250 | static int |
880f421f | 251 | define_printed (proc_list *stop, version_list *start) |
28f540f4 | 252 | { |
880f421f UD |
253 | version_list *vers; |
254 | proc_list *proc; | |
255 | ||
256 | for (vers = start; vers != NULL; vers = vers->next) | |
257 | { | |
258 | for (proc = vers->procs; proc != NULL; proc = proc->next) | |
259 | { | |
260 | if (proc == stop) | |
261 | { | |
262 | return 0; | |
263 | } | |
264 | else if (streq (proc->proc_name, stop->proc_name)) | |
265 | { | |
266 | return 1; | |
267 | } | |
28f540f4 | 268 | } |
880f421f UD |
269 | } |
270 | abort (); | |
271 | /* NOTREACHED */ | |
28f540f4 RM |
272 | } |
273 | ||
0d204b0a | 274 | static void |
880f421f | 275 | pfreeprocdef (const char *name, const char *vers, int mode) |
28f540f4 | 276 | { |
880f421f UD |
277 | f_print (fout, "extern int "); |
278 | pvname (name, vers); | |
279 | if (mode == 1) | |
280 | f_print (fout,"_freeresult (SVCXPRT *, xdrproc_t, caddr_t);\n"); | |
281 | else | |
282 | f_print (fout,"_freeresult ();\n"); | |
283 | } | |
284 | ||
285 | static void | |
286 | pprogramdef (definition *def) | |
287 | { | |
288 | version_list *vers; | |
289 | proc_list *proc; | |
290 | int i; | |
291 | const char *ext; | |
292 | ||
293 | pargdef (def); | |
294 | ||
ee586e0e | 295 | pdefine (def->def_name, def->def.pr.prog_num); |
880f421f UD |
296 | for (vers = def->def.pr.versions; vers != NULL; vers = vers->next) |
297 | { | |
298 | if (tblflag) | |
299 | { | |
300 | f_print (fout, "extern struct rpcgen_table %s_%s_table[];\n", | |
301 | locase (def->def_name), vers->vers_num); | |
302 | f_print (fout, "extern %s_%s_nproc;\n", | |
303 | locase (def->def_name), vers->vers_num); | |
304 | } | |
ee586e0e | 305 | pdefine (vers->vers_name, vers->vers_num); |
880f421f UD |
306 | |
307 | /* | |
308 | * Print out 2 definitions, one for ANSI-C, another for | |
309 | * old K & R C | |
310 | */ | |
311 | ||
312 | if(!Cflag) | |
313 | { | |
314 | ext = "extern "; | |
315 | for (proc = vers->procs; proc != NULL; | |
316 | proc = proc->next) | |
317 | { | |
318 | if (!define_printed(proc, def->def.pr.versions)) | |
319 | { | |
ee586e0e | 320 | pdefine (proc->proc_name, proc->proc_num); |
880f421f UD |
321 | } |
322 | f_print (fout, "%s", ext); | |
323 | pprocdef (proc, vers, NULL, 0, 2); | |
324 | ||
325 | if (mtflag) | |
326 | { | |
327 | f_print(fout, "%s", ext); | |
328 | pprocdef (proc, vers, NULL, 1, 2); | |
329 | } | |
330 | } | |
331 | pfreeprocdef (def->def_name, vers->vers_num, 2); | |
332 | } | |
333 | else | |
334 | { | |
335 | for (i = 1; i < 3; i++) | |
336 | { | |
337 | if (i == 1) | |
338 | { | |
339 | f_print (fout, "\n#if defined(__STDC__) || defined(__cplusplus)\n"); | |
340 | ext = "extern "; | |
341 | } | |
342 | else | |
343 | { | |
344 | f_print (fout, "\n#else /* K&R C */\n"); | |
345 | ext = "extern "; | |
0d204b0a | 346 | } |
0d204b0a | 347 | |
880f421f UD |
348 | for (proc = vers->procs; proc != NULL; proc = proc->next) |
349 | { | |
350 | if (!define_printed(proc, def->def.pr.versions)) | |
351 | { | |
ee586e0e | 352 | pdefine(proc->proc_name, proc->proc_num); |
880f421f UD |
353 | } |
354 | f_print (fout, "%s", ext); | |
355 | pprocdef (proc, vers, "CLIENT *", 0, i); | |
356 | f_print (fout, "%s", ext); | |
357 | pprocdef (proc, vers, "struct svc_req *", 1, i); | |
28f540f4 | 358 | } |
880f421f UD |
359 | pfreeprocdef (def->def_name, vers->vers_num, i); |
360 | } | |
361 | f_print (fout, "#endif /* K&R C */\n"); | |
28f540f4 | 362 | } |
880f421f | 363 | } |
28f540f4 RM |
364 | } |
365 | ||
0d204b0a | 366 | void |
880f421f UD |
367 | pprocdef (proc_list * proc, version_list * vp, |
368 | const char *addargtype, int server_p, int mode) | |
0d204b0a | 369 | { |
880f421f UD |
370 | if (mtflag) |
371 | {/* Print MT style stubs */ | |
372 | if (server_p) | |
373 | f_print (fout, "bool_t "); | |
374 | else | |
375 | f_print (fout, "enum clnt_stat "); | |
376 | } | |
377 | else | |
378 | { | |
379 | ptype (proc->res_prefix, proc->res_type, 1); | |
380 | f_print (fout, "* "); | |
381 | } | |
382 | if (server_p) | |
383 | pvname_svc (proc->proc_name, vp->vers_num); | |
384 | else | |
385 | pvname (proc->proc_name, vp->vers_num); | |
386 | ||
387 | /* | |
388 | * mode 1 = ANSI-C, mode 2 = K&R C | |
389 | */ | |
390 | if (mode == 1) | |
391 | parglist (proc, addargtype); | |
392 | else | |
393 | f_print (fout, "();\n"); | |
0d204b0a UD |
394 | } |
395 | ||
0d204b0a UD |
396 | /* print out argument list of procedure */ |
397 | static void | |
880f421f | 398 | parglist (proc_list *proc, const char *addargtype) |
28f540f4 | 399 | { |
880f421f UD |
400 | decl_list *dl; |
401 | ||
402 | f_print(fout,"("); | |
403 | if (proc->arg_num < 2 && newstyle && | |
404 | streq (proc->args.decls->decl.type, "void")) | |
405 | { | |
406 | /* 0 argument in new style: do nothing */ | |
407 | } | |
408 | else | |
409 | { | |
410 | for (dl = proc->args.decls; dl != NULL; dl = dl->next) | |
411 | { | |
412 | ptype (dl->decl.prefix, dl->decl.type, 1); | |
413 | if (!newstyle) | |
414 | f_print (fout, "*"); /* old style passes by reference */ | |
415 | ||
416 | f_print (fout, ", "); | |
417 | } | |
418 | } | |
419 | if (mtflag) | |
420 | { | |
421 | ptype(proc->res_prefix, proc->res_type, 1); | |
422 | f_print(fout, "*, "); | |
423 | } | |
424 | ||
425 | f_print (fout, "%s);\n", addargtype); | |
28f540f4 RM |
426 | } |
427 | ||
0d204b0a | 428 | static void |
880f421f | 429 | penumdef (definition *def) |
28f540f4 | 430 | { |
880f421f UD |
431 | const char *name = def->def_name; |
432 | enumval_list *l; | |
433 | const char *last = NULL; | |
434 | int count = 0; | |
435 | ||
436 | f_print (fout, "enum %s {\n", name); | |
437 | for (l = def->def.en.vals; l != NULL; l = l->next) | |
438 | { | |
439 | f_print (fout, "\t%s", l->name); | |
440 | if (l->assignment) | |
441 | { | |
442 | f_print (fout, " = %s", l->assignment); | |
443 | last = l->assignment; | |
444 | count = 1; | |
445 | } | |
446 | else | |
447 | { | |
448 | if (last == NULL) | |
449 | { | |
450 | f_print (fout, " = %d", count++); | |
451 | } | |
452 | else | |
453 | { | |
454 | f_print (fout, " = %s + %d", last, count++); | |
455 | } | |
28f540f4 | 456 | } |
880f421f UD |
457 | f_print (fout, ",\n"); |
458 | } | |
459 | f_print (fout, "};\n"); | |
460 | f_print (fout, "typedef enum %s %s;\n", name, name); | |
28f540f4 RM |
461 | } |
462 | ||
0d204b0a | 463 | static void |
880f421f | 464 | ptypedef (definition *def) |
28f540f4 | 465 | { |
880f421f UD |
466 | const char *name = def->def_name; |
467 | const char *old = def->def.ty.old_type; | |
468 | char prefix[8]; /* enough to contain "struct ", including NUL */ | |
469 | relation rel = def->def.ty.rel; | |
470 | ||
471 | if (!streq (name, old)) | |
472 | { | |
473 | if (streq (old, "string")) | |
474 | { | |
475 | old = "char"; | |
476 | rel = REL_POINTER; | |
477 | } | |
478 | else if (streq (old, "opaque")) | |
479 | { | |
480 | old = "char"; | |
481 | } | |
482 | else if (streq (old, "bool")) | |
483 | { | |
484 | old = "bool_t"; | |
485 | } | |
486 | if (undefined2 (old, name) && def->def.ty.old_prefix) | |
487 | { | |
488 | s_print (prefix, "%s ", def->def.ty.old_prefix); | |
28f540f4 | 489 | } |
880f421f UD |
490 | else |
491 | { | |
492 | prefix[0] = 0; | |
493 | } | |
494 | f_print (fout, "typedef "); | |
495 | switch (rel) | |
496 | { | |
497 | case REL_ARRAY: | |
498 | f_print (fout, "struct {\n"); | |
499 | f_print (fout, "\tu_int %s_len;\n", name); | |
500 | f_print (fout, "\t%s%s *%s_val;\n", prefix, old, name); | |
501 | f_print (fout, "} %s", name); | |
502 | break; | |
503 | case REL_POINTER: | |
504 | f_print (fout, "%s%s *%s", prefix, old, name); | |
505 | break; | |
506 | case REL_VECTOR: | |
507 | f_print (fout, "%s%s %s[%s]", prefix, old, name, | |
508 | def->def.ty.array_max); | |
509 | break; | |
510 | case REL_ALIAS: | |
511 | f_print (fout, "%s%s %s", prefix, old, name); | |
512 | break; | |
513 | } | |
514 | f_print (fout, ";\n"); | |
515 | } | |
28f540f4 RM |
516 | } |
517 | ||
0d204b0a | 518 | void |
880f421f UD |
519 | pdeclaration (const char *name, declaration * dec, int tab, |
520 | const char *separator) | |
28f540f4 | 521 | { |
880f421f UD |
522 | char buf[8]; /* enough to hold "struct ", include NUL */ |
523 | const char *prefix; | |
524 | const char *type; | |
525 | ||
526 | if (streq (dec->type, "void")) | |
527 | { | |
528 | return; | |
529 | } | |
530 | tabify (fout, tab); | |
531 | if (streq (dec->type, name) && !dec->prefix) | |
532 | { | |
533 | f_print (fout, "struct "); | |
534 | } | |
535 | if (streq (dec->type, "string")) | |
536 | { | |
537 | f_print (fout, "char *%s", dec->name); | |
538 | } | |
539 | else | |
540 | { | |
541 | prefix = ""; | |
542 | if (streq (dec->type, "bool")) | |
543 | { | |
544 | type = "bool_t"; | |
28f540f4 | 545 | } |
880f421f UD |
546 | else if (streq (dec->type, "opaque")) |
547 | { | |
548 | type = "char"; | |
28f540f4 | 549 | } |
880f421f UD |
550 | else |
551 | { | |
552 | if (dec->prefix) | |
553 | { | |
554 | s_print (buf, "%s ", dec->prefix); | |
555 | prefix = buf; | |
556 | } | |
557 | type = dec->type; | |
558 | } | |
559 | switch (dec->rel) | |
560 | { | |
561 | case REL_ALIAS: | |
562 | f_print (fout, "%s%s %s", prefix, type, dec->name); | |
563 | break; | |
564 | case REL_VECTOR: | |
565 | f_print (fout, "%s%s %s[%s]", prefix, type, dec->name, | |
566 | dec->array_max); | |
567 | break; | |
568 | case REL_POINTER: | |
569 | f_print (fout, "%s%s *%s", prefix, type, dec->name); | |
570 | break; | |
571 | case REL_ARRAY: | |
572 | f_print (fout, "struct {\n"); | |
573 | tabify (fout, tab); | |
574 | f_print (fout, "\tu_int %s_len;\n", dec->name); | |
575 | tabify (fout, tab); | |
576 | f_print (fout, "\t%s%s *%s_val;\n", prefix, type, dec->name); | |
577 | tabify (fout, tab); | |
578 | f_print (fout, "} %s", dec->name); | |
579 | break; | |
28f540f4 | 580 | } |
880f421f UD |
581 | } |
582 | f_print (fout, separator); | |
28f540f4 RM |
583 | } |
584 | ||
0d204b0a | 585 | static int |
880f421f | 586 | undefined2 (const char *type, const char *stop) |
28f540f4 | 587 | { |
880f421f UD |
588 | list *l; |
589 | definition *def; | |
590 | ||
591 | for (l = defined; l != NULL; l = l->next) | |
592 | { | |
593 | def = (definition *) l->val; | |
594 | if (def->def_kind != DEF_PROGRAM) | |
595 | { | |
596 | if (streq (def->def_name, stop)) | |
597 | { | |
598 | return 1; | |
599 | } | |
600 | else if (streq (def->def_name, type)) | |
601 | { | |
602 | return 0; | |
603 | } | |
28f540f4 | 604 | } |
880f421f UD |
605 | } |
606 | return 1; | |
28f540f4 | 607 | } |