Branch data Line data Source code
1 : : %{
2 : : /* contrib/cube/cubeparse.y */
3 : :
4 : : /* NdBox = [(lowerleft),(upperright)] */
5 : : /* [(xLL(1)...xLL(N)),(xUR(1)...xUR(n))] */
6 : :
7 : : #include "postgres.h"
8 : :
9 : : #include "cubedata.h"
10 : : #include "cubeparse.h" /* must be after cubedata.h for YYSTYPE and NDBOX */
11 : : #include "nodes/miscnodes.h"
12 : : #include "utils/float.h"
13 : : #include "varatt.h"
14 : :
15 : : /*
16 : : * Bison doesn't allocate anything that needs to live across parser calls,
17 : : * so we can easily have it use palloc instead of malloc. This prevents
18 : : * memory leaks if we error out during parsing.
19 : : */
20 : : #define YYMALLOC palloc
21 : : #define YYFREE pfree
22 : :
23 : : static int item_count(const char *s, char delim);
24 : : static bool write_box(int dim, char *str1, char *str2,
25 : : NDBOX **result, struct Node *escontext);
26 : : static bool write_point_as_box(int dim, char *str,
27 : : NDBOX **result, struct Node *escontext);
28 : :
29 : : %}
30 : :
31 : : /* BISON Declarations */
32 : : %parse-param {NDBOX **result}
33 : : %parse-param {Size scanbuflen}
34 : : %parse-param {struct Node *escontext}
35 : : %parse-param {yyscan_t yyscanner}
36 : : %lex-param {yyscan_t yyscanner}
37 : : %pure-parser
38 : : %expect 0
39 : : %name-prefix="cube_yy"
40 : :
41 : : %token CUBEFLOAT O_PAREN C_PAREN O_BRACKET C_BRACKET COMMA
42 : : %start box
43 : :
44 : : /* Grammar follows */
45 : : %%
46 : :
47 : : box: O_BRACKET paren_list COMMA paren_list C_BRACKET
48 : : {
49 : : int dim;
50 : :
51 : 16 : dim = item_count($2, ',');
52 [ + + ]: 16 : if (item_count($4, ',') != dim)
53 : : {
54 [ + - ]: 2 : errsave(escontext,
55 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
56 : : errmsg("invalid input syntax for cube"),
57 : : errdetail("Different point dimensions in (%s) and (%s).",
58 : : $2, $4)));
59 : 0 : YYABORT;
60 : : }
61 [ - + ]: 14 : if (dim > CUBE_MAX_DIM)
62 : : {
63 [ # # ]: 0 : errsave(escontext,
64 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
65 : : errmsg("invalid input syntax for cube"),
66 : : errdetail("A cube cannot have more than %d dimensions.",
67 : : CUBE_MAX_DIM)));
68 : 0 : YYABORT;
69 : : }
70 : :
71 [ - + ]: 14 : if (!write_box(dim, $2, $4, result, escontext))
72 : 0 : YYABORT;
73 : :
74 : : (void) yynerrs; /* suppress compiler warning */
75 : : }
76 : :
77 : : | paren_list COMMA paren_list
78 : : {
79 : : int dim;
80 : :
81 : 3246 : dim = item_count($1, ',');
82 [ + + ]: 3246 : if (item_count($3, ',') != dim)
83 : : {
84 [ + - ]: 2 : errsave(escontext,
85 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
86 : : errmsg("invalid input syntax for cube"),
87 : : errdetail("Different point dimensions in (%s) and (%s).",
88 : : $1, $3)));
89 : 0 : YYABORT;
90 : : }
91 [ + + ]: 3244 : if (dim > CUBE_MAX_DIM)
92 : : {
93 [ + - ]: 1 : errsave(escontext,
94 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
95 : : errmsg("invalid input syntax for cube"),
96 : : errdetail("A cube cannot have more than %d dimensions.",
97 : : CUBE_MAX_DIM)));
98 : 0 : YYABORT;
99 : : }
100 : :
101 [ - + ]: 3243 : if (!write_box(dim, $1, $3, result, escontext))
102 : 0 : YYABORT;
103 : : }
104 : :
105 : : | paren_list
106 : : {
107 : : int dim;
108 : :
109 : 69 : dim = item_count($1, ',');
110 [ + + ]: 69 : if (dim > CUBE_MAX_DIM)
111 : : {
112 [ + - ]: 1 : errsave(escontext,
113 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
114 : : errmsg("invalid input syntax for cube"),
115 : : errdetail("A cube cannot have more than %d dimensions.",
116 : : CUBE_MAX_DIM)));
117 : 0 : YYABORT;
118 : : }
119 : :
120 [ - + ]: 68 : if (!write_point_as_box(dim, $1, result, escontext))
121 : 0 : YYABORT;
122 : : }
123 : :
124 : : | list
125 : : {
126 : : int dim;
127 : :
128 : 89 : dim = item_count($1, ',');
129 [ - + ]: 89 : if (dim > CUBE_MAX_DIM)
130 : : {
131 [ # # ]: 0 : errsave(escontext,
132 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
133 : : errmsg("invalid input syntax for cube"),
134 : : errdetail("A cube cannot have more than %d dimensions.",
135 : : CUBE_MAX_DIM)));
136 : 0 : YYABORT;
137 : : }
138 : :
139 [ + + ]: 89 : if (!write_point_as_box(dim, $1, result, escontext))
140 : 2 : YYABORT;
141 : : }
142 : : ;
143 : :
144 : : paren_list: O_PAREN list C_PAREN
145 : : {
146 : 6596 : $$ = $2;
147 : : }
148 : : | O_PAREN C_PAREN
149 : : {
150 : 4 : $$ = pstrdup("");
151 : : }
152 : : ;
153 : :
154 : : list: CUBEFLOAT
155 : : {
156 : : /* alloc enough space to be sure whole list will fit */
157 : 6691 : $$ = palloc(scanbuflen + 1);
158 : 6691 : strcpy($$, $1);
159 : : }
160 : : | list COMMA CUBEFLOAT
161 : : {
162 : 7368 : $$ = $1;
163 : 7368 : strcat($$, ",");
164 : 7368 : strcat($$, $3);
165 : : }
166 : : ;
167 : :
168 : : %%
169 : :
170 : : /* This assumes the string has been normalized by productions above */
171 : : static int
172 : 6682 : item_count(const char *s, char delim)
173 : : {
174 : 6682 : int nitems = 0;
175 : :
176 [ + + ]: 6682 : if (s[0] != '\0')
177 : : {
178 : 6679 : nitems++;
179 [ + + ]: 14045 : while ((s = strchr(s, delim)) != NULL)
180 : : {
181 : 7366 : nitems++;
182 : 7366 : s++;
183 : : }
184 : : }
185 : 6682 : return nitems;
186 : : }
187 : :
188 : : static bool
189 : 3257 : write_box(int dim, char *str1, char *str2,
190 : : NDBOX **result, struct Node *escontext)
191 : : {
192 : : NDBOX *bp;
193 : : char *s;
194 : : char *endptr;
195 : : int i;
196 : 3257 : int size = CUBE_SIZE(dim);
197 : 3257 : bool point = true;
198 : :
199 : 3257 : bp = palloc0(size);
200 : 3257 : SET_VARSIZE(bp, size);
201 : 3257 : SET_DIM(bp, dim);
202 : :
203 : 3257 : s = str1;
204 : 3257 : i = 0;
205 [ + + ]: 3257 : if (dim > 0)
206 : : {
207 : 3256 : bp->x[i++] = float8in_internal(s, &endptr, "cube", str1, escontext);
208 [ - + - - : 3256 : if (SOFT_ERROR_OCCURRED(escontext))
- - ]
209 : 0 : return false;
210 : : }
211 [ + + ]: 6576 : while ((s = strchr(s, ',')) != NULL)
212 : : {
213 : 3319 : s++;
214 : 3319 : bp->x[i++] = float8in_internal(s, &endptr, "cube", str1, escontext);
215 [ - + - - : 3319 : if (SOFT_ERROR_OCCURRED(escontext))
- - ]
216 : 0 : return false;
217 : : }
218 : : Assert(i == dim);
219 : :
220 : 3257 : s = str2;
221 [ + + ]: 3257 : if (dim > 0)
222 : : {
223 : 3256 : bp->x[i] = float8in_internal(s, &endptr, "cube", str2, escontext);
224 [ - + - - : 3256 : if (SOFT_ERROR_OCCURRED(escontext))
- - ]
225 : 0 : return false;
226 : : /* code this way to do right thing with NaN */
227 : 3256 : point &= (bp->x[i] == bp->x[0]);
228 : 3256 : i++;
229 : : }
230 [ + + ]: 6576 : while ((s = strchr(s, ',')) != NULL)
231 : : {
232 : 3319 : s++;
233 : 3319 : bp->x[i] = float8in_internal(s, &endptr, "cube", str2, escontext);
234 [ - + - - : 3319 : if (SOFT_ERROR_OCCURRED(escontext))
- - ]
235 : 0 : return false;
236 : 3319 : point &= (bp->x[i] == bp->x[i - dim]);
237 : 3319 : i++;
238 : : }
239 : : Assert(i == dim * 2);
240 : :
241 [ + + ]: 3257 : if (point)
242 : : {
243 : : /*
244 : : * The value turned out to be a point, ie. all the upper-right
245 : : * coordinates were equal to the lower-left coordinates. Resize the
246 : : * cube we constructed. Note: we don't bother to repalloc() it
247 : : * smaller, as it's unlikely that the tiny amount of memory freed that
248 : : * way would be useful, and the output is always short-lived.
249 : : */
250 : 25 : size = POINT_SIZE(dim);
251 : 25 : SET_VARSIZE(bp, size);
252 : 25 : SET_POINT_BIT(bp);
253 : : }
254 : :
255 : 3257 : *result = bp;
256 : 3257 : return true;
257 : : }
258 : :
259 : : static bool
260 : 157 : write_point_as_box(int dim, char *str,
261 : : NDBOX **result, struct Node *escontext)
262 : : {
263 : : NDBOX *bp;
264 : : int i,
265 : : size;
266 : : char *s;
267 : : char *endptr;
268 : :
269 : 157 : size = POINT_SIZE(dim);
270 : 157 : bp = palloc0(size);
271 : 157 : SET_VARSIZE(bp, size);
272 : 157 : SET_DIM(bp, dim);
273 : 157 : SET_POINT_BIT(bp);
274 : :
275 : 157 : s = str;
276 : 157 : i = 0;
277 [ + + ]: 157 : if (dim > 0)
278 : : {
279 : 156 : bp->x[i++] = float8in_internal(s, &endptr, "cube", str, escontext);
280 [ + + + - : 155 : if (SOFT_ERROR_OCCURRED(escontext))
+ + ]
281 : 2 : return false;
282 : : }
283 [ + + ]: 276 : while ((s = strchr(s, ',')) != NULL)
284 : : {
285 : 122 : s++;
286 : 122 : bp->x[i++] = float8in_internal(s, &endptr, "cube", str, escontext);
287 [ + + + - : 122 : if (SOFT_ERROR_OCCURRED(escontext))
- + ]
288 : 0 : return false;
289 : : }
290 : : Assert(i == dim);
291 : :
292 : 154 : *result = bp;
293 : 154 : return true;
294 : : }
|
