Branch data Line data Source code
1 : : /* src/interfaces/ecpg/preproc/variable.c */
2 : :
3 : : #include "postgres_fe.h"
4 : :
5 : : #include "preproc_extern.h"
6 : :
7 : : static struct variable *allvariables = NULL;
8 : :
9 : : /* this probably belongs in util.c, but for now it's only needed here */
10 : : static char *
11 : 165 : loc_nstrdup(const char *in, size_t len)
12 : : {
13 : : char *out;
14 : :
15 : 165 : out = loc_alloc(len + 1);
16 : 165 : memcpy(out, in, len);
17 : 165 : out[len] = '\0';
18 : :
19 : 165 : return out;
20 : : }
21 : :
22 : : struct variable *
23 : 531 : new_variable(const char *name, struct ECPGtype *type, int brace_level)
24 : : {
25 : 531 : struct variable *p = (struct variable *) mm_alloc(sizeof(struct variable));
26 : :
27 : 531 : p->name = mm_strdup(name);
28 : 531 : p->type = type;
29 : 531 : p->brace_level = brace_level;
30 : :
31 : 531 : p->next = allvariables;
32 : 531 : allvariables = p;
33 : :
34 : 531 : return p;
35 : : }
36 : :
37 : : /*
38 : : * Perform lookup of a field within a struct
39 : : *
40 : : * 'name' is the entire C variable name
41 : : * 'str' points just before the next field name to parse
42 : : * 'members' and 'brace_level' describe the struct we are looking into
43 : : *
44 : : * Returns NULL if field is not found.
45 : : *
46 : : * This recurses if needed to handle sub-fields.
47 : : */
48 : : static struct variable *
49 : 65 : find_struct_member(const char *name, const char *str,
50 : : struct ECPGstruct_member *members, int brace_level)
51 : : {
52 : : /* ++ here skips over the '.', or the '>' of '->' */
53 : 65 : const char *next = strpbrk(++str, ".-["),
54 : : *end,
55 : : *field;
56 : :
57 [ + + ]: 65 : if (next != NULL)
58 : 12 : field = loc_nstrdup(str, next - str);
59 : : else
60 : 53 : field = str;
61 : :
62 [ + - ]: 104 : for (; members; members = members->next)
63 : : {
64 [ + + ]: 104 : if (strcmp(members->name, field) == 0)
65 : : {
66 [ + + ]: 65 : if (next == NULL)
67 : : {
68 : : /* found the end */
69 [ - - + ]: 53 : switch (members->type->type)
70 : : {
71 : 0 : case ECPGt_array:
72 : 0 : return new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(members->type->u.element->type, members->type->u.element->size, members->type->u.element->counter), members->type->size), brace_level);
73 : 0 : case ECPGt_struct:
74 : : case ECPGt_union:
75 : 0 : return new_variable(name, ECPGmake_struct_type(members->type->u.members, members->type->type, members->type->type_name, members->type->struct_sizeof), brace_level);
76 : 53 : default:
77 : 53 : return new_variable(name, ECPGmake_simple_type(members->type->type, members->type->size, members->type->counter), brace_level);
78 : : }
79 : : }
80 : : else
81 : : {
82 [ + - ]: 12 : if (*next == '[')
83 : : {
84 : : int count;
85 : :
86 : : /*
87 : : * We don't care about what's inside the array brackets so
88 : : * just scan to find the matching right bracket.
89 : : */
90 [ + + ]: 36 : for (count = 1, end = next + 1; count; end++)
91 : : {
92 [ - + + ]: 24 : switch (*end)
93 : : {
94 : 0 : case '[':
95 : 0 : count++;
96 : 0 : break;
97 : 12 : case ']':
98 : 12 : count--;
99 : 12 : break;
100 : 12 : default:
101 : 12 : break;
102 : : }
103 : : }
104 : : }
105 : : else
106 : 0 : end = next;
107 : :
108 [ - - + - ]: 12 : switch (*end)
109 : : {
110 : 0 : case '\0': /* found the end, but this time it has to be
111 : : * an array element */
112 [ # # ]: 0 : if (members->type->type != ECPGt_array)
113 : 0 : mmfatal(PARSE_ERROR, "incorrectly formed variable \"%s\"", name);
114 : :
115 [ # # # ]: 0 : switch (members->type->u.element->type)
116 : : {
117 : 0 : case ECPGt_array:
118 : 0 : return new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(members->type->u.element->u.element->type, members->type->u.element->u.element->size, members->type->u.element->u.element->counter), members->type->u.element->size), brace_level);
119 : 0 : case ECPGt_struct:
120 : : case ECPGt_union:
121 : 0 : return new_variable(name, ECPGmake_struct_type(members->type->u.element->u.members, members->type->u.element->type, members->type->u.element->type_name, members->type->u.element->struct_sizeof), brace_level);
122 : 0 : default:
123 : 0 : return new_variable(name, ECPGmake_simple_type(members->type->u.element->type, members->type->u.element->size, members->type->u.element->counter), brace_level);
124 : : }
125 : : break;
126 : 0 : case '-':
127 [ # # ]: 0 : if (members->type->type == ECPGt_array)
128 : 0 : return find_struct_member(name, ++end, members->type->u.element->u.members, brace_level);
129 : : else
130 : 0 : return find_struct_member(name, ++end, members->type->u.members, brace_level);
131 : : break;
132 : 12 : case '.':
133 [ - + ]: 12 : if (members->type->type == ECPGt_array)
134 : 0 : return find_struct_member(name, end, members->type->u.element->u.members, brace_level);
135 : : else
136 : 12 : return find_struct_member(name, end, members->type->u.members, brace_level);
137 : : break;
138 : 0 : default:
139 : 0 : mmfatal(PARSE_ERROR, "incorrectly formed variable \"%s\"", name);
140 : : break;
141 : : }
142 : : }
143 : : }
144 : : }
145 : :
146 : 0 : return NULL;
147 : : }
148 : :
149 : : /*
150 : : * Do struct lookup when we have found var.field, var->field, or var[n].field
151 : : *
152 : : * 'name' is the entire C variable name
153 : : * 'next' points at the character after the base name
154 : : * 'end' points at the character after the subscript, if there was a
155 : : * subscript, else it's the same as 'next'.
156 : : *
157 : : * This is used only at the first level of field reference; sub-fields will
158 : : * be handled by internal recursion in find_struct_member.
159 : : */
160 : : static struct variable *
161 : 53 : find_struct(const char *name, const char *next, const char *end)
162 : : {
163 : : char *prefix;
164 : : struct variable *p;
165 : :
166 : : /* first get the mother structure entry */
167 : 53 : prefix = loc_nstrdup(name, next - name);
168 : 53 : p = find_variable(prefix);
169 : :
170 [ + + ]: 53 : if (*next == '-')
171 : : {
172 : : /* We have var->field */
173 [ - + ]: 6 : if (p->type->type != ECPGt_array)
174 : 0 : mmfatal(PARSE_ERROR, "variable \"%s\" is not a pointer", prefix);
175 : :
176 [ - + - - ]: 6 : if (p->type->u.element->type != ECPGt_struct && p->type->u.element->type != ECPGt_union)
177 : 0 : mmfatal(PARSE_ERROR, "variable \"%s\" is not a pointer to a structure or a union", prefix);
178 : :
179 : 6 : return find_struct_member(name, ++end, p->type->u.element->u.members, p->brace_level);
180 : : }
181 : : else
182 : : {
183 [ + + ]: 47 : if (next == end)
184 : : {
185 : : /* We have var.field */
186 [ + + - + ]: 41 : if (p->type->type != ECPGt_struct && p->type->type != ECPGt_union)
187 : 0 : mmfatal(PARSE_ERROR, "variable \"%s\" is neither a structure nor a union", prefix);
188 : :
189 : 41 : return find_struct_member(name, end, p->type->u.members, p->brace_level);
190 : : }
191 : : else
192 : : {
193 : : /* We have var[n].field */
194 [ - + ]: 6 : if (p->type->type != ECPGt_array)
195 : 0 : mmfatal(PARSE_ERROR, "variable \"%s\" is not an array", prefix);
196 : :
197 [ - + - - ]: 6 : if (p->type->u.element->type != ECPGt_struct && p->type->u.element->type != ECPGt_union)
198 : 0 : mmfatal(PARSE_ERROR, "variable \"%s\" is not a pointer to a structure or a union", prefix);
199 : :
200 : 6 : return find_struct_member(name, end, p->type->u.element->u.members, p->brace_level);
201 : : }
202 : : }
203 : : }
204 : :
205 : : /* Look up a variable given its base name */
206 : : static struct variable *
207 : 1421 : find_simple(const char *name)
208 : : {
209 : : struct variable *p;
210 : :
211 [ + - ]: 11578 : for (p = allvariables; p; p = p->next)
212 : : {
213 [ + + ]: 11578 : if (strcmp(p->name, name) == 0)
214 : 1421 : return p;
215 : : }
216 : :
217 : 0 : return NULL;
218 : : }
219 : :
220 : : /*
221 : : * Build a "struct variable" for a C variable reference.
222 : : *
223 : : * The given "name" string is a CVARIABLE per pgc.l, so it can include not
224 : : * only a base variable name but also ".field", "->field", or "[subscript]"
225 : : * decoration. We don't need to understand that fully, because we always
226 : : * duplicate the whole string into the name field of the result variable
227 : : * and emit it literally to the output file; the C compiler will make sense
228 : : * of it later. What we do need to do here is identify the type of the
229 : : * target field or array element so that we can attach a correct ECPGtype
230 : : * struct to the result.
231 : : *
232 : : * Note that this function will end the program in case of an unknown variable.
233 : : */
234 : : struct variable *
235 : 1474 : find_variable(const char *name)
236 : : {
237 : : const char *next,
238 : : *end;
239 : : struct variable *p;
240 : : int count;
241 : :
242 : 1474 : next = strpbrk(name, ".[-");
243 [ + + ]: 1474 : if (next)
244 : : {
245 : : /* Deal with field/subscript decoration */
246 [ + + ]: 153 : if (*next == '[')
247 : : {
248 : : /*
249 : : * We don't care about what's inside the array brackets so just
250 : : * scan to find the matching right bracket.
251 : : */
252 [ + + ]: 318 : for (count = 1, end = next + 1; count; end++)
253 : : {
254 [ - + - + ]: 212 : switch (*end)
255 : : {
256 : 0 : case '[':
257 : 0 : count++;
258 : 0 : break;
259 : 106 : case ']':
260 : 106 : count--;
261 : 106 : break;
262 : 0 : case '\0':
263 : 0 : mmfatal(PARSE_ERROR, "unmatched bracket in variable \"%s\"", name);
264 : : break;
265 : 106 : default:
266 : 106 : break;
267 : : }
268 : : }
269 [ + + ]: 106 : if (*end == '.')
270 : : {
271 : : /* We have var[n].field */
272 : 6 : p = find_struct(name, next, end);
273 : : }
274 : : else
275 : : {
276 : : /*
277 : : * Note: this part assumes we must just have var[n] without
278 : : * any further decoration, which fails to handle cases such as
279 : : * var[n]->field. For now, that's okay because
280 : : * pointer-to-pointer variables are rejected elsewhere.
281 : : */
282 : 100 : char *prefix = loc_nstrdup(name, next - name);
283 : :
284 : 100 : p = find_simple(prefix);
285 [ - + ]: 100 : if (p == NULL)
286 : 0 : mmfatal(PARSE_ERROR, "variable \"%s\" is not declared", prefix);
287 [ - + ]: 100 : if (p->type->type != ECPGt_array)
288 : 0 : mmfatal(PARSE_ERROR, "variable \"%s\" is not a pointer", prefix);
289 [ - + + ]: 100 : switch (p->type->u.element->type)
290 : : {
291 : 0 : case ECPGt_array:
292 : 0 : return new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(p->type->u.element->u.element->type, p->type->u.element->u.element->size, p->type->u.element->u.element->counter), p->type->u.element->size), p->brace_level);
293 : 3 : case ECPGt_struct:
294 : : case ECPGt_union:
295 : 3 : return new_variable(name, ECPGmake_struct_type(p->type->u.element->u.members, p->type->u.element->type, p->type->u.element->type_name, p->type->u.element->struct_sizeof), p->brace_level);
296 : 97 : default:
297 : 97 : return new_variable(name, ECPGmake_simple_type(p->type->u.element->type, p->type->u.element->size, p->type->u.element->counter), p->brace_level);
298 : : }
299 : : }
300 : : }
301 : : else
302 : : {
303 : : /* Must be var.field or var->field */
304 : 47 : p = find_struct(name, next, next);
305 : : }
306 : : }
307 : : else
308 : 1321 : p = find_simple(name);
309 : :
310 [ - + ]: 1374 : if (p == NULL)
311 : 0 : mmfatal(PARSE_ERROR, "variable \"%s\" is not declared", name);
312 : :
313 : 1374 : return p;
314 : : }
315 : :
316 : : void
317 : 334 : remove_typedefs(int brace_level)
318 : : {
319 : : struct typedefs *p,
320 : : *prev,
321 : : *next;
322 : :
323 [ + + ]: 498 : for (p = types, prev = NULL; p; p = next)
324 : : {
325 : 164 : next = p->next;
326 [ + + ]: 164 : if (p->brace_level >= brace_level)
327 : : {
328 : : /* remove it */
329 [ - + ]: 14 : if (prev)
330 : 0 : prev->next = next;
331 : : else
332 : 14 : types = next;
333 : :
334 [ + + - + ]: 14 : if (p->type->type_enum == ECPGt_struct || p->type->type_enum == ECPGt_union)
335 : 12 : ECPGfree_struct_member(p->struct_member_list);
336 : 14 : free(p->type->type_storage);
337 : 14 : free(p->type->type_str);
338 : 14 : free(p->type->type_dimension);
339 : 14 : free(p->type->type_index);
340 : 14 : free(p->type->type_sizeof);
341 : 14 : free(p->type);
342 : 14 : free(p->name);
343 : 14 : free(p);
344 : : }
345 : : else
346 : 150 : prev = p;
347 : : }
348 : 334 : }
349 : :
350 : : void
351 : 334 : remove_variables(int brace_level)
352 : : {
353 : : struct variable *p,
354 : : *prev,
355 : : *next;
356 : :
357 [ + + ]: 1691 : for (p = allvariables, prev = NULL; p; p = next)
358 : : {
359 : 1357 : next = p->next;
360 [ + + ]: 1357 : if (p->brace_level >= brace_level)
361 : : {
362 : : /* remove it, but first remove any references from cursors */
363 : : struct cursor *ptr;
364 : :
365 [ + + ]: 805 : for (ptr = cur; ptr != NULL; ptr = ptr->next)
366 : : {
367 : : struct arguments *varptr,
368 : : *prevvar,
369 : : *nextvar;
370 : :
371 : 377 : for (varptr = ptr->argsinsert, prevvar = NULL;
372 [ + + ]: 642 : varptr != NULL; varptr = nextvar)
373 : : {
374 : 265 : nextvar = varptr->next;
375 [ + + ]: 265 : if (p == varptr->variable)
376 : : {
377 : : /* remove from list */
378 [ + + ]: 12 : if (prevvar)
379 : 3 : prevvar->next = nextvar;
380 : : else
381 : 9 : ptr->argsinsert = nextvar;
382 : 12 : free(varptr);
383 : : }
384 : : else
385 : 253 : prevvar = varptr;
386 : : }
387 : 377 : for (varptr = ptr->argsresult, prevvar = NULL;
388 [ + + ]: 382 : varptr != NULL; varptr = nextvar)
389 : : {
390 : 5 : nextvar = varptr->next;
391 [ + + ]: 5 : if (p == varptr->variable)
392 : : {
393 : : /* remove from list */
394 [ - + ]: 3 : if (prevvar)
395 : 0 : prevvar->next = nextvar;
396 : : else
397 : 3 : ptr->argsresult = nextvar;
398 : 3 : free(varptr);
399 : : }
400 : : else
401 : 2 : prevvar = varptr;
402 : : }
403 : : }
404 : :
405 : : /* remove it */
406 [ + + ]: 428 : if (prev)
407 : 167 : prev->next = next;
408 : : else
409 : 261 : allvariables = next;
410 : :
411 : 428 : ECPGfree_type(p->type);
412 : 428 : free(p->name);
413 : 428 : free(p);
414 : : }
415 : : else
416 : 929 : prev = p;
417 : : }
418 : 334 : }
419 : :
420 : :
421 : : /*
422 : : * Here are the variables that need to be handled on every request.
423 : : * These are of two kinds: input and output.
424 : : * I will make two lists for them.
425 : : */
426 : :
427 : : struct arguments *argsinsert = NULL;
428 : : struct arguments *argsresult = NULL;
429 : :
430 : : void
431 : 1508 : reset_variables(void)
432 : : {
433 : : struct arguments *p,
434 : : *next;
435 : :
436 [ + + ]: 1510 : for (p = argsinsert; p; p = next)
437 : : {
438 : 2 : next = p->next;
439 : 2 : free(p);
440 : : }
441 : 1508 : argsinsert = NULL;
442 [ - + ]: 1508 : for (p = argsresult; p; p = next)
443 : : {
444 : 0 : next = p->next;
445 : 0 : free(p);
446 : : }
447 : 1508 : argsresult = NULL;
448 : 1508 : }
449 : :
450 : : /*
451 : : * Insert a new variable into our request list.
452 : : * Note: The list is dumped from the end,
453 : : * so we have to add new entries at the beginning
454 : : */
455 : : void
456 : 528 : add_variable_to_head(struct arguments **list, struct variable *var, struct variable *ind)
457 : : {
458 : 528 : struct arguments *p = (struct arguments *) mm_alloc(sizeof(struct arguments));
459 : :
460 : 528 : p->variable = var;
461 : 528 : p->indicator = ind;
462 : 528 : p->next = *list;
463 : 528 : *list = p;
464 : 528 : }
465 : :
466 : : /* Append a new variable to our request list. */
467 : : void
468 : 99 : add_variable_to_tail(struct arguments **list, struct variable *var, struct variable *ind)
469 : : {
470 : : struct arguments *p,
471 : 99 : *new = (struct arguments *) mm_alloc(sizeof(struct arguments));
472 : :
473 [ + + + + ]: 106 : for (p = *list; p && p->next; p = p->next);
474 : :
475 : 99 : new->variable = var;
476 : 99 : new->indicator = ind;
477 : 99 : new->next = NULL;
478 : :
479 [ + + ]: 99 : if (p)
480 : 26 : p->next = new;
481 : : else
482 : 73 : *list = new;
483 : 99 : }
484 : :
485 : : void
486 : 17 : remove_variable_from_list(struct arguments **list, struct variable *var)
487 : : {
488 : : struct arguments *p,
489 : 17 : *prev = NULL;
490 : 17 : bool found = false;
491 : :
492 [ + - ]: 17 : for (p = *list; p; p = p->next)
493 : : {
494 [ + - ]: 17 : if (p->variable == var)
495 : : {
496 : 17 : found = true;
497 : 17 : break;
498 : : }
499 : 0 : prev = p;
500 : : }
501 [ + - ]: 17 : if (found)
502 : : {
503 [ - + ]: 17 : if (prev)
504 : 0 : prev->next = p->next;
505 : : else
506 : 17 : *list = p->next;
507 : 17 : free(p);
508 : : }
509 : 17 : }
510 : :
511 : : /*
512 : : * Dump out a list of all the variable on this list.
513 : : * This is a recursive function that works from the end of the list and
514 : : * deletes the list as we go on.
515 : : */
516 : : void
517 : 1711 : dump_variables(struct arguments *list, int mode)
518 : : {
519 : : char *str_zero;
520 : :
521 [ + + ]: 1711 : if (list == NULL)
522 : 1175 : return;
523 : :
524 : 536 : str_zero = mm_strdup("0");
525 : :
526 : : /*
527 : : * The list is build up from the beginning so lets first dump the end of
528 : : * the list:
529 : : */
530 : :
531 : 536 : dump_variables(list->next, mode);
532 : :
533 : : /* Then the current element and its indicator */
534 : 536 : ECPGdump_a_type(base_yyout, list->variable->name, list->variable->type, list->variable->brace_level,
535 : 536 : list->indicator->name, list->indicator->type, list->indicator->brace_level,
536 : : NULL, NULL, str_zero, NULL, NULL);
537 : :
538 : : /* Then release the list element. */
539 [ + - ]: 536 : if (mode != 0)
540 : 536 : free(list);
541 : :
542 : 536 : free(str_zero);
543 : : }
544 : :
545 : : void
546 : 67 : check_indicator(struct ECPGtype *var)
547 : : {
548 : : /* make sure this is a valid indicator variable */
549 [ + + + - ]: 67 : switch (var->type)
550 : : {
551 : : struct ECPGstruct_member *p;
552 : :
553 : 45 : case ECPGt_short:
554 : : case ECPGt_int:
555 : : case ECPGt_long:
556 : : case ECPGt_long_long:
557 : : case ECPGt_unsigned_short:
558 : : case ECPGt_unsigned_int:
559 : : case ECPGt_unsigned_long:
560 : : case ECPGt_unsigned_long_long:
561 : 45 : break;
562 : :
563 : 11 : case ECPGt_struct:
564 : : case ECPGt_union:
565 [ + + ]: 36 : for (p = var->u.members; p; p = p->next)
566 : 25 : check_indicator(p->type);
567 : 11 : break;
568 : :
569 : 11 : case ECPGt_array:
570 : 11 : check_indicator(var->u.element);
571 : 11 : break;
572 : 0 : default:
573 : 0 : mmerror(PARSE_ERROR, ET_ERROR, "indicator variable must have an integer type");
574 : 0 : break;
575 : : }
576 : 67 : }
577 : :
578 : : struct typedefs *
579 : 5978 : get_typedef(const char *name, bool noerror)
580 : : {
581 : : struct typedefs *this;
582 : :
583 [ + + ]: 9575 : for (this = types; this != NULL; this = this->next)
584 : : {
585 [ + + ]: 3633 : if (strcmp(this->name, name) == 0)
586 : 36 : return this;
587 : : }
588 : :
589 [ - + ]: 5942 : if (!noerror)
590 : 0 : mmfatal(PARSE_ERROR, "unrecognized data type name \"%s\"", name);
591 : :
592 : 5942 : return NULL;
593 : : }
594 : :
595 : : void
596 : 400 : adjust_array(enum ECPGttype type_enum,
597 : : const char **dimension, const char **length,
598 : : const char *type_dimension, const char *type_index,
599 : : int pointer_len, bool type_definition)
600 : : {
601 [ + + ]: 400 : if (atoi(type_index) >= 0)
602 : : {
603 [ - + ]: 6 : if (atoi(*length) >= 0)
604 : 0 : mmfatal(PARSE_ERROR, "multidimensional arrays are not supported");
605 : :
606 : 6 : *length = type_index;
607 : : }
608 : :
609 [ + + ]: 400 : if (atoi(type_dimension) >= 0)
610 : : {
611 [ - + - - ]: 1 : if (atoi(*dimension) >= 0 && atoi(*length) >= 0)
612 : 0 : mmfatal(PARSE_ERROR, "multidimensional arrays are not supported");
613 : :
614 [ - + ]: 1 : if (atoi(*dimension) >= 0)
615 : 0 : *length = *dimension;
616 : :
617 : 1 : *dimension = type_dimension;
618 : : }
619 : :
620 [ - + ]: 400 : if (pointer_len > 2)
621 : 0 : mmfatal(PARSE_ERROR, ngettext("multilevel pointers (more than 2 levels) are not supported; found %d level",
622 : : "multilevel pointers (more than 2 levels) are not supported; found %d levels", pointer_len),
623 : : pointer_len);
624 : :
625 [ + + - + : 400 : if (pointer_len > 1 && type_enum != ECPGt_char && type_enum != ECPGt_unsigned_char && type_enum != ECPGt_string)
- - - - ]
626 : 0 : mmfatal(PARSE_ERROR, "pointer to pointer is not supported for this data type");
627 : :
628 [ + + + - : 400 : if (pointer_len > 1 && (atoi(*length) >= 0 || atoi(*dimension) >= 0))
- + ]
629 : 0 : mmfatal(PARSE_ERROR, "multidimensional arrays are not supported");
630 : :
631 [ + + + + : 400 : if (atoi(*length) >= 0 && atoi(*dimension) >= 0 && pointer_len)
- + ]
632 : 0 : mmfatal(PARSE_ERROR, "multidimensional arrays are not supported");
633 : :
634 [ + + + + ]: 400 : switch (type_enum)
635 : : {
636 : 40 : case ECPGt_struct:
637 : : case ECPGt_union:
638 : : /* pointer has to get dimension 0 */
639 [ + + ]: 40 : if (pointer_len)
640 : : {
641 : 10 : *length = *dimension;
642 : 10 : *dimension = "0";
643 : : }
644 : :
645 [ - + ]: 40 : if (atoi(*length) >= 0)
646 : 0 : mmfatal(PARSE_ERROR, "multidimensional arrays for structures are not supported");
647 : :
648 : 40 : break;
649 : 23 : case ECPGt_varchar:
650 : : case ECPGt_bytea:
651 : : /* pointer has to get dimension 0 */
652 [ - + ]: 23 : if (pointer_len)
653 : 0 : *dimension = "0";
654 : :
655 : : /* one index is the string length */
656 [ + + ]: 23 : if (atoi(*length) < 0)
657 : : {
658 : 15 : *length = *dimension;
659 : 15 : *dimension = "-1";
660 : : }
661 : :
662 : 23 : break;
663 : 134 : case ECPGt_char:
664 : : case ECPGt_unsigned_char:
665 : : case ECPGt_string:
666 : : /* char ** */
667 [ + + ]: 134 : if (pointer_len == 2)
668 : : {
669 : 8 : *length = *dimension = "0";
670 : 8 : break;
671 : : }
672 : :
673 : : /* pointer has to get length 0 */
674 [ + + ]: 126 : if (pointer_len == 1)
675 : 46 : *length = "0";
676 : :
677 : : /* one index is the string length */
678 [ + + ]: 126 : if (atoi(*length) < 0)
679 : : {
680 : : /*
681 : : * make sure we return length = -1 for arrays without given
682 : : * bounds
683 : : */
684 [ + + + + ]: 70 : if (atoi(*dimension) < 0 && !type_definition)
685 : :
686 : : /*
687 : : * do not change this for typedefs since it will be
688 : : * changed later on when the variable is defined
689 : : */
690 : 5 : *length = "1";
691 [ + + ]: 65 : else if (strcmp(*dimension, "0") == 0)
692 : 2 : *length = "-1";
693 : : else
694 : 63 : *length = *dimension;
695 : :
696 : 70 : *dimension = "-1";
697 : : }
698 : 126 : break;
699 : 203 : default:
700 : : /* a pointer has dimension = 0 */
701 [ + + ]: 203 : if (pointer_len)
702 : : {
703 : 20 : *length = *dimension;
704 : 20 : *dimension = "0";
705 : : }
706 : :
707 [ - + ]: 203 : if (atoi(*length) >= 0)
708 : 0 : mmfatal(PARSE_ERROR, "multidimensional arrays for simple data types are not supported");
709 : :
710 : 203 : break;
711 : : }
712 : 400 : }
|
