xref: /netbsd/bin/csh/set.c (revision bf9ec67e) 
1 /* $NetBSD: set.c,v 1.18 2002/05/25 23:29:17 wiz Exp $ */
2 
3 /*-
4  * Copyright (c) 1980, 1991, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. All advertising materials mentioning features or use of this software
16  *    must display the following acknowledgement:
17  *	This product includes software developed by the University of
18  *	California, Berkeley and its contributors.
19  * 4. Neither the name of the University nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35 
36 #include <sys/cdefs.h>
37 #ifndef lint
38 #if 0
39 static char sccsid[] = "@(#)set.c	8.1 (Berkeley) 5/31/93";
40 #else
41 __RCSID("$NetBSD: set.c,v 1.18 2002/05/25 23:29:17 wiz Exp $");
42 #endif
43 #endif /* not lint */
44 
45 #include <sys/types.h>
46 
47 #include <stdarg.h>
48 #include <stdlib.h>
49 
50 #ifndef SHORT_STRINGS
51 #include <string.h>
52 #endif /* SHORT_STRINGS */
53 
54 #include "csh.h"
55 #include "extern.h"
56 
57 static Char *getinx(Char *, int *);
58 static void asx(Char *, int, Char *);
59 static struct varent *getvx(Char *, int);
60 static Char *xset(Char *, Char ***);
61 static Char *operate(int, Char *, Char *);
62 static void putn1(int);
63 static struct varent *madrof(Char *, struct varent *);
64 static void unsetv1(struct varent *);
65 static void exportpath(Char **);
66 static void balance(struct varent *, int, int);
67 
68 /*
69  * C Shell
70  */
71 
72 void
73 /*ARGSUSED*/
74 doset(Char **v, struct command *t)
75 {
76     Char op, *p, **vecp, *vp;
77     int subscr;
78     bool hadsub;
79 
80     v++;
81     p = *v++;
82     if (p == 0) {
83 	prvars();
84 	return;
85     }
86     do {
87 	hadsub = 0;
88 	vp = p;
89 	if (letter(*p))
90 	    for (; alnum(*p); p++)
91 		continue;
92 	if (vp == p || !letter(*vp))
93 	    stderror(ERR_NAME | ERR_VARBEGIN);
94 	if ((p - vp) > MAXVARLEN)
95 	    stderror(ERR_NAME | ERR_VARTOOLONG);
96 	if (*p == '[') {
97 	    hadsub++;
98 	    p = getinx(p, &subscr);
99 	}
100 	if ((op = *p) != '\0') {
101 	    *p++ = 0;
102 	    if (*p == 0 && *v && **v == '(')
103 		p = *v++;
104 	}
105 	else if (*v && eq(*v, STRequal)) {
106 	    op = '=', v++;
107 	    if (*v)
108 		p = *v++;
109 	}
110 	if (op && op != '=')
111 	    stderror(ERR_NAME | ERR_SYNTAX);
112 	if (eq(p, STRLparen)) {
113 	    Char **e = v;
114 
115 	    if (hadsub)
116 		stderror(ERR_NAME | ERR_SYNTAX);
117 	    for (;;) {
118 		if (!*e)
119 		    stderror(ERR_NAME | ERR_MISSING, ')');
120 		if (**e == ')')
121 		    break;
122 		e++;
123 	    }
124 	    p = *e;
125 	    *e = 0;
126 	    vecp = saveblk(v);
127 	    set1(vp, vecp, &shvhed);
128 	    *e = p;
129 	    v = e + 1;
130 	}
131 	else if (hadsub)
132 	    asx(vp, subscr, Strsave(p));
133 	else
134 	    set(vp, Strsave(p));
135 	if (eq(vp, STRpath)) {
136 	    exportpath(adrof(STRpath)->vec);
137 	    dohash(NULL, NULL);
138 	}
139 	else if (eq(vp, STRhistchars)) {
140 	    Char *pn = value(STRhistchars);
141 
142 	    HIST = *pn++;
143 	    HISTSUB = *pn;
144 	}
145 	else if (eq(vp, STRuser)) {
146 	    Setenv(STRUSER, value(vp));
147 	    Setenv(STRLOGNAME, value(vp));
148 	}
149 	else if (eq(vp, STRwordchars)) {
150 	    word_chars = value(vp);
151 	}
152 	else if (eq(vp, STRterm))
153 	    Setenv(STRTERM, value(vp));
154 	else if (eq(vp, STRhome)) {
155 	    Char *cp;
156 
157 	    cp = Strsave(value(vp));	/* get the old value back */
158 
159 	    /*
160 	     * convert to cononical pathname (possibly resolving symlinks)
161 	     */
162 	    cp = dcanon(cp, cp);
163 
164 	    set(vp, Strsave(cp));	/* have to save the new val */
165 
166 	    /* and now mirror home with HOME */
167 	    Setenv(STRHOME, cp);
168 	    /* fix directory stack for new tilde home */
169 	    dtilde();
170 	    xfree((ptr_t)cp);
171 	}
172 #ifdef FILEC
173 	else if (eq(vp, STRfilec))
174 	    filec = 1;
175 #endif
176     } while ((p = *v++) != NULL);
177 }
178 
179 static Char *
180 getinx(Char *cp, int *ip)
181 {
182     *ip = 0;
183     *cp++ = 0;
184     while (*cp && Isdigit(*cp))
185 	*ip = *ip * 10 + *cp++ - '0';
186     if (*cp++ != ']')
187 	stderror(ERR_NAME | ERR_SUBSCRIPT);
188     return (cp);
189 }
190 
191 static void
192 asx(Char *vp, int subscr, Char *p)
193 {
194     struct varent *v;
195 
196     v = getvx(vp, subscr);
197     xfree((ptr_t) v->vec[subscr - 1]);
198     v->vec[subscr - 1] = globone(p, G_APPEND);
199 }
200 
201 static struct varent *
202 getvx(Char *vp, int subscr)
203 {
204     struct varent *v;
205 
206     v = adrof(vp);
207     if (v == 0)
208 	udvar(vp);
209     if (subscr < 1 || subscr > blklen(v->vec))
210 	stderror(ERR_NAME | ERR_RANGE);
211     return (v);
212 }
213 
214 void
215 /*ARGSUSED*/
216 dolet(Char **v, struct command *t)
217 {
218     Char c, op, *p, *vp;
219     int subscr;
220     bool hadsub;
221 
222     v++;
223     p = *v++;
224     if (p == 0) {
225 	prvars();
226 	return;
227     }
228     do {
229 	hadsub = 0;
230 	vp = p;
231 	if (letter(*p))
232 	    for (; alnum(*p); p++)
233 		continue;
234 	if (vp == p || !letter(*vp))
235 	    stderror(ERR_NAME | ERR_VARBEGIN);
236 	if ((p - vp) > MAXVARLEN)
237 	    stderror(ERR_NAME | ERR_VARTOOLONG);
238 	if (*p == '[') {
239 	    hadsub++;
240 	    p = getinx(p, &subscr);
241 	}
242 	if (*p == 0 && *v)
243 	    p = *v++;
244 	if ((op = *p) != '\0')
245 	    *p++ = 0;
246 	else
247 	    stderror(ERR_NAME | ERR_ASSIGN);
248 
249 	if (*p == '\0' && *v == NULL)
250 	    stderror(ERR_NAME | ERR_ASSIGN);
251 
252 	vp = Strsave(vp);
253 	if (op == '=') {
254 	    c = '=';
255 	    p = xset(p, &v);
256 	}
257 	else {
258 	    c = *p++;
259 	    if (any("+-", c)) {
260 		if (c != op || *p)
261 		    stderror(ERR_NAME | ERR_UNKNOWNOP);
262 		p = Strsave(STR1);
263 	    }
264 	    else {
265 		if (any("<>", op)) {
266 		    if (c != op)
267 			stderror(ERR_NAME | ERR_UNKNOWNOP);
268 		    c = *p++;
269 		    stderror(ERR_NAME | ERR_SYNTAX);
270 		}
271 		if (c != '=')
272 		    stderror(ERR_NAME | ERR_UNKNOWNOP);
273 		p = xset(p, &v);
274 	    }
275 	}
276 	if (op == '=') {
277 	    if (hadsub)
278 		asx(vp, subscr, p);
279 	    else
280 		set(vp, p);
281 	} else if (hadsub) {
282 	    struct varent *gv = getvx(vp, subscr);
283 
284 	    asx(vp, subscr, operate(op, gv->vec[subscr - 1], p));
285 	}
286 	else
287 	    set(vp, operate(op, value(vp), p));
288 	if (eq(vp, STRpath)) {
289 	    exportpath(adrof(STRpath)->vec);
290 	    dohash(NULL, NULL);
291 	}
292 	xfree((ptr_t) vp);
293 	if (c != '=')
294 	    xfree((ptr_t) p);
295     } while ((p = *v++) != NULL);
296 }
297 
298 static Char *
299 xset(Char *cp, Char ***vp)
300 {
301     Char *dp;
302 
303     if (*cp) {
304 	dp = Strsave(cp);
305 	--(*vp);
306 	xfree((ptr_t) ** vp);
307 	**vp = dp;
308     }
309     return (putn(expr(vp)));
310 }
311 
312 static Char *
313 operate(int op, Char *vp, Char *p)
314 {
315     Char opr[2], **v, *vec[5], **vecp;
316     int i;
317 
318     v = vec;
319     vecp = v;
320     if (op != '=') {
321 	if (*vp)
322 	    *v++ = vp;
323 	opr[0] = op;
324 	opr[1] = 0;
325 	*v++ = opr;
326 	if (op == '<' || op == '>')
327 	    *v++ = opr;
328     }
329     *v++ = p;
330     *v++ = 0;
331     i = expr(&vecp);
332     if (*vecp)
333 	stderror(ERR_NAME | ERR_EXPRESSION);
334     return (putn(i));
335 }
336 
337 static Char *putp;
338 
339 Char *
340 putn(int n)
341 {
342     static Char numbers[15];
343     int num;
344 
345     putp = numbers;
346     if (n < 0) {
347 	n = -n;
348 	*putp++ = '-';
349     }
350     num = 2;			/* confuse lint */
351     if (sizeof(int) == num && ((unsigned int) n) == 0x8000) {
352 	*putp++ = '3';
353 	n = 2768;
354 #ifdef pdp11
355     }
356 #else
357     }
358     else {
359 	num = 4;		/* confuse lint */
360 	if (sizeof(int) == num && ((unsigned int) n) == 0x80000000) {
361 	    *putp++ = '2';
362 	    n = 147483648;
363 	}
364     }
365 #endif
366     putn1(n);
367     *putp = 0;
368     return (Strsave(numbers));
369 }
370 
371 static void
372 putn1(int n)
373 {
374     if (n > 9)
375 	putn1(n / 10);
376     *putp++ = n % 10 + '0';
377 }
378 
379 int
380 getn(Char *cp)
381 {
382     int n, sign;
383 
384     sign = 0;
385     if (cp[0] == '+' && cp[1])
386 	cp++;
387     if (*cp == '-') {
388 	sign++;
389 	cp++;
390 	if (!Isdigit(*cp))
391 	    stderror(ERR_NAME | ERR_BADNUM);
392     }
393     n = 0;
394     while (Isdigit(*cp))
395 	n = n * 10 + *cp++ - '0';
396     if (*cp)
397 	stderror(ERR_NAME | ERR_BADNUM);
398     return (sign ? -n : n);
399 }
400 
401 Char *
402 value1(Char *var, struct varent *head)
403 {
404     struct varent *vp;
405 
406     vp = adrof1(var, head);
407     return (vp == 0 || vp->vec[0] == 0 ? STRNULL : vp->vec[0]);
408 }
409 
410 static struct varent *
411 madrof(Char *pat, struct varent *vp)
412 {
413     struct varent *vp1;
414 
415     for (; vp; vp = vp->v_right) {
416 	if (vp->v_left && (vp1 = madrof(pat, vp->v_left)))
417 	    return vp1;
418 	if (Gmatch(vp->v_name, pat))
419 	    return vp;
420     }
421     return vp;
422 }
423 
424 struct varent *
425 adrof1(Char *name, struct varent *v)
426 {
427     int cmp;
428 
429     v = v->v_left;
430     while (v && ((cmp = *name - *v->v_name) ||
431 		 (cmp = Strcmp(name, v->v_name))))
432 	if (cmp < 0)
433 	    v = v->v_left;
434 	else
435 	    v = v->v_right;
436     return v;
437 }
438 
439 /*
440  * The caller is responsible for putting value in a safe place
441  */
442 void
443 set(Char *var, Char *val)
444 {
445     Char **vec;
446 
447     vec = (Char **)xmalloc((size_t)(2 * sizeof(Char **)));
448     vec[0] = val;
449     vec[1] = 0;
450     set1(var, vec, &shvhed);
451 }
452 
453 void
454 set1(Char *var, Char **vec, struct varent *head)
455 {
456     Char **oldv;
457 
458     oldv = vec;
459     gflag = 0;
460     tglob(oldv);
461     if (gflag) {
462 	vec = globall(oldv);
463 	if (vec == 0) {
464 	    blkfree(oldv);
465 	    stderror(ERR_NAME | ERR_NOMATCH);
466 	}
467 	blkfree(oldv);
468 	gargv = 0;
469     }
470     setq(var, vec, head);
471 }
472 
473 void
474 setq(Char *name, Char **vec, struct varent *p)
475 {
476     struct varent *c;
477     int f;
478 
479     f = 0;			/* tree hangs off the header's left link */
480     while ((c = p->v_link[f]) != NULL) {
481 	if ((f = *name - *c->v_name) == 0 &&
482 	    (f = Strcmp(name, c->v_name)) == 0) {
483 	    blkfree(c->vec);
484 	    goto found;
485 	}
486 	p = c;
487 	f = f > 0;
488     }
489     p->v_link[f] = c = (struct varent *)xmalloc((size_t)sizeof(struct varent));
490     c->v_name = Strsave(name);
491     c->v_bal = 0;
492     c->v_left = c->v_right = 0;
493     c->v_parent = p;
494     balance(p, f, 0);
495 found:
496     trim(c->vec = vec);
497 }
498 
499 void
500 /*ARGSUSED*/
501 unset(Char **v, struct command *t)
502 {
503     unset1(v, &shvhed);
504 #ifdef FILEC
505     if (adrof(STRfilec) == 0)
506 	filec = 0;
507 #endif
508     if (adrof(STRhistchars) == 0) {
509 	HIST = '!';
510 	HISTSUB = '^';
511     }
512     if (adrof(STRwordchars) == 0)
513 	word_chars = STR_WORD_CHARS;
514 }
515 
516 void
517 unset1(Char *v[], struct varent *head)
518 {
519     struct varent *vp;
520     int cnt;
521 
522     while (*++v) {
523 	cnt = 0;
524 	while ((vp = madrof(*v, head->v_left)) != NULL)
525 	    unsetv1(vp), cnt++;
526 	if (cnt == 0)
527 	    setname(vis_str(*v));
528     }
529 }
530 
531 void
532 unsetv(Char *var)
533 {
534     struct varent *vp;
535 
536     if ((vp = adrof1(var, &shvhed)) == 0)
537 	udvar(var);
538     unsetv1(vp);
539 }
540 
541 static void
542 unsetv1(struct varent *p)
543 {
544     struct varent *c, *pp;
545     int f;
546 
547     /*
548      * Free associated memory first to avoid complications.
549      */
550     blkfree(p->vec);
551     xfree((ptr_t) p->v_name);
552     /*
553      * If p is missing one child, then we can move the other into where p is.
554      * Otherwise, we find the predecessor of p, which is guaranteed to have no
555      * right child, copy it into p, and move it's left child into it.
556      */
557     if (p->v_right == 0)
558 	c = p->v_left;
559     else if (p->v_left == 0)
560 	c = p->v_right;
561     else {
562 	for (c = p->v_left; c->v_right; c = c->v_right)
563 	    continue;
564 	p->v_name = c->v_name;
565 	p->vec = c->vec;
566 	p = c;
567 	c = p->v_left;
568     }
569     /*
570      * Move c into where p is.
571      */
572     pp = p->v_parent;
573     f = pp->v_right == p;
574     if ((pp->v_link[f] = c) != NULL)
575 	c->v_parent = pp;
576     /*
577      * Free the deleted node, and rebalance.
578      */
579     xfree((ptr_t) p);
580     balance(pp, f, 1);
581 }
582 
583 void
584 setNS(Char *cp)
585 {
586     set(cp, Strsave(STRNULL));
587 }
588 
589 void
590 /*ARGSUSED*/
591 shift(Char **v, struct command *t)
592 {
593     struct varent *argv;
594     Char *name;
595 
596     v++;
597     name = *v;
598     if (name == 0)
599 	name = STRargv;
600     else
601 	(void) strip(name);
602     argv = adrof(name);
603     if (argv == 0)
604 	udvar(name);
605     if (argv->vec[0] == 0)
606 	stderror(ERR_NAME | ERR_NOMORE);
607     lshift(argv->vec, 1);
608 }
609 
610 static void
611 exportpath(Char **val)
612 {
613     Char exppath[BUFSIZE];
614 
615     exppath[0] = 0;
616     if (val)
617 	while (*val) {
618 	    if (Strlen(*val) + Strlen(exppath) + 2 > BUFSIZE) {
619 		(void)fprintf(csherr,
620 			       "Warning: ridiculously long PATH truncated\n");
621 		break;
622 	    }
623 	    (void)Strcat(exppath, *val++);
624 	    if (*val == 0 || eq(*val, STRRparen))
625 		break;
626 	    (void)Strcat(exppath, STRcolon);
627 	}
628     Setenv(STRPATH, exppath);
629 }
630 
631 #ifndef lint
632  /*
633   * Lint thinks these have null effect
634   */
635  /* macros to do single rotations on node p */
636 #define rright(p) (\
637 	t = (p)->v_left,\
638 	(t)->v_parent = (p)->v_parent,\
639 	((p)->v_left = t->v_right) ? (t->v_right->v_parent = (p)) : 0,\
640 	(t->v_right = (p))->v_parent = t,\
641 	(p) = t)
642 #define rleft(p) (\
643 	t = (p)->v_right,\
644 	(t)->v_parent = (p)->v_parent,\
645 	((p)->v_right = t->v_left) ? (t->v_left->v_parent = (p)) : 0,\
646 	(t->v_left = (p))->v_parent = t,\
647 	(p) = t)
648 #else
649 struct varent *
650 rleft(struct varent *p)
651 {
652     return (p);
653 }
654 struct varent *
655 rright(struct varent *p)
656 {
657     return (p);
658 }
659 #endif				/* ! lint */
660 
661 
662 /*
663  * Rebalance a tree, starting at p and up.
664  * F == 0 means we've come from p's left child.
665  * D == 1 means we've just done a delete, otherwise an insert.
666  */
667 static void
668 balance(struct varent *p, int f, int d)
669 {
670     struct varent *pp;
671 
672 #ifndef lint
673     struct varent *t;	/* used by the rotate macros */
674 
675 #endif
676     int ff;
677 
678     /*
679      * Ok, from here on, p is the node we're operating on; pp is it's parent; f
680      * is the branch of p from which we have come; ff is the branch of pp which
681      * is p.
682      */
683     for (; (pp = p->v_parent) != NULL; p = pp, f = ff) {
684 	ff = pp->v_right == p;
685 	if (f ^ d) {		/* right heavy */
686 	    switch (p->v_bal) {
687 	    case -1:		/* was left heavy */
688 		p->v_bal = 0;
689 		break;
690 	    case 0:		/* was balanced */
691 		p->v_bal = 1;
692 		break;
693 	    case 1:		/* was already right heavy */
694 		switch (p->v_right->v_bal) {
695 		case 1:	/* sigle rotate */
696 		    pp->v_link[ff] = rleft(p);
697 		    p->v_left->v_bal = 0;
698 		    p->v_bal = 0;
699 		    break;
700 		case 0:	/* single rotate */
701 		    pp->v_link[ff] = rleft(p);
702 		    p->v_left->v_bal = 1;
703 		    p->v_bal = -1;
704 		    break;
705 		case -1:	/* double rotate */
706 		    (void) rright(p->v_right);
707 		    pp->v_link[ff] = rleft(p);
708 		    p->v_left->v_bal =
709 			p->v_bal < 1 ? 0 : -1;
710 		    p->v_right->v_bal =
711 			p->v_bal > -1 ? 0 : 1;
712 		    p->v_bal = 0;
713 		    break;
714 		}
715 		break;
716 	    }
717 	}
718 	else {			/* left heavy */
719 	    switch (p->v_bal) {
720 	    case 1:		/* was right heavy */
721 		p->v_bal = 0;
722 		break;
723 	    case 0:		/* was balanced */
724 		p->v_bal = -1;
725 		break;
726 	    case -1:		/* was already left heavy */
727 		switch (p->v_left->v_bal) {
728 		case -1:	/* single rotate */
729 		    pp->v_link[ff] = rright(p);
730 		    p->v_right->v_bal = 0;
731 		    p->v_bal = 0;
732 		    break;
733 		case 0:	/* signle rotate */
734 		    pp->v_link[ff] = rright(p);
735 		    p->v_right->v_bal = -1;
736 		    p->v_bal = 1;
737 		    break;
738 		case 1:	/* double rotate */
739 		    (void) rleft(p->v_left);
740 		    pp->v_link[ff] = rright(p);
741 		    p->v_left->v_bal =
742 			p->v_bal < 1 ? 0 : -1;
743 		    p->v_right->v_bal =
744 			p->v_bal > -1 ? 0 : 1;
745 		    p->v_bal = 0;
746 		    break;
747 		}
748 		break;
749 	    }
750 	}
751 	/*
752 	 * If from insert, then we terminate when p is balanced. If from
753 	 * delete, then we terminate when p is unbalanced.
754 	 */
755 	if ((p->v_bal == 0) ^ d)
756 	    break;
757     }
758 }
759 
760 void
761 plist(struct varent *p)
762 {
763     struct varent *c;
764     sigset_t sigset;
765     int len;
766 
767     if (setintr) {
768 	sigemptyset(&sigset);
769 	(void)sigaddset(&sigset, SIGINT);
770 	(void)sigprocmask(SIG_UNBLOCK, &sigset, NULL);
771     }
772 
773     for (;;) {
774 	while (p->v_left)
775 	    p = p->v_left;
776 x:
777 	if (p->v_parent == 0)	/* is it the header? */
778 	    return;
779 	len = blklen(p->vec);
780 	(void)fprintf(cshout, "%s\t", short2str(p->v_name));
781 	if (len != 1)
782 	    (void)fputc('(', cshout);
783 	blkpr(cshout, p->vec);
784 	if (len != 1)
785 	    (void)fputc(')', cshout);
786 	(void)fputc('\n', cshout);
787 	if (p->v_right) {
788 	    p = p->v_right;
789 	    continue;
790 	}
791 	do {
792 	    c = p;
793 	    p = p->v_parent;
794 	} while (p->v_right == c);
795 	goto x;
796     }
797 }
798