Age Owner Branch data 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 *
9544 bruce@momjian.us 13 :CBC 21100 : mm_alloc(size_t size)
14 : : {
15 : 21100 : void *ptr = malloc(size);
16 : :
17 [ - + ]: 21100 : if (ptr == NULL)
3806 peter_e@gmx.net 18 :UBC 0 : mmfatal(OUT_OF_MEMORY, "out of memory");
19 : :
9357 bruce@momjian.us 20 :CBC 21100 : return ptr;
21 : : }
22 : :
23 : : /* strdup + error check */
24 : : char *
9325 lockhart@fourpalms.o 25 : 47208 : mm_strdup(const char *string)
26 : : {
27 : 47208 : char *new = strdup(string);
28 : :
29 [ - + ]: 47208 : if (new == NULL)
3806 peter_e@gmx.net 30 :UBC 0 : mmfatal(OUT_OF_MEMORY, "out of memory");
31 : :
9325 lockhart@fourpalms.o 32 :CBC 47208 : return new;
33 : : }
34 : :
35 : : /* duplicate memberlist */
36 : : struct ECPGstruct_member *
2489 tgl@sss.pgh.pa.us 37 : 71 : ECPGstruct_member_dup(struct ECPGstruct_member *rm)
38 : : {
9357 bruce@momjian.us 39 : 71 : struct ECPGstruct_member *new = NULL;
40 : :
41 [ + + ]: 226 : while (rm)
42 : : {
43 : : struct ECPGtype *type;
44 : :
8148 meskes@postgresql.or 45 [ + - + ]: 155 : switch (rm->type->type)
46 : : {
9357 bruce@momjian.us 47 : 4 : case ECPGt_struct:
48 : : case ECPGt_union:
5192 meskes@postgresql.or 49 : 4 : type = ECPGmake_struct_type(rm->type->u.members, rm->type->type, rm->type->type_name, rm->type->struct_sizeof);
9357 bruce@momjian.us 50 : 4 : break;
9357 bruce@momjian.us 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 : : */
5127 meskes@postgresql.or 57 [ # # # # ]: 0 : if (rm->type->u.element->type == ECPGt_struct || rm->type->u.element->type == ECPGt_union)
5192 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
5150 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);
9357 bruce@momjian.us 61 : 0 : break;
9357 bruce@momjian.us 62 :CBC 151 : default:
5150 meskes@postgresql.or 63 : 151 : type = ECPGmake_simple_type(rm->type->type, rm->type->size, rm->type->counter);
9357 bruce@momjian.us 64 : 151 : break;
65 : : }
66 : :
67 : 155 : ECPGmake_struct_member(rm->name, type, &new);
68 : :
69 : 155 : rm = rm->next;
70 : : }
71 : :
2432 peter_e@gmx.net 72 : 71 : return new;
73 : : }
74 : :
75 : : /* The NAME argument is copied. The type argument is preserved as a pointer. */
76 : : void
2357 77 : 209 : ECPGmake_struct_member(const char *name, struct ECPGtype *type, struct ECPGstruct_member **start)
78 : : {
79 : : struct ECPGstruct_member *ptr,
80 : : *ne =
331 tgl@sss.pgh.pa.us 81 : 209 : (struct ECPGstruct_member *) mm_alloc(sizeof(struct ECPGstruct_member));
82 : :
6080 meskes@postgresql.or 83 : 209 : ne->name = mm_strdup(name);
8148 84 : 209 : ne->type = type;
9544 bruce@momjian.us 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;
9565 scrappy@hub.org 93 : 209 : }
94 : :
95 : : struct ECPGtype *
5150 meskes@postgresql.or 96 : 765 : ECPGmake_simple_type(enum ECPGttype type, char *size, int counter)
97 : : {
9544 bruce@momjian.us 98 : 765 : struct ECPGtype *ne = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
99 : :
8148 meskes@postgresql.or 100 : 765 : ne->type = type;
5192 101 : 765 : ne->type_name = NULL;
8148 102 : 765 : ne->size = size;
7126 neilc@samurai.com 103 : 765 : ne->u.element = NULL;
8148 meskes@postgresql.or 104 : 765 : ne->struct_sizeof = NULL;
1882 105 : 765 : ne->counter = counter; /* only needed for varchar and bytea */
106 : :
9544 bruce@momjian.us 107 : 765 : return ne;
108 : : }
109 : :
110 : : struct ECPGtype *
2489 tgl@sss.pgh.pa.us 111 : 72 : ECPGmake_array_type(struct ECPGtype *type, char *size)
112 : : {
6088 meskes@postgresql.or 113 : 72 : struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array, size, 0);
114 : :
8148 115 : 72 : ne->u.element = type;
116 : :
9544 bruce@momjian.us 117 : 72 : return ne;
118 : : }
119 : :
120 : : struct ECPGtype *
2489 tgl@sss.pgh.pa.us 121 : 33 : ECPGmake_struct_type(struct ECPGstruct_member *rm, enum ECPGttype type, char *type_name, char *struct_sizeof)
122 : : {
4844 meskes@postgresql.or 123 : 33 : struct ECPGtype *ne = ECPGmake_simple_type(type, mm_strdup("1"), 0);
124 : :
5192 125 : 33 : ne->type_name = mm_strdup(type_name);
9185 scrappy@hub.org 126 : 33 : ne->u.members = ECPGstruct_member_dup(rm);
8148 meskes@postgresql.or 127 : 33 : ne->struct_sizeof = struct_sizeof;
128 : :
9544 bruce@momjian.us 129 : 33 : return ne;
130 : : }
131 : :
132 : : static const char *
8148 meskes@postgresql.or 133 : 603 : get_type(enum ECPGttype type)
134 : : {
135 [ + - + - : 603 : switch (type)
+ - + - -
- + + + +
+ - + + +
+ + - - +
+ + - ]
136 : : {
8207 bruce@momjian.us 137 : 195 : case ECPGt_char:
2432 peter_e@gmx.net 138 : 195 : return "ECPGt_char";
139 : : break;
9357 bruce@momjian.us 140 :UBC 0 : case ECPGt_unsigned_char:
2432 peter_e@gmx.net 141 : 0 : return "ECPGt_unsigned_char";
142 : : break;
9357 bruce@momjian.us 143 :CBC 32 : case ECPGt_short:
2432 peter_e@gmx.net 144 : 32 : return "ECPGt_short";
145 : : break;
9357 bruce@momjian.us 146 :UBC 0 : case ECPGt_unsigned_short:
2432 peter_e@gmx.net 147 : 0 : return "ECPGt_unsigned_short";
148 : : break;
9357 bruce@momjian.us 149 :CBC 209 : case ECPGt_int:
2432 peter_e@gmx.net 150 : 209 : return "ECPGt_int";
151 : : break;
9357 bruce@momjian.us 152 :UBC 0 : case ECPGt_unsigned_int:
2432 peter_e@gmx.net 153 : 0 : return "ECPGt_unsigned_int";
154 : : break;
9357 bruce@momjian.us 155 :CBC 12 : case ECPGt_long:
2432 peter_e@gmx.net 156 : 12 : return "ECPGt_long";
157 : : break;
9357 bruce@momjian.us 158 :UBC 0 : case ECPGt_unsigned_long:
2432 peter_e@gmx.net 159 : 0 : return "ECPGt_unsigned_long";
160 : : break;
8608 meskes@postgresql.or 161 : 0 : case ECPGt_long_long:
2432 peter_e@gmx.net 162 : 0 : return "ECPGt_long_long";
163 : : break;
8608 meskes@postgresql.or 164 : 0 : case ECPGt_unsigned_long_long:
2432 peter_e@gmx.net 165 : 0 : return "ECPGt_unsigned_long_long";
166 : : break;
9357 bruce@momjian.us 167 :CBC 6 : case ECPGt_float:
2432 peter_e@gmx.net 168 : 6 : return "ECPGt_float";
169 : : break;
9357 bruce@momjian.us 170 : 16 : case ECPGt_double:
2432 peter_e@gmx.net 171 : 16 : return "ECPGt_double";
172 : : break;
9357 bruce@momjian.us 173 : 13 : case ECPGt_bool:
2432 peter_e@gmx.net 174 : 13 : return "ECPGt_bool";
175 : : break;
9357 bruce@momjian.us 176 : 20 : case ECPGt_varchar:
2432 peter_e@gmx.net 177 : 20 : return "ECPGt_varchar";
1882 meskes@postgresql.or 178 : 21 : case ECPGt_bytea:
179 : 21 : return "ECPGt_bytea";
2489 tgl@sss.pgh.pa.us 180 :UBC 0 : case ECPGt_NO_INDICATOR: /* no indicator */
2432 peter_e@gmx.net 181 : 0 : return "ECPGt_NO_INDICATOR";
182 : : break;
2489 tgl@sss.pgh.pa.us 183 :CBC 20 : case ECPGt_char_variable: /* string that should not be quoted */
2432 peter_e@gmx.net 184 : 20 : return "ECPGt_char_variable";
185 : : break;
7604 meskes@postgresql.or 186 : 16 : case ECPGt_const: /* constant string quoted */
2432 peter_e@gmx.net 187 : 16 : return "ECPGt_const";
188 : : break;
7593 meskes@postgresql.or 189 : 6 : case ECPGt_decimal:
2432 peter_e@gmx.net 190 : 6 : return "ECPGt_decimal";
191 : : break;
7700 meskes@postgresql.or 192 : 9 : case ECPGt_numeric:
2432 peter_e@gmx.net 193 : 9 : return "ECPGt_numeric";
194 : : break;
7689 meskes@postgresql.or 195 : 4 : case ECPGt_interval:
2432 peter_e@gmx.net 196 : 4 : return "ECPGt_interval";
197 : : break;
8243 meskes@postgresql.or 198 :UBC 0 : case ECPGt_descriptor:
2432 peter_e@gmx.net 199 : 0 : return "ECPGt_descriptor";
200 : : break;
5213 meskes@postgresql.or 201 : 0 : case ECPGt_sqlda:
2432 peter_e@gmx.net 202 : 0 : return "ECPGt_sqlda";
203 : : break;
7696 meskes@postgresql.or 204 :CBC 10 : case ECPGt_date:
2432 peter_e@gmx.net 205 : 10 : return "ECPGt_date";
206 : : break;
7696 meskes@postgresql.or 207 : 13 : case ECPGt_timestamp:
2432 peter_e@gmx.net 208 : 13 : return "ECPGt_timestamp";
209 : : break;
5364 meskes@postgresql.or 210 : 1 : case ECPGt_string:
2432 peter_e@gmx.net 211 : 1 : return "ECPGt_string";
212 : : break;
9357 bruce@momjian.us 213 :UBC 0 : default:
5560 peter_e@gmx.net 214 : 0 : mmerror(PARSE_ERROR, ET_ERROR, "unrecognized variable type code %d", type);
215 : : }
216 : :
9177 scrappy@hub.org 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
2489 tgl@sss.pgh.pa.us 241 :CBC 614 : 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 : :
5127 meskes@postgresql.or 249 [ + + + + ]: 614 : if (type->type != ECPGt_descriptor && type->type != ECPGt_sqlda &&
4783 heikki.linnakangas@i 250 [ + + + + : 567 : type->type != ECPGt_char_variable && type->type != ECPGt_const &&
+ + ]
251 : : brace_level >= 0)
252 : : {
253 : : char *str;
254 : :
5127 meskes@postgresql.or 255 : 495 : str = mm_strdup(name);
256 : 495 : var = find_variable(str);
257 : 495 : free(str);
258 : :
259 [ + - ]: 495 : if ((var->type->type != type->type) ||
260 [ + + + - ]: 495 : (var->type->type_name && !type->type_name) ||
261 [ + + + - ]: 495 : (!var->type->type_name && type->type_name) ||
4492 peter_e@gmx.net 262 [ + + + - : 495 : (var->type->type_name && type->type_name && strcmp(var->type->type_name, type->type_name) != 0))
- + ]
5125 peter_e@gmx.net 263 :UBC 0 : mmerror(PARSE_ERROR, ET_ERROR, "variable \"%s\" is hidden by a local variable of a different type", name);
5127 meskes@postgresql.or 264 [ - + ]:CBC 495 : else if (var->brace_level != brace_level)
5125 peter_e@gmx.net 265 :UBC 0 : mmerror(PARSE_ERROR, ET_WARNING, "variable \"%s\" is hidden by a local variable", name);
266 : :
5127 meskes@postgresql.or 267 [ + + + - :CBC 495 : 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) ||
4492 peter_e@gmx.net 276 [ + + + - : 32 : (var->type->type_name && ind_type->type_name && strcmp(var->type->type_name, ind_type->type_name) != 0))
- + ]
5125 peter_e@gmx.net 277 :UBC 0 : mmerror(PARSE_ERROR, ET_ERROR, "indicator variable \"%s\" is hidden by a local variable of a different type", ind_name);
5127 meskes@postgresql.or 278 [ - + ]:CBC 32 : else if (var->brace_level != ind_brace_level)
5125 peter_e@gmx.net 279 :UBC 0 : mmerror(PARSE_ERROR, ET_WARNING, "indicator variable \"%s\" is hidden by a local variable", ind_name);
280 : : }
281 : : }
282 : :
8148 meskes@postgresql.or 283 [ + + - + :CBC 614 : switch (type->type)
+ + ]
284 : : {
8207 bruce@momjian.us 285 : 83 : case ECPGt_array:
8148 meskes@postgresql.or 286 [ + + + + : 83 : if (indicator_set && ind_type->type != ECPGt_array)
- + ]
3806 peter_e@gmx.net 287 :UBC 0 : mmfatal(INDICATOR_NOT_ARRAY, "indicator for array/pointer has to be array/pointer");
8148 meskes@postgresql.or 288 [ - + + ]:CBC 83 : switch (type->u.element->type)
289 : : {
8207 bruce@momjian.us 290 :UBC 0 : case ECPGt_array:
5421 291 : 0 : mmerror(PARSE_ERROR, ET_ERROR, "nested arrays are not supported (except strings)"); /* array of array */
9177 scrappy@hub.org 292 : 0 : break;
9177 scrappy@hub.org 293 :CBC 8 : case ECPGt_struct:
294 : : case ECPGt_union:
7626 meskes@postgresql.or 295 [ + - ]: 16 : ECPGdump_a_struct(o, name,
296 : : ind_name,
297 : : type->size,
298 : : type->u.element,
6454 299 [ + - ]: 8 : (ind_type == NULL) ? NULL : ((ind_type->type == ECPGt_NO_INDICATOR) ? ind_type : ind_type->u.element),
300 : : prefix, ind_prefix);
9177 scrappy@hub.org 301 : 8 : break;
9091 bruce@momjian.us 302 : 75 : default:
8148 meskes@postgresql.or 303 [ + - + + : 75 : if (!IS_SIMPLE_TYPE(type->u.element->type))
+ - - + ]
1507 peter@eisentraut.org 304 :UBC 0 : base_yyerror("internal error: unknown datatype, please report this to <" PACKAGE_BUGREPORT ">");
305 : :
7626 meskes@postgresql.or 306 :CBC 75 : ECPGdump_a_simple(o, name,
7559 bruce@momjian.us 307 : 75 : type->u.element->type,
3658 meskes@postgresql.or 308 : 75 : type->u.element->size, type->size, struct_sizeof ? struct_sizeof : NULL,
309 : 75 : prefix, type->u.element->counter);
310 : :
8148 311 [ + + ]: 75 : if (ind_type != NULL)
312 : : {
313 [ + + ]: 55 : if (ind_type->type == ECPGt_NO_INDICATOR)
314 : : {
3631 bruce@momjian.us 315 : 53 : char *str_neg_one = mm_strdup("-1");
316 : :
3697 sfrost@snowman.net 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 : : {
7626 meskes@postgresql.or 322 : 2 : ECPGdump_a_simple(o, ind_name, ind_type->u.element->type,
6088 323 : 2 : ind_type->u.element->size, ind_type->size, NULL, ind_prefix, 0);
324 : : }
325 : : }
326 : : }
9357 bruce@momjian.us 327 : 83 : break;
328 : 6 : case ECPGt_struct:
329 : : {
3631 330 : 6 : char *str_one = mm_strdup("1");
331 : :
3697 sfrost@snowman.net 332 [ + - + + : 6 : if (indicator_set && ind_type->type != ECPGt_struct)
- + ]
3697 sfrost@snowman.net 333 :UBC 0 : mmfatal(INDICATOR_NOT_STRUCT, "indicator for struct has to be a struct");
334 : :
3697 sfrost@snowman.net 335 :CBC 6 : ECPGdump_a_struct(o, name, ind_name, str_one, type, ind_type, prefix, ind_prefix);
336 : 6 : free(str_one);
337 : : }
9357 bruce@momjian.us 338 : 6 : break;
9091 bruce@momjian.us 339 :UBC 0 : case ECPGt_union: /* cannot dump a complete union */
5812 peter_e@gmx.net 340 : 0 : base_yyerror("type of union has to be specified");
9177 scrappy@hub.org 341 : 0 : break;
9177 scrappy@hub.org 342 :CBC 20 : case ECPGt_char_variable:
343 : : {
344 : : /*
345 : : * Allocate for each, as there are code-paths where the values
346 : : * get stomped on.
347 : : */
3631 bruce@momjian.us 348 : 20 : char *str_varchar_one = mm_strdup("1");
349 : 20 : char *str_arr_one = mm_strdup("1");
350 : 20 : char *str_neg_one = mm_strdup("-1");
351 : :
3697 sfrost@snowman.net 352 [ + - - + : 20 : if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
- - - - ]
3697 sfrost@snowman.net 353 :UBC 0 : mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");
354 : :
2588 peter_e@gmx.net 355 [ + - - + ]:CBC 20 : 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);
3697 sfrost@snowman.net 356 [ + - ]: 20 : if (ind_type != NULL)
2588 peter_e@gmx.net 357 [ + - - + ]: 20 : 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 : :
3697 sfrost@snowman.net 359 : 20 : free(str_varchar_one);
360 : 20 : free(str_arr_one);
361 : 20 : free(str_neg_one);
362 : : }
9177 scrappy@hub.org 363 : 20 : break;
8243 meskes@postgresql.or 364 : 22 : case ECPGt_descriptor:
365 : : {
366 : : /*
367 : : * Allocate for each, as there are code-paths where the values
368 : : * get stomped on.
369 : : */
3631 bruce@momjian.us 370 : 22 : char *str_neg_one = mm_strdup("-1");
371 : 22 : char *ind_type_neg_one = mm_strdup("-1");
372 : :
3697 sfrost@snowman.net 373 [ + - - + : 22 : if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
- - - - ]
3697 sfrost@snowman.net 374 :UBC 0 : mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");
375 : :
3697 sfrost@snowman.net 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 : : }
8243 meskes@postgresql.or 383 : 22 : break;
9357 bruce@momjian.us 384 : 483 : default:
385 : : {
386 : : /*
387 : : * Allocate for each, as there are code-paths where the values
388 : : * get stomped on.
389 : : */
3631 390 : 483 : char *str_neg_one = mm_strdup("-1");
391 : 483 : char *ind_type_neg_one = mm_strdup("-1");
392 : :
3697 sfrost@snowman.net 393 [ + + + + : 483 : if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
+ - - + ]
3697 sfrost@snowman.net 394 :UBC 0 : mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");
395 : :
2588 peter_e@gmx.net 396 [ + - + + ]:CBC 483 : 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);
3697 sfrost@snowman.net 397 [ + + ]: 483 : if (ind_type != NULL)
2588 peter_e@gmx.net 398 [ + - + + ]: 437 : 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 : :
3697 sfrost@snowman.net 400 : 483 : free(str_neg_one);
401 : 483 : free(ind_type_neg_one);
402 : : }
9357 bruce@momjian.us 403 : 483 : break;
404 : : }
9565 scrappy@hub.org 405 : 614 : }
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
8148 meskes@postgresql.or 411 : 1134 : 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 [ + + ]: 1134 : if (type == ECPGt_NO_INDICATOR)
9357 bruce@momjian.us 419 : 484 : fprintf(o, "\n\tECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ");
8148 meskes@postgresql.or 420 [ + + ]: 650 : else if (type == ECPGt_descriptor)
421 : : /* remember that name here already contains quotes (if needed) */
3748 422 : 22 : fprintf(o, "\n\tECPGt_descriptor, %s, 1L, 1L, 1L, ", name);
5213 423 [ + + ]: 628 : else if (type == ECPGt_sqlda)
424 : 25 : fprintf(o, "\n\tECPGt_sqlda, &%s, 0L, 0L, 0L, ", name);
425 : : else
426 : : {
5421 bruce@momjian.us 427 [ + + ]: 603 : char *variable = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 4);
428 : 603 : 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 : :
8148 meskes@postgresql.or 431 [ + + + + : 603 : switch (type)
+ + + + ]
432 : : {
433 : : /*
434 : : * we have to use the & operator except for arrays and
435 : : * pointers
436 : : */
437 : :
9357 bruce@momjian.us 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 : : */
7559 445 [ + + ]: 41 : if (((atoi(arrsize) > 0) ||
446 [ + + - + : 41 : (atoi(arrsize) == 0 && strcmp(arrsize, "0") != 0)) &&
+ + ]
447 : : size == NULL)
8775 meskes@postgresql.or 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 : : */
1882 456 [ + + ]: 41 : if (type == ECPGt_varchar)
457 : 20 : struct_name = "struct varchar";
458 : : else
459 : 21 : struct_name = "struct bytea";
460 : :
5150 461 [ + + ]: 41 : if (counter)
1882 462 : 40 : sprintf(offset, "sizeof(%s_%d)", struct_name, counter);
463 : : else
464 : 1 : sprintf(offset, "sizeof(%s)", struct_name);
9357 bruce@momjian.us 465 : 41 : break;
466 : 216 : case ECPGt_char:
467 : : case ECPGt_unsigned_char:
468 : : case ECPGt_char_variable:
469 : : case ECPGt_string:
470 : : {
3631 471 : 216 : 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 [ + + ]: 216 : if ((atoi(varcharsize) > 1 ||
478 [ + + ]: 85 : (atoi(arrsize) > 0) ||
479 [ + - + + ]: 59 : (atoi(varcharsize) == 0 && strcmp(varcharsize, "0") != 0) ||
480 [ + + - + ]: 51 : (atoi(arrsize) == 0 && strcmp(arrsize, "0") != 0))
2588 peter_e@gmx.net 481 [ + + ]: 165 : && size == NULL)
482 : : {
3631 bruce@momjian.us 483 [ - + ]: 158 : sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
484 [ + + - + ]: 158 : if ((type == ECPGt_char || type == ECPGt_unsigned_char) &&
485 [ - + ]: 137 : 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 : : */
3631 bruce@momjian.us 491 :UBC 0 : sizeof_name = "char *";
492 : : }
493 : : }
494 : : else
3631 bruce@momjian.us 495 [ + + ]:CBC 58 : sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
496 : :
497 [ + + ]: 216 : sprintf(offset, "(%s)*sizeof(%s)", strcmp(varcharsize, "0") == 0 ? "1" : varcharsize, sizeof_name);
498 : 216 : break;
499 : : }
7700 meskes@postgresql.or 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);
7523 506 : 9 : sprintf(offset, "sizeof(numeric)");
7689 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);
7523 514 : 4 : sprintf(offset, "sizeof(interval)");
7700 515 : 4 : break;
7696 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);
7523 522 : 10 : sprintf(offset, "sizeof(date)");
7696 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);
7523 530 : 13 : sprintf(offset, "sizeof(timestamp)");
7696 531 : 13 : break;
7604 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;
9357 bruce@momjian.us 540 : 294 : default:
541 : :
542 : : /*
543 : : * we have to use the pointer except for arrays with given
544 : : * bounds
545 : : */
7559 546 [ + + ]: 294 : if (((atoi(arrsize) > 0) ||
547 [ + + + + : 294 : (atoi(arrsize) == 0 && strcmp(arrsize, "0") != 0)) &&
+ + ]
548 : : size == NULL)
8775 meskes@postgresql.or 549 [ - + ]: 18 : sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
550 : : else
551 [ + + ]: 276 : sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
552 : :
6038 553 : 294 : sprintf(offset, "sizeof(%s)", ecpg_type_name(type));
9357 bruce@momjian.us 554 : 294 : 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 : : */
2588 peter_e@gmx.net 561 [ + + + + ]: 603 : if (atoi(arrsize) < 0 && !size)
7641 meskes@postgresql.or 562 : 442 : 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 : : */
2588 peter_e@gmx.net 568 [ + + + + ]: 603 : if (size == NULL || strlen(size) == 0)
7641 meskes@postgresql.or 569 : 542 : fprintf(o, "\n\t%s,%s,(long)%s,(long)%s,%s, ", get_type(type), variable, varcharsize, arrsize, offset);
570 : : else
2588 peter_e@gmx.net 571 : 61 : fprintf(o, "\n\t%s,%s,(long)%s,(long)%s,%s, ", get_type(type), variable, varcharsize, arrsize, size);
572 : :
9357 bruce@momjian.us 573 : 603 : free(variable);
574 : 603 : free(offset);
575 : : }
9565 scrappy@hub.org 576 : 1134 : }
577 : :
578 : :
579 : : /* Penetrate a struct and dump the contents. */
580 : : static void
2489 tgl@sss.pgh.pa.us 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,
9357 bruce@momjian.us 588 : 14 : *ind_p = NULL;
3973 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 : :
2588 peter_e@gmx.net 592 [ + + ]: 14 : if (atoi(arrsize) == 1)
8163 meskes@postgresql.or 593 [ + + ]: 6 : sprintf(pbuf, "%s%s.", prefix ? prefix : "", name);
594 : : else
595 [ - + ]: 8 : sprintf(pbuf, "%s%s->", prefix ? prefix : "", name);
596 : :
9544 bruce@momjian.us 597 : 14 : prefix = pbuf;
598 : :
8148 meskes@postgresql.or 599 [ + + ]: 14 : if (ind_type == &ecpg_no_indicator)
8167 600 : 2 : ind_p = &struct_no_indicator;
8148 601 [ + - ]: 12 : else if (ind_type != NULL)
602 : : {
2588 peter_e@gmx.net 603 [ + + ]: 12 : if (atoi(arrsize) == 1)
8163 meskes@postgresql.or 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 : :
8167 608 : 12 : ind_prefix = ind_pbuf;
8148 609 : 12 : ind_p = ind_type->u.members;
610 : : }
611 : :
612 [ + + ]: 50 : for (p = type->u.members; p; p = p->next)
613 : : {
5127 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,
2588 peter_e@gmx.net 618 [ + - ]: 36 : prefix, ind_prefix, arrsize, type->struct_sizeof,
619 : : (ind_p != NULL) ? ind_type->struct_sizeof : NULL);
8167 meskes@postgresql.or 620 [ + - + + ]: 36 : if (ind_p != NULL && ind_p != &struct_no_indicator)
621 : : {
9357 bruce@momjian.us 622 : 30 : ind_p = ind_p->next;
2180 tgl@sss.pgh.pa.us 623 [ + + - + ]: 30 : if (ind_p == NULL && p->next != NULL)
624 : : {
2283 meskes@postgresql.or 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 : :
2180 tgl@sss.pgh.pa.us 631 [ + - + + :CBC 14 : if (ind_type != NULL && ind_p != NULL && ind_p != &struct_no_indicator)
- + ]
632 : : {
2283 meskes@postgresql.or 633 :UBC 0 : mmerror(PARSE_ERROR, ET_WARNING, "indicator struct \"%s\" has too many members", ind_name);
634 : : }
635 : :
4160 meskes@postgresql.or 636 :CBC 14 : free(pbuf);
637 : 14 : free(ind_pbuf);
9565 scrappy@hub.org 638 : 14 : }
639 : :
640 : : void
2489 tgl@sss.pgh.pa.us 641 : 48 : ECPGfree_struct_member(struct ECPGstruct_member *rm)
642 : : {
9357 bruce@momjian.us 643 [ + + ]: 112 : while (rm)
644 : : {
645 : 64 : struct ECPGstruct_member *p = rm;
646 : :
647 : 64 : rm = rm->next;
648 : 64 : free(p->name);
8148 meskes@postgresql.or 649 : 64 : free(p->type);
9357 bruce@momjian.us 650 : 64 : free(p);
651 : : }
9475 scrappy@hub.org 652 : 48 : }
653 : :
654 : : void
2489 tgl@sss.pgh.pa.us 655 : 394 : ECPGfree_type(struct ECPGtype *type)
656 : : {
8148 meskes@postgresql.or 657 [ + - + + : 394 : if (!IS_SIMPLE_TYPE(type->type))
+ + + + ]
658 : : {
659 [ + + - ]: 80 : switch (type->type)
660 : : {
8207 bruce@momjian.us 661 : 68 : case ECPGt_array:
8148 meskes@postgresql.or 662 [ - + + ]: 68 : switch (type->u.element->type)
663 : : {
8207 bruce@momjian.us 664 :UBC 0 : case ECPGt_array:
5812 peter_e@gmx.net 665 : 0 : base_yyerror("internal error: found multidimensional array\n");
9177 scrappy@hub.org 666 : 0 : break;
9177 scrappy@hub.org 667 :CBC 13 : case ECPGt_struct:
668 : : case ECPGt_union:
669 : : /* Array of structs. */
8148 meskes@postgresql.or 670 : 13 : ECPGfree_struct_member(type->u.element->u.members);
671 : 13 : free(type->u.element);
9177 scrappy@hub.org 672 : 13 : break;
9091 bruce@momjian.us 673 : 55 : default:
8148 meskes@postgresql.or 674 [ + - + + : 55 : if (!IS_SIMPLE_TYPE(type->u.element->type))
+ - - + ]
1507 peter@eisentraut.org 675 :UBC 0 : base_yyerror("internal error: unknown datatype, please report this to <" PACKAGE_BUGREPORT ">");
676 : :
8148 meskes@postgresql.or 677 :CBC 55 : free(type->u.element);
678 : : }
9177 scrappy@hub.org 679 : 68 : break;
680 : 12 : case ECPGt_struct:
681 : : case ECPGt_union:
8148 meskes@postgresql.or 682 : 12 : ECPGfree_struct_member(type->u.members);
9177 scrappy@hub.org 683 : 12 : break;
9177 scrappy@hub.org 684 :UBC 0 : default:
5560 peter_e@gmx.net 685 : 0 : mmerror(PARSE_ERROR, ET_ERROR, "unrecognized variable type code %d", type->type);
9177 scrappy@hub.org 686 : 0 : break;
687 : : }
688 : : }
8148 meskes@postgresql.or 689 :CBC 394 : free(type);
9565 scrappy@hub.org 690 : 394 : }
691 : :
692 : : const char *
8148 meskes@postgresql.or 693 : 66 : get_dtype(enum ECPGdtype type)
694 : : {
695 [ - + + - : 66 : switch (type)
+ - + + -
+ + - + +
+ - - ]
696 : : {
8207 bruce@momjian.us 697 :UBC 0 : case ECPGd_count:
102 michael@paquier.xyz 698 :UNC 0 : return "ECPGd_count";
699 : : break;
8818 meskes@postgresql.or 700 :CBC 31 : case ECPGd_data:
2432 peter_e@gmx.net 701 : 31 : return "ECPGd_data";
702 : : break;
8818 meskes@postgresql.or 703 : 2 : case ECPGd_di_code:
2432 peter_e@gmx.net 704 : 2 : return "ECPGd_di_code";
705 : : break;
8818 meskes@postgresql.or 706 :UBC 0 : case ECPGd_di_precision:
2432 peter_e@gmx.net 707 : 0 : return "ECPGd_di_precision";
708 : : break;
8818 meskes@postgresql.or 709 :CBC 17 : case ECPGd_indicator:
2432 peter_e@gmx.net 710 : 17 : return "ECPGd_indicator";
711 : : break;
8818 meskes@postgresql.or 712 :UBC 0 : case ECPGd_key_member:
2432 peter_e@gmx.net 713 : 0 : return "ECPGd_key_member";
714 : : break;
8818 meskes@postgresql.or 715 :CBC 2 : case ECPGd_length:
2432 peter_e@gmx.net 716 : 2 : return "ECPGd_length";
717 : : break;
8818 meskes@postgresql.or 718 : 9 : case ECPGd_name:
2432 peter_e@gmx.net 719 : 9 : return "ECPGd_name";
720 : : break;
8818 meskes@postgresql.or 721 :UBC 0 : case ECPGd_nullable:
2432 peter_e@gmx.net 722 : 0 : return "ECPGd_nullable";
723 : : break;
8818 meskes@postgresql.or 724 :CBC 1 : case ECPGd_octet:
2432 peter_e@gmx.net 725 : 1 : return "ECPGd_octet";
726 : : break;
8818 meskes@postgresql.or 727 : 1 : case ECPGd_precision:
2432 peter_e@gmx.net 728 : 1 : return "ECPGd_precision";
729 : : break;
8818 meskes@postgresql.or 730 :UBC 0 : case ECPGd_ret_length:
2432 peter_e@gmx.net 731 : 0 : return "ECPGd_ret_length";
8818 meskes@postgresql.or 732 :CBC 1 : case ECPGd_ret_octet:
2432 peter_e@gmx.net 733 : 1 : return "ECPGd_ret_octet";
734 : : break;
8768 bruce@momjian.us 735 : 1 : case ECPGd_scale:
2432 peter_e@gmx.net 736 : 1 : return "ECPGd_scale";
737 : : break;
8768 bruce@momjian.us 738 : 1 : case ECPGd_type:
2432 peter_e@gmx.net 739 : 1 : return "ECPGd_type";
740 : : break;
8274 meskes@postgresql.or 741 :UBC 0 : case ECPGd_cardinality:
2432 peter_e@gmx.net 742 : 0 : return "ECPGd_cardinality";
8818 meskes@postgresql.or 743 : 0 : default:
5560 peter_e@gmx.net 744 : 0 : mmerror(PARSE_ERROR, ET_ERROR, "unrecognized descriptor item code %d", type);
745 : : }
746 : :
8818 meskes@postgresql.or 747 : 0 : return NULL;
748 : : }
|
