Age Owner TLA Line data Source code
1 : /* src/interfaces/ecpg/preproc/type.c */
2 :
3 : #include "postgres_fe.h"
4 :
5 : #include "preproc_extern.h"
6 :
7 : #define indicator_set ind_type != NULL && ind_type->type != ECPGt_NO_INDICATOR
8 :
9 : static struct ECPGstruct_member struct_no_indicator = {"no_indicator", &ecpg_no_indicator, NULL};
10 :
11 : /* malloc + error check */
12 : void *
9173 bruce 13 CBC 20493 : mm_alloc(size_t size)
14 : {
15 20493 : void *ptr = malloc(size);
16 :
17 20493 : if (ptr == NULL)
3435 peter_e 18 UBC 0 : mmfatal(OUT_OF_MEMORY, "out of memory");
19 :
8986 bruce 20 CBC 20493 : return ptr;
21 : }
22 :
23 : /* strdup + error check */
24 : char *
8954 lockhart 25 46183 : mm_strdup(const char *string)
26 : {
27 46183 : char *new = strdup(string);
28 :
29 46183 : if (new == NULL)
3435 peter_e 30 UBC 0 : mmfatal(OUT_OF_MEMORY, "out of memory");
31 :
8954 lockhart 32 CBC 46183 : return new;
33 : }
34 :
35 : /* duplicate memberlist */
36 : struct ECPGstruct_member *
2118 tgl 37 71 : ECPGstruct_member_dup(struct ECPGstruct_member *rm)
38 : {
8986 bruce 39 71 : struct ECPGstruct_member *new = NULL;
40 :
41 226 : while (rm)
42 : {
43 : struct ECPGtype *type;
44 :
7777 meskes 45 155 : switch (rm->type->type)
46 : {
8986 bruce 47 4 : case ECPGt_struct:
48 : case ECPGt_union:
4821 meskes 49 4 : type = ECPGmake_struct_type(rm->type->u.members, rm->type->type, rm->type->type_name, rm->type->struct_sizeof);
8986 bruce 50 4 : break;
8986 bruce 51 UBC 0 : case ECPGt_array:
52 :
53 : /*
54 : * if this array does contain a struct again, we have to
55 : * create the struct too
56 : */
4756 meskes 57 0 : if (rm->type->u.element->type == ECPGt_struct || rm->type->u.element->type == ECPGt_union)
4821 58 0 : type = ECPGmake_struct_type(rm->type->u.element->u.members, rm->type->u.element->type, rm->type->u.element->type_name, rm->type->u.element->struct_sizeof);
59 : else
4779 60 0 : type = ECPGmake_array_type(ECPGmake_simple_type(rm->type->u.element->type, rm->type->u.element->size, rm->type->u.element->counter), rm->type->size);
8986 bruce 61 0 : break;
8986 bruce 62 CBC 151 : default:
4779 meskes 63 151 : type = ECPGmake_simple_type(rm->type->type, rm->type->size, rm->type->counter);
8986 bruce 64 151 : break;
65 : }
66 :
67 155 : ECPGmake_struct_member(rm->name, type, &new);
68 :
69 155 : rm = rm->next;
70 : }
71 :
2061 peter_e 72 71 : return new;
73 : }
74 :
75 : /* The NAME argument is copied. The type argument is preserved as a pointer. */
76 : void
1986 77 209 : ECPGmake_struct_member(const char *name, struct ECPGtype *type, struct ECPGstruct_member **start)
78 : {
79 : struct ECPGstruct_member *ptr,
80 : *ne =
8814 scrappy 81 209 : (struct ECPGstruct_member *) mm_alloc(sizeof(struct ECPGstruct_member));
82 :
5709 meskes 83 209 : ne->name = mm_strdup(name);
7777 84 209 : ne->type = type;
9173 bruce 85 209 : ne->next = NULL;
86 :
87 295 : for (ptr = *start; ptr && ptr->next; ptr = ptr->next);
88 :
89 209 : if (ptr)
90 127 : ptr->next = ne;
91 : else
92 82 : *start = ne;
9194 scrappy 93 209 : }
94 :
95 : struct ECPGtype *
4779 meskes 96 761 : ECPGmake_simple_type(enum ECPGttype type, char *size, int counter)
97 : {
9173 bruce 98 761 : struct ECPGtype *ne = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
99 :
7777 meskes 100 761 : ne->type = type;
4821 101 761 : ne->type_name = NULL;
7777 102 761 : ne->size = size;
6755 neilc 103 761 : ne->u.element = NULL;
7777 meskes 104 761 : ne->struct_sizeof = NULL;
1511 105 761 : ne->counter = counter; /* only needed for varchar and bytea */
106 :
9173 bruce 107 761 : return ne;
108 : }
109 :
110 : struct ECPGtype *
2118 tgl 111 71 : ECPGmake_array_type(struct ECPGtype *type, char *size)
112 : {
5717 meskes 113 71 : struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array, size, 0);
114 :
7777 115 71 : ne->u.element = type;
116 :
9173 bruce 117 71 : return ne;
118 : }
119 :
120 : struct ECPGtype *
2118 tgl 121 33 : ECPGmake_struct_type(struct ECPGstruct_member *rm, enum ECPGttype type, char *type_name, char *struct_sizeof)
122 : {
4473 meskes 123 33 : struct ECPGtype *ne = ECPGmake_simple_type(type, mm_strdup("1"), 0);
124 :
4821 125 33 : ne->type_name = mm_strdup(type_name);
8814 scrappy 126 33 : ne->u.members = ECPGstruct_member_dup(rm);
7777 meskes 127 33 : ne->struct_sizeof = struct_sizeof;
128 :
9173 bruce 129 33 : return ne;
130 : }
131 :
132 : static const char *
7777 meskes 133 582 : get_type(enum ECPGttype type)
134 : {
135 582 : switch (type)
136 : {
7836 bruce 137 177 : case ECPGt_char:
2061 peter_e 138 177 : return "ECPGt_char";
139 : break;
8986 bruce 140 UBC 0 : case ECPGt_unsigned_char:
2061 peter_e 141 0 : return "ECPGt_unsigned_char";
142 : break;
8986 bruce 143 CBC 32 : case ECPGt_short:
2061 peter_e 144 32 : return "ECPGt_short";
145 : break;
8986 bruce 146 UBC 0 : case ECPGt_unsigned_short:
2061 peter_e 147 0 : return "ECPGt_unsigned_short";
148 : break;
8986 bruce 149 CBC 207 : case ECPGt_int:
2061 peter_e 150 207 : return "ECPGt_int";
151 : break;
8986 bruce 152 UBC 0 : case ECPGt_unsigned_int:
2061 peter_e 153 0 : return "ECPGt_unsigned_int";
154 : break;
8986 bruce 155 CBC 12 : case ECPGt_long:
2061 peter_e 156 12 : return "ECPGt_long";
157 : break;
8986 bruce 158 UBC 0 : case ECPGt_unsigned_long:
2061 peter_e 159 0 : return "ECPGt_unsigned_long";
160 : break;
8237 meskes 161 0 : case ECPGt_long_long:
2061 peter_e 162 0 : return "ECPGt_long_long";
163 : break;
8237 meskes 164 0 : case ECPGt_unsigned_long_long:
2061 peter_e 165 0 : return "ECPGt_unsigned_long_long";
166 : break;
8986 bruce 167 CBC 6 : case ECPGt_float:
2061 peter_e 168 6 : return "ECPGt_float";
169 : break;
8986 bruce 170 16 : case ECPGt_double:
2061 peter_e 171 16 : return "ECPGt_double";
172 : break;
8986 bruce 173 13 : case ECPGt_bool:
2061 peter_e 174 13 : return "ECPGt_bool";
175 : break;
8986 bruce 176 20 : case ECPGt_varchar:
2061 peter_e 177 20 : return "ECPGt_varchar";
1511 meskes 178 21 : case ECPGt_bytea:
179 21 : return "ECPGt_bytea";
2118 tgl 180 UBC 0 : case ECPGt_NO_INDICATOR: /* no indicator */
2061 peter_e 181 0 : return "ECPGt_NO_INDICATOR";
182 : break;
2118 tgl 183 CBC 19 : case ECPGt_char_variable: /* string that should not be quoted */
2061 peter_e 184 19 : return "ECPGt_char_variable";
185 : break;
7233 meskes 186 16 : case ECPGt_const: /* constant string quoted */
2061 peter_e 187 16 : return "ECPGt_const";
188 : break;
7222 meskes 189 6 : case ECPGt_decimal:
2061 peter_e 190 6 : return "ECPGt_decimal";
191 : break;
7329 meskes 192 9 : case ECPGt_numeric:
2061 peter_e 193 9 : return "ECPGt_numeric";
194 : break;
7318 meskes 195 4 : case ECPGt_interval:
2061 peter_e 196 4 : return "ECPGt_interval";
197 : break;
7872 meskes 198 UBC 0 : case ECPGt_descriptor:
2061 peter_e 199 0 : return "ECPGt_descriptor";
200 : break;
4842 meskes 201 0 : case ECPGt_sqlda:
2061 peter_e 202 0 : return "ECPGt_sqlda";
203 : break;
7325 meskes 204 CBC 10 : case ECPGt_date:
2061 peter_e 205 10 : return "ECPGt_date";
206 : break;
7325 meskes 207 13 : case ECPGt_timestamp:
2061 peter_e 208 13 : return "ECPGt_timestamp";
209 : break;
4993 meskes 210 1 : case ECPGt_string:
2061 peter_e 211 1 : return "ECPGt_string";
212 : break;
8986 bruce 213 UBC 0 : default:
5189 peter_e 214 0 : mmerror(PARSE_ERROR, ET_ERROR, "unrecognized variable type code %d", type);
215 : }
216 :
8806 scrappy 217 0 : return NULL;
218 : }
219 :
220 : /* Dump a type.
221 : The type is dumped as:
222 : type-tag <comma> - enum ECPGttype
223 : reference-to-variable <comma> - char *
224 : size <comma> - long size of this field (if varchar)
225 : arrsize <comma> - long number of elements in the arr
226 : offset <comma> - offset to the next element
227 : Where:
228 : type-tag is one of the simple types or varchar.
229 : reference-to-variable can be a reference to a struct element.
230 : arrsize is the size of the array in case of array fetches. Otherwise 0.
231 : size is the maxsize in case it is a varchar. Otherwise it is the size of
232 : the variable (required to do array fetches of structs).
233 : */
234 : static void ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype type,
235 : char *varcharsize,
236 : char *arrsize, const char *size, const char *prefix, int counter);
237 : static void ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, char *arrsize,
238 : struct ECPGtype *type, struct ECPGtype *ind_type, const char *prefix, const char *ind_prefix);
239 :
240 : void
2118 tgl 241 CBC 592 : ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype *type, const int brace_level,
242 : const char *ind_name, struct ECPGtype *ind_type, const int ind_brace_level,
243 : const char *prefix, const char *ind_prefix,
244 : char *arr_str_size, const char *struct_sizeof,
245 : const char *ind_struct_sizeof)
246 : {
247 : struct variable *var;
248 :
4756 meskes 249 592 : if (type->type != ECPGt_descriptor && type->type != ECPGt_sqlda &&
4412 heikki.linnakangas 250 546 : type->type != ECPGt_char_variable && type->type != ECPGt_const &&
251 : brace_level >= 0)
252 : {
253 : char *str;
254 :
4756 meskes 255 475 : str = mm_strdup(name);
256 475 : var = find_variable(str);
257 475 : free(str);
258 :
259 475 : if ((var->type->type != type->type) ||
260 475 : (var->type->type_name && !type->type_name) ||
261 475 : (!var->type->type_name && type->type_name) ||
4121 peter_e 262 475 : (var->type->type_name && type->type_name && strcmp(var->type->type_name, type->type_name) != 0))
4754 peter_e 263 UBC 0 : mmerror(PARSE_ERROR, ET_ERROR, "variable \"%s\" is hidden by a local variable of a different type", name);
4756 meskes 264 CBC 475 : else if (var->brace_level != brace_level)
4754 peter_e 265 UBC 0 : mmerror(PARSE_ERROR, ET_WARNING, "variable \"%s\" is hidden by a local variable", name);
266 :
4756 meskes 267 CBC 475 : if (ind_name && ind_type && ind_type->type != ECPGt_NO_INDICATOR && ind_brace_level >= 0)
268 : {
269 32 : str = mm_strdup(ind_name);
270 32 : var = find_variable(str);
271 32 : free(str);
272 :
273 32 : if ((var->type->type != ind_type->type) ||
274 32 : (var->type->type_name && !ind_type->type_name) ||
275 32 : (!var->type->type_name && ind_type->type_name) ||
4121 peter_e 276 32 : (var->type->type_name && ind_type->type_name && strcmp(var->type->type_name, ind_type->type_name) != 0))
4754 peter_e 277 UBC 0 : mmerror(PARSE_ERROR, ET_ERROR, "indicator variable \"%s\" is hidden by a local variable of a different type", ind_name);
4756 meskes 278 CBC 32 : else if (var->brace_level != ind_brace_level)
4754 peter_e 279 UBC 0 : mmerror(PARSE_ERROR, ET_WARNING, "indicator variable \"%s\" is hidden by a local variable", ind_name);
280 : }
281 : }
282 :
7777 meskes 283 CBC 592 : switch (type->type)
284 : {
7836 bruce 285 83 : case ECPGt_array:
7777 meskes 286 83 : if (indicator_set && ind_type->type != ECPGt_array)
3435 peter_e 287 UBC 0 : mmfatal(INDICATOR_NOT_ARRAY, "indicator for array/pointer has to be array/pointer");
7777 meskes 288 CBC 83 : switch (type->u.element->type)
289 : {
7836 bruce 290 UBC 0 : case ECPGt_array:
5050 291 0 : mmerror(PARSE_ERROR, ET_ERROR, "nested arrays are not supported (except strings)"); /* array of array */
8806 scrappy 292 0 : break;
8806 scrappy 293 CBC 8 : case ECPGt_struct:
294 : case ECPGt_union:
7255 meskes 295 16 : ECPGdump_a_struct(o, name,
296 : ind_name,
297 : type->size,
298 : type->u.element,
6083 299 8 : (ind_type == NULL) ? NULL : ((ind_type->type == ECPGt_NO_INDICATOR) ? ind_type : ind_type->u.element),
300 : prefix, ind_prefix);
8806 scrappy 301 8 : break;
8720 bruce 302 75 : default:
7777 meskes 303 75 : if (!IS_SIMPLE_TYPE(type->u.element->type))
1136 peter 304 UBC 0 : base_yyerror("internal error: unknown datatype, please report this to <" PACKAGE_BUGREPORT ">");
305 :
7255 meskes 306 CBC 75 : ECPGdump_a_simple(o, name,
7188 bruce 307 75 : type->u.element->type,
3287 meskes 308 75 : type->u.element->size, type->size, struct_sizeof ? struct_sizeof : NULL,
309 75 : prefix, type->u.element->counter);
310 :
7777 311 75 : if (ind_type != NULL)
312 : {
313 55 : if (ind_type->type == ECPGt_NO_INDICATOR)
314 : {
3260 bruce 315 53 : char *str_neg_one = mm_strdup("-1");
316 :
3326 sfrost 317 53 : ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, str_neg_one, NULL, ind_prefix, 0);
318 53 : free(str_neg_one);
319 : }
320 : else
321 : {
7255 meskes 322 2 : ECPGdump_a_simple(o, ind_name, ind_type->u.element->type,
5717 323 2 : ind_type->u.element->size, ind_type->size, NULL, ind_prefix, 0);
324 : }
325 : }
326 : }
8986 bruce 327 83 : break;
328 6 : case ECPGt_struct:
329 : {
3260 330 6 : char *str_one = mm_strdup("1");
331 :
3326 sfrost 332 6 : if (indicator_set && ind_type->type != ECPGt_struct)
3326 sfrost 333 UBC 0 : mmfatal(INDICATOR_NOT_STRUCT, "indicator for struct has to be a struct");
334 :
3326 sfrost 335 CBC 6 : ECPGdump_a_struct(o, name, ind_name, str_one, type, ind_type, prefix, ind_prefix);
336 6 : free(str_one);
337 : }
8986 bruce 338 6 : break;
8720 bruce 339 UBC 0 : case ECPGt_union: /* cannot dump a complete union */
5441 peter_e 340 0 : base_yyerror("type of union has to be specified");
8806 scrappy 341 0 : break;
8806 scrappy 342 CBC 19 : case ECPGt_char_variable:
343 : {
344 : /*
345 : * Allocate for each, as there are code-paths where the values
346 : * get stomped on.
347 : */
3260 bruce 348 19 : char *str_varchar_one = mm_strdup("1");
349 19 : char *str_arr_one = mm_strdup("1");
350 19 : char *str_neg_one = mm_strdup("-1");
351 :
3326 sfrost 352 19 : if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
3326 sfrost 353 UBC 0 : mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");
354 :
2217 peter_e 355 CBC 19 : ECPGdump_a_simple(o, name, type->type, str_varchar_one, (arr_str_size && strcmp(arr_str_size, "0") != 0) ? arr_str_size : str_arr_one, struct_sizeof, prefix, 0);
3326 sfrost 356 19 : if (ind_type != NULL)
2217 peter_e 357 19 : ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, (arr_str_size && strcmp(arr_str_size, "0") != 0) ? arr_str_size : str_neg_one, ind_struct_sizeof, ind_prefix, 0);
358 :
3326 sfrost 359 19 : free(str_varchar_one);
360 19 : free(str_arr_one);
361 19 : free(str_neg_one);
362 : }
8806 scrappy 363 19 : break;
7872 meskes 364 22 : case ECPGt_descriptor:
365 : {
366 : /*
367 : * Allocate for each, as there are code-paths where the values
368 : * get stomped on.
369 : */
3260 bruce 370 22 : char *str_neg_one = mm_strdup("-1");
371 22 : char *ind_type_neg_one = mm_strdup("-1");
372 :
3326 sfrost 373 22 : if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
3326 sfrost 374 UBC 0 : mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");
375 :
3326 sfrost 376 CBC 22 : ECPGdump_a_simple(o, name, type->type, NULL, str_neg_one, NULL, prefix, 0);
377 22 : if (ind_type != NULL)
378 22 : ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, ind_type_neg_one, NULL, ind_prefix, 0);
379 :
380 22 : free(str_neg_one);
381 22 : free(ind_type_neg_one);
382 : }
7872 meskes 383 22 : break;
8986 bruce 384 462 : default:
385 : {
386 : /*
387 : * Allocate for each, as there are code-paths where the values
388 : * get stomped on.
389 : */
3260 390 462 : char *str_neg_one = mm_strdup("-1");
391 462 : char *ind_type_neg_one = mm_strdup("-1");
392 :
3326 sfrost 393 462 : if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
3326 sfrost 394 UBC 0 : mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");
395 :
2217 peter_e 396 CBC 462 : ECPGdump_a_simple(o, name, type->type, type->size, (arr_str_size && strcmp(arr_str_size, "0") != 0) ? arr_str_size : str_neg_one, struct_sizeof, prefix, type->counter);
3326 sfrost 397 462 : if (ind_type != NULL)
2217 peter_e 398 416 : ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, (arr_str_size && strcmp(arr_str_size, "0") != 0) ? arr_str_size : ind_type_neg_one, ind_struct_sizeof, ind_prefix, 0);
399 :
3326 sfrost 400 462 : free(str_neg_one);
401 462 : free(ind_type_neg_one);
402 : }
8986 bruce 403 462 : break;
404 : }
9194 scrappy 405 592 : }
406 :
407 :
408 : /* If size is NULL, then the offset is 0, if not use size as a
409 : string, it represents the offset needed if we are in an array of structs. */
410 : static void
7777 meskes 411 1090 : ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype type,
412 : char *varcharsize,
413 : char *arrsize,
414 : const char *size,
415 : const char *prefix,
416 : int counter)
417 : {
418 1090 : if (type == ECPGt_NO_INDICATOR)
8986 bruce 419 462 : fprintf(o, "\n\tECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ");
7777 meskes 420 628 : else if (type == ECPGt_descriptor)
421 : /* remember that name here already contains quotes (if needed) */
3377 422 22 : fprintf(o, "\n\tECPGt_descriptor, %s, 1L, 1L, 1L, ", name);
4842 423 606 : else if (type == ECPGt_sqlda)
424 24 : fprintf(o, "\n\tECPGt_sqlda, &%s, 0L, 0L, 0L, ", name);
425 : else
426 : {
5050 bruce 427 582 : char *variable = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 4);
428 582 : char *offset = (char *) mm_alloc(strlen(name) + strlen("sizeof(struct varchar_)") + 1 + strlen(varcharsize) + sizeof(int) * CHAR_BIT * 10 / 3);
429 : char *struct_name;
430 :
7777 meskes 431 582 : switch (type)
432 : {
433 : /*
434 : * we have to use the & operator except for arrays and
435 : * pointers
436 : */
437 :
8986 bruce 438 41 : case ECPGt_varchar:
439 : case ECPGt_bytea:
440 :
441 : /*
442 : * we have to use the pointer except for arrays with given
443 : * bounds
444 : */
7188 445 41 : if (((atoi(arrsize) > 0) ||
446 41 : (atoi(arrsize) == 0 && strcmp(arrsize, "0") != 0)) &&
447 : size == NULL)
8404 meskes 448 2 : sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
449 : else
450 39 : sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
451 :
452 : /*
453 : * If we created a varchar structure automatically, counter is
454 : * greater than 0.
455 : */
1511 456 41 : if (type == ECPGt_varchar)
457 20 : struct_name = "struct varchar";
458 : else
459 21 : struct_name = "struct bytea";
460 :
4779 461 41 : if (counter)
1511 462 40 : sprintf(offset, "sizeof(%s_%d)", struct_name, counter);
463 : else
464 1 : sprintf(offset, "sizeof(%s)", struct_name);
8986 bruce 465 41 : break;
466 197 : case ECPGt_char:
467 : case ECPGt_unsigned_char:
468 : case ECPGt_char_variable:
469 : case ECPGt_string:
470 : {
3260 471 197 : char *sizeof_name = "char";
472 :
473 : /*
474 : * we have to use the pointer except for arrays with given
475 : * bounds, ecpglib will distinguish between * and []
476 : */
477 197 : if ((atoi(varcharsize) > 1 ||
478 84 : (atoi(arrsize) > 0) ||
479 59 : (atoi(varcharsize) == 0 && strcmp(varcharsize, "0") != 0) ||
480 51 : (atoi(arrsize) == 0 && strcmp(arrsize, "0") != 0))
2217 peter_e 481 146 : && size == NULL)
482 : {
3260 bruce 483 139 : sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
484 139 : if ((type == ECPGt_char || type == ECPGt_unsigned_char) &&
485 119 : strcmp(varcharsize, "0") == 0)
486 : {
487 : /*
488 : * If this is an array of char *, the offset would
489 : * be sizeof(char *) and not sizeof(char).
490 : */
3260 bruce 491 UBC 0 : sizeof_name = "char *";
492 : }
493 : }
494 : else
3260 bruce 495 CBC 58 : sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
496 :
497 197 : sprintf(offset, "(%s)*sizeof(%s)", strcmp(varcharsize, "0") == 0 ? "1" : varcharsize, sizeof_name);
498 197 : break;
499 : }
7329 meskes 500 9 : case ECPGt_numeric:
501 :
502 : /*
503 : * we have to use a pointer here
504 : */
505 9 : sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
7152 506 9 : sprintf(offset, "sizeof(numeric)");
7318 507 9 : break;
508 4 : case ECPGt_interval:
509 :
510 : /*
511 : * we have to use a pointer here
512 : */
513 4 : sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
7152 514 4 : sprintf(offset, "sizeof(interval)");
7329 515 4 : break;
7325 516 10 : case ECPGt_date:
517 :
518 : /*
519 : * we have to use a pointer and translate the variable type
520 : */
521 10 : sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
7152 522 10 : sprintf(offset, "sizeof(date)");
7325 523 10 : break;
524 13 : case ECPGt_timestamp:
525 :
526 : /*
527 : * we have to use a pointer and translate the variable type
528 : */
529 13 : sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
7152 530 13 : sprintf(offset, "sizeof(timestamp)");
7325 531 13 : break;
7233 532 16 : case ECPGt_const:
533 :
534 : /*
535 : * just dump the const as string
536 : */
537 16 : sprintf(variable, "\"%s\"", name);
538 16 : sprintf(offset, "strlen(\"%s\")", name);
539 16 : break;
8986 bruce 540 292 : default:
541 :
542 : /*
543 : * we have to use the pointer except for arrays with given
544 : * bounds
545 : */
7188 546 292 : if (((atoi(arrsize) > 0) ||
547 292 : (atoi(arrsize) == 0 && strcmp(arrsize, "0") != 0)) &&
548 : size == NULL)
8404 meskes 549 18 : sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
550 : else
551 274 : sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
552 :
5667 553 292 : sprintf(offset, "sizeof(%s)", ecpg_type_name(type));
8986 bruce 554 292 : break;
555 : }
556 :
557 : /*
558 : * Array size would be -1 for addresses of members within structure,
559 : * when pointer to structure is being dumped.
560 : */
2217 peter_e 561 582 : if (atoi(arrsize) < 0 && !size)
7270 meskes 562 422 : strcpy(arrsize, "1");
563 :
564 : /*
565 : * If size i.e. the size of structure of which this variable is part
566 : * of, that gives the offset to the next element, if required
567 : */
2217 peter_e 568 582 : if (size == NULL || strlen(size) == 0)
7270 meskes 569 521 : fprintf(o, "\n\t%s,%s,(long)%s,(long)%s,%s, ", get_type(type), variable, varcharsize, arrsize, offset);
570 : else
2217 peter_e 571 61 : fprintf(o, "\n\t%s,%s,(long)%s,(long)%s,%s, ", get_type(type), variable, varcharsize, arrsize, size);
572 :
8986 bruce 573 582 : free(variable);
574 582 : free(offset);
575 : }
9194 scrappy 576 1090 : }
577 :
578 :
579 : /* Penetrate a struct and dump the contents. */
580 : static void
2118 tgl 581 14 : ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, char *arrsize, struct ECPGtype *type, struct ECPGtype *ind_type, const char *prefix, const char *ind_prefix)
582 : {
583 : /*
584 : * If offset is NULL, then this is the first recursive level. If not then
585 : * we are in a struct and the offset is used as offset.
586 : */
587 : struct ECPGstruct_member *p,
8986 bruce 588 14 : *ind_p = NULL;
3602 589 14 : char *pbuf = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 3);
590 14 : char *ind_pbuf = (char *) mm_alloc(strlen(ind_name) + ((ind_prefix == NULL) ? 0 : strlen(ind_prefix)) + 3);
591 :
2217 peter_e 592 14 : if (atoi(arrsize) == 1)
7792 meskes 593 6 : sprintf(pbuf, "%s%s.", prefix ? prefix : "", name);
594 : else
595 8 : sprintf(pbuf, "%s%s->", prefix ? prefix : "", name);
596 :
9173 bruce 597 14 : prefix = pbuf;
598 :
7777 meskes 599 14 : if (ind_type == &ecpg_no_indicator)
7796 600 2 : ind_p = &struct_no_indicator;
7777 601 12 : else if (ind_type != NULL)
602 : {
2217 peter_e 603 12 : if (atoi(arrsize) == 1)
7792 meskes 604 4 : sprintf(ind_pbuf, "%s%s.", ind_prefix ? ind_prefix : "", ind_name);
605 : else
606 8 : sprintf(ind_pbuf, "%s%s->", ind_prefix ? ind_prefix : "", ind_name);
607 :
7796 608 12 : ind_prefix = ind_pbuf;
7777 609 12 : ind_p = ind_type->u.members;
610 : }
611 :
612 50 : for (p = type->u.members; p; p = p->next)
613 : {
4756 614 72 : ECPGdump_a_type(o, p->name, p->type, -1,
615 : (ind_p != NULL) ? ind_p->name : NULL,
616 : (ind_p != NULL) ? ind_p->type : NULL,
617 : -1,
2217 peter_e 618 36 : prefix, ind_prefix, arrsize, type->struct_sizeof,
619 : (ind_p != NULL) ? ind_type->struct_sizeof : NULL);
7796 meskes 620 36 : if (ind_p != NULL && ind_p != &struct_no_indicator)
621 : {
8986 bruce 622 30 : ind_p = ind_p->next;
1809 tgl 623 30 : if (ind_p == NULL && p->next != NULL)
624 : {
1912 meskes 625 UBC 0 : mmerror(PARSE_ERROR, ET_WARNING, "indicator struct \"%s\" has too few members", ind_name);
626 0 : ind_p = &struct_no_indicator;
627 : }
628 : }
629 : }
630 :
1809 tgl 631 CBC 14 : if (ind_type != NULL && ind_p != NULL && ind_p != &struct_no_indicator)
632 : {
1912 meskes 633 UBC 0 : mmerror(PARSE_ERROR, ET_WARNING, "indicator struct \"%s\" has too many members", ind_name);
634 : }
635 :
3789 meskes 636 CBC 14 : free(pbuf);
637 14 : free(ind_pbuf);
9194 scrappy 638 14 : }
639 :
640 : void
2118 tgl 641 48 : ECPGfree_struct_member(struct ECPGstruct_member *rm)
642 : {
8986 bruce 643 112 : while (rm)
644 : {
645 64 : struct ECPGstruct_member *p = rm;
646 :
647 64 : rm = rm->next;
648 64 : free(p->name);
7777 meskes 649 64 : free(p->type);
8986 bruce 650 64 : free(p);
651 : }
9104 scrappy 652 48 : }
653 :
654 : void
2118 tgl 655 393 : ECPGfree_type(struct ECPGtype *type)
656 : {
7777 meskes 657 393 : if (!IS_SIMPLE_TYPE(type->type))
658 : {
659 80 : switch (type->type)
660 : {
7836 bruce 661 68 : case ECPGt_array:
7777 meskes 662 68 : switch (type->u.element->type)
663 : {
7836 bruce 664 UBC 0 : case ECPGt_array:
5441 peter_e 665 0 : base_yyerror("internal error: found multidimensional array\n");
8806 scrappy 666 0 : break;
8806 scrappy 667 CBC 13 : case ECPGt_struct:
668 : case ECPGt_union:
669 : /* Array of structs. */
7777 meskes 670 13 : ECPGfree_struct_member(type->u.element->u.members);
671 13 : free(type->u.element);
8806 scrappy 672 13 : break;
8720 bruce 673 55 : default:
7777 meskes 674 55 : if (!IS_SIMPLE_TYPE(type->u.element->type))
1136 peter 675 UBC 0 : base_yyerror("internal error: unknown datatype, please report this to <" PACKAGE_BUGREPORT ">");
676 :
7777 meskes 677 CBC 55 : free(type->u.element);
678 : }
8806 scrappy 679 68 : break;
680 12 : case ECPGt_struct:
681 : case ECPGt_union:
7777 meskes 682 12 : ECPGfree_struct_member(type->u.members);
8806 scrappy 683 12 : break;
8806 scrappy 684 UBC 0 : default:
5189 peter_e 685 0 : mmerror(PARSE_ERROR, ET_ERROR, "unrecognized variable type code %d", type->type);
8806 scrappy 686 0 : break;
687 : }
688 : }
7777 meskes 689 CBC 393 : free(type);
9194 scrappy 690 393 : }
691 :
692 : const char *
7777 meskes 693 66 : get_dtype(enum ECPGdtype type)
694 : {
695 66 : switch (type)
696 : {
7836 bruce 697 UBC 0 : case ECPGd_count:
2061 peter_e 698 0 : return "ECPGd_countr";
699 : break;
8447 meskes 700 CBC 31 : case ECPGd_data:
2061 peter_e 701 31 : return "ECPGd_data";
702 : break;
8447 meskes 703 2 : case ECPGd_di_code:
2061 peter_e 704 2 : return "ECPGd_di_code";
705 : break;
8447 meskes 706 UBC 0 : case ECPGd_di_precision:
2061 peter_e 707 0 : return "ECPGd_di_precision";
708 : break;
8447 meskes 709 CBC 17 : case ECPGd_indicator:
2061 peter_e 710 17 : return "ECPGd_indicator";
711 : break;
8447 meskes 712 UBC 0 : case ECPGd_key_member:
2061 peter_e 713 0 : return "ECPGd_key_member";
714 : break;
8447 meskes 715 CBC 2 : case ECPGd_length:
2061 peter_e 716 2 : return "ECPGd_length";
717 : break;
8447 meskes 718 9 : case ECPGd_name:
2061 peter_e 719 9 : return "ECPGd_name";
720 : break;
8447 meskes 721 UBC 0 : case ECPGd_nullable:
2061 peter_e 722 0 : return "ECPGd_nullable";
723 : break;
8447 meskes 724 CBC 1 : case ECPGd_octet:
2061 peter_e 725 1 : return "ECPGd_octet";
726 : break;
8447 meskes 727 1 : case ECPGd_precision:
2061 peter_e 728 1 : return "ECPGd_precision";
729 : break;
8447 meskes 730 UBC 0 : case ECPGd_ret_length:
2061 peter_e 731 0 : return "ECPGd_ret_length";
8447 meskes 732 CBC 1 : case ECPGd_ret_octet:
2061 peter_e 733 1 : return "ECPGd_ret_octet";
734 : break;
8397 bruce 735 1 : case ECPGd_scale:
2061 peter_e 736 1 : return "ECPGd_scale";
737 : break;
8397 bruce 738 1 : case ECPGd_type:
2061 peter_e 739 1 : return "ECPGd_type";
740 : break;
7903 meskes 741 UBC 0 : case ECPGd_cardinality:
2061 peter_e 742 0 : return "ECPGd_cardinality";
8447 meskes 743 0 : default:
5189 peter_e 744 0 : mmerror(PARSE_ERROR, ET_ERROR, "unrecognized descriptor item code %d", type);
745 : }
746 :
8447 meskes 747 0 : return NULL;
748 : }
|
