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