window(1): Remove __RCSID & friends.
[dragonfly.git] / usr.bin / window / var.c
1 /*      @(#)var.c       8.1 (Berkeley) 6/6/93   */
2 /*      $NetBSD: var.c,v 1.10 2009/04/14 08:50:06 lukem Exp $   */
3
4 /*
5  * Copyright (c) 1983, 1993
6  *      The Regents of the University of California.  All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Edward Wang at The University of California, Berkeley.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. 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 <stdlib.h>
37 #include <string.h>
38 #include "value.h"
39 #define EXTERN
40 #include "var.h"
41 #undef  EXTERN
42 #include "window_string.h"
43
44 struct var *
45 var_set1(struct var **head, const char *name, struct value *v)
46 {
47         struct var **p;
48         struct var *r;
49         struct value val;
50
51         /* do this first, easier to recover */
52         val = *v;
53         if (val.v_type == V_STR && val.v_str != 0 &&
54             (val.v_str = str_cpy(val.v_str)) == 0)
55                 return 0;
56         if (*(p = var_lookup1(head, name)) == 0) {
57                 r = (struct var *) malloc(sizeof (struct var));
58                 if (r == 0) {
59                         val_free(val);
60                         return 0;
61                 }
62                 if ((r->r_name = str_cpy(name)) == 0) {
63                         val_free(val);
64                         free((char *) r);
65                         return 0;
66                 }
67                 r->r_left = r->r_right = 0;
68                 *p = r;
69         } else {
70                 r = *p;
71                 val_free(r->r_val);
72         }
73         r->r_val = val;
74         return r;
75 }
76
77 struct var *
78 var_setstr1(struct var **head, const char *name, char *str)
79 {
80         struct value v;
81
82         v.v_type = V_STR;
83         v.v_str = str;
84         return var_set1(head, name, &v);
85 }
86
87 struct var *
88 var_setnum1(struct var **head, const char *name, int num)
89 {
90         struct value v;
91
92         v.v_type = V_NUM;
93         v.v_num = num;
94         return var_set1(head, name, &v);
95 }
96
97 int
98 var_unset1(struct var **head, const char *name)
99 {
100         struct var **p;
101         struct var *r;
102
103         if (*(p = var_lookup1(head, name)) == 0)
104                 return -1;
105         r = *p;
106         *p = r->r_left;
107         while (*p != 0)
108                 p = &(*p)->r_right;
109         *p = r->r_right;
110         val_free(r->r_val);
111         str_free(r->r_name);
112         free((char *) r);
113         return 0;
114 }
115
116 struct var **
117 var_lookup1(struct var **p, const char *name)
118 {
119         int cmp;
120
121         while (*p != 0) {
122                 if ((cmp = strcmp(name, (*p)->r_name)) < 0)
123                         p = &(*p)->r_left;
124                 else if (cmp > 0)
125                         p = &(*p)->r_right;
126                 else
127                         break;
128         }
129         return p;
130 }
131
132 int
133 var_walk1(struct var *r, int (*func) (void *, struct var *), void *a)
134 {
135         if (r == 0)
136                 return 0;
137         if (var_walk1(r->r_left, func, a) < 0 || (*func)(a, r) < 0
138             || var_walk1(r->r_right, func, a) < 0)
139                 return -1;
140         return 0;
141 }