Age Owner TLA Line data Source code
1 : /*
2 : * functions needed for descriptor handling
3 : *
4 : * src/interfaces/ecpg/preproc/descriptor.c
5 : *
6 : * since descriptor might be either a string constant or a string var
7 : * we need to check for a constant if we expect a constant
8 : */
9 :
10 : #include "postgres_fe.h"
11 :
12 : #include "preproc_extern.h"
13 :
14 : /*
15 : * assignment handling function (descriptor)
16 : */
17 :
18 : static struct assignment *assignments;
19 :
20 : void
8397 bruce 21 CBC 78 : push_assignment(char *var, enum ECPGdtype value)
22 : {
23 78 : struct assignment *new = (struct assignment *) mm_alloc(sizeof(struct assignment));
24 :
8451 meskes 25 78 : new->next = assignments;
8447 26 78 : new->variable = mm_alloc(strlen(var) + 1);
27 78 : strcpy(new->variable, var);
28 78 : new->value = value;
8451 29 78 : assignments = new;
8452 30 78 : }
31 :
32 : static void
33 54 : drop_assignments(void)
34 : {
8451 35 132 : while (assignments)
36 : {
37 78 : struct assignment *old_head = assignments;
38 :
39 78 : assignments = old_head->next;
8452 40 78 : free(old_head->variable);
41 78 : free(old_head);
42 : }
43 54 : }
44 :
45 : static void
5588 46 12 : ECPGnumeric_lvalue(char *name)
47 : {
8397 bruce 48 12 : const struct variable *v = find_variable(name);
49 :
7777 meskes 50 12 : switch (v->type->type)
51 : {
8452 52 12 : case ECPGt_short:
53 : case ECPGt_int:
54 : case ECPGt_long:
55 : case ECPGt_long_long:
56 : case ECPGt_unsigned_short:
57 : case ECPGt_unsigned_int:
58 : case ECPGt_unsigned_long:
59 : case ECPGt_unsigned_long_long:
60 : case ECPGt_const:
2310 tgl 61 12 : fputs(name, base_yyout);
8452 meskes 62 12 : break;
8452 meskes 63 UBC 0 : default:
5189 peter_e 64 0 : mmerror(PARSE_ERROR, ET_ERROR, "variable \"%s\" must have a numeric type", name);
8452 meskes 65 0 : break;
66 : }
8452 meskes 67 CBC 12 : }
68 :
69 : /*
70 : * descriptor name lookup
71 : */
72 :
73 : static struct descriptor *descriptors;
74 :
75 : void
8397 bruce 76 18 : add_descriptor(char *name, char *connection)
77 : {
78 : struct descriptor *new;
79 :
7836 80 18 : if (name[0] != '"')
81 1 : return;
82 :
7903 meskes 83 17 : new = (struct descriptor *) mm_alloc(sizeof(struct descriptor));
84 :
8447 85 17 : new->next = descriptors;
86 17 : new->name = mm_alloc(strlen(name) + 1);
8397 bruce 87 17 : strcpy(new->name, name);
88 17 : if (connection)
89 : {
8447 meskes 90 2 : new->connection = mm_alloc(strlen(connection) + 1);
91 2 : strcpy(new->connection, connection);
92 : }
93 : else
8397 bruce 94 15 : new->connection = connection;
8447 meskes 95 17 : descriptors = new;
96 : }
97 :
98 : void
8397 bruce 99 16 : drop_descriptor(char *name, char *connection)
100 : {
101 : struct descriptor *i;
102 16 : struct descriptor **lastptr = &descriptors;
103 :
7836 104 16 : if (name[0] != '"')
105 1 : return;
106 :
8397 107 19 : for (i = descriptors; i; lastptr = &i->next, i = i->next)
108 : {
4121 peter_e 109 19 : if (strcmp(name, i->name) == 0)
110 : {
8397 bruce 111 15 : if ((!connection && !i->connection)
112 2 : || (connection && i->connection
4121 peter_e 113 2 : && strcmp(connection, i->connection) == 0))
114 : {
8397 bruce 115 15 : *lastptr = i->next;
297 peter 116 GNC 15 : free(i->connection);
8451 meskes 117 CBC 15 : free(i->name);
118 15 : free(i);
8451 meskes 119 GIC 15 : return;
120 : }
121 : }
8451 meskes 122 EUB : }
604 meskes 123 UBC 0 : if (connection)
604 meskes 124 UIC 0 : mmerror(PARSE_ERROR, ET_WARNING, "descriptor %s bound to connection %s does not exist", name, connection);
604 meskes 125 EUB : else
604 meskes 126 UIC 0 : mmerror(PARSE_ERROR, ET_WARNING, "descriptor %s bound to the default connection does not exist", name);
127 : }
128 :
129 : struct descriptor
8053 bruce 130 ECB : *
8053 bruce 131 GIC 54 : lookup_descriptor(char *name, char *connection)
132 : {
133 : struct descriptor *i;
8397 bruce 134 ECB :
7836 bruce 135 CBC 54 : if (name[0] != '"')
7836 bruce 136 GIC 1 : return NULL;
7903 meskes 137 ECB :
8447 meskes 138 GIC 67 : for (i = descriptors; i; i = i->next)
8451 meskes 139 ECB : {
4121 peter_e 140 GIC 67 : if (strcmp(name, i->name) == 0)
8451 meskes 141 ECB : {
8397 bruce 142 CBC 53 : if ((!connection && !i->connection)
143 3 : || (connection && i->connection
4121 peter_e 144 3 : && strcmp(connection, i->connection) == 0))
8451 meskes 145 GBC 53 : return i;
604 meskes 146 UIC 0 : if (connection && !i->connection)
147 : {
604 meskes 148 EUB : /* overwrite descriptor's connection */
604 meskes 149 UBC 0 : i->connection = mm_strdup(connection);
604 meskes 150 UIC 0 : return i;
151 : }
152 : }
8451 meskes 153 EUB : }
604 meskes 154 UBC 0 : if (connection)
604 meskes 155 UIC 0 : mmerror(PARSE_ERROR, ET_WARNING, "descriptor %s bound to connection %s does not exist", name, connection);
604 meskes 156 EUB : else
604 meskes 157 UBC 0 : mmerror(PARSE_ERROR, ET_WARNING, "descriptor %s bound to the default connection does not exist", name);
8451 meskes 158 UIC 0 : return NULL;
159 : }
160 :
8452 meskes 161 ECB : void
8452 meskes 162 GIC 11 : output_get_descr_header(char *desc_name)
163 : {
164 : struct assignment *results;
8452 meskes 165 ECB :
2310 tgl 166 CBC 11 : fprintf(base_yyout, "{ ECPGget_desc_header(__LINE__, %s, &(", desc_name);
8451 meskes 167 GIC 22 : for (results = assignments; results != NULL; results = results->next)
8452 meskes 168 ECB : {
8447 meskes 169 CBC 11 : if (results->value == ECPGd_count)
5588 meskes 170 GIC 11 : ECPGnumeric_lvalue(results->variable);
8452 meskes 171 EUB : else
5189 peter_e 172 UIC 0 : mmerror(PARSE_ERROR, ET_WARNING, "descriptor header item \"%d\" does not exist", results->value);
173 : }
8397 bruce 174 ECB :
8451 meskes 175 CBC 11 : drop_assignments();
2310 tgl 176 11 : fprintf(base_yyout, "));\n");
8451 meskes 177 11 : whenever_action(3);
8452 meskes 178 GIC 11 : }
179 :
8452 meskes 180 ECB : void
8447 meskes 181 GIC 31 : output_get_descr(char *desc_name, char *index)
182 : {
183 : struct assignment *results;
8447 meskes 184 ECB :
2310 tgl 185 CBC 31 : fprintf(base_yyout, "{ ECPGget_desc(__LINE__, %s, %s,", desc_name, index);
8447 meskes 186 GIC 82 : for (results = assignments; results != NULL; results = results->next)
8452 meskes 187 ECB : {
8447 meskes 188 CBC 51 : const struct variable *v = find_variable(results->variable);
2495 rhaas 189 GIC 51 : char *str_zero = mm_strdup("0");
8397 bruce 190 ECB :
8447 meskes 191 GIC 51 : switch (results->value)
8452 meskes 192 EUB : {
8447 meskes 193 UBC 0 : case ECPGd_nullable:
7704 bruce 194 0 : mmerror(PARSE_ERROR, ET_WARNING, "nullable is always 1");
8447 meskes 195 0 : break;
196 0 : case ECPGd_key_member:
7704 bruce 197 0 : mmerror(PARSE_ERROR, ET_WARNING, "key_member is always 0");
8447 meskes 198 LBC 0 : break;
8447 meskes 199 CBC 51 : default:
8397 bruce 200 GIC 51 : break;
8452 meskes 201 ECB : }
2310 tgl 202 CBC 51 : fprintf(base_yyout, "%s,", get_dtype(results->value));
2310 tgl 203 GIC 51 : ECPGdump_a_type(base_yyout, v->name, v->type, v->brace_level,
2310 tgl 204 ECB : NULL, NULL, -1, NULL, NULL, str_zero, NULL, NULL);
2858 meskes 205 GIC 51 : free(str_zero);
8452 meskes 206 ECB : }
8452 meskes 207 CBC 31 : drop_assignments();
2310 tgl 208 GIC 31 : fputs("ECPGd_EODT);\n", base_yyout);
8397 bruce 209 ECB :
8397 bruce 210 CBC 31 : whenever_action(2 | 1);
8452 meskes 211 GIC 31 : }
212 :
6857 meskes 213 ECB : void
6857 meskes 214 GIC 1 : output_set_descr_header(char *desc_name)
215 : {
216 : struct assignment *results;
6857 meskes 217 ECB :
2310 tgl 218 CBC 1 : fprintf(base_yyout, "{ ECPGset_desc_header(__LINE__, %s, (int)(", desc_name);
6857 meskes 219 GIC 2 : for (results = assignments; results != NULL; results = results->next)
6857 meskes 220 ECB : {
6857 meskes 221 CBC 1 : if (results->value == ECPGd_count)
5588 meskes 222 GIC 1 : ECPGnumeric_lvalue(results->variable);
6857 meskes 223 EUB : else
5189 peter_e 224 UIC 0 : mmerror(PARSE_ERROR, ET_WARNING, "descriptor header item \"%d\" does not exist", results->value);
225 : }
6857 meskes 226 ECB :
6857 meskes 227 CBC 1 : drop_assignments();
2310 tgl 228 1 : fprintf(base_yyout, "));\n");
6857 meskes 229 1 : whenever_action(3);
6857 meskes 230 GIC 1 : }
231 :
6857 meskes 232 EUB : static const char *
6857 meskes 233 UIC 0 : descriptor_item_name(enum ECPGdtype itemcode)
6857 meskes 234 EUB : {
6857 meskes 235 UIC 0 : switch (itemcode)
6857 meskes 236 EUB : {
6857 meskes 237 UBC 0 : case ECPGd_cardinality:
238 0 : return "CARDINALITY";
239 0 : case ECPGd_count:
240 0 : return "COUNT";
241 0 : case ECPGd_data:
242 0 : return "DATA";
243 0 : case ECPGd_di_code:
244 0 : return "DATETIME_INTERVAL_CODE";
245 0 : case ECPGd_di_precision:
246 0 : return "DATETIME_INTERVAL_PRECISION";
247 0 : case ECPGd_indicator:
248 0 : return "INDICATOR";
249 0 : case ECPGd_key_member:
250 0 : return "KEY_MEMBER";
251 0 : case ECPGd_length:
252 0 : return "LENGTH";
253 0 : case ECPGd_name:
254 0 : return "NAME";
255 0 : case ECPGd_nullable:
256 0 : return "NULLABLE";
257 0 : case ECPGd_octet:
258 0 : return "OCTET_LENGTH";
259 0 : case ECPGd_precision:
260 0 : return "PRECISION";
261 0 : case ECPGd_ret_length:
262 0 : return "RETURNED_LENGTH";
263 0 : case ECPGd_ret_octet:
264 0 : return "RETURNED_OCTET_LENGTH";
265 0 : case ECPGd_scale:
266 0 : return "SCALE";
267 0 : case ECPGd_type:
268 0 : return "TYPE";
269 0 : default:
6857 meskes 270 UIC 0 : return NULL;
271 : }
272 : }
273 :
6857 meskes 274 ECB : void
6857 meskes 275 GIC 11 : output_set_descr(char *desc_name, char *index)
276 : {
277 : struct assignment *results;
6857 meskes 278 ECB :
2310 tgl 279 CBC 11 : fprintf(base_yyout, "{ ECPGset_desc(__LINE__, %s, %s,", desc_name, index);
6857 meskes 280 GIC 26 : for (results = assignments; results != NULL; results = results->next)
6857 meskes 281 ECB : {
6857 meskes 282 GIC 15 : const struct variable *v = find_variable(results->variable);
6857 meskes 283 ECB :
6857 meskes 284 GIC 15 : switch (results->value)
6857 meskes 285 EUB : {
6857 meskes 286 UIC 0 : case ECPGd_cardinality:
287 : case ECPGd_di_code:
288 : case ECPGd_di_precision:
289 : case ECPGd_precision:
6857 meskes 290 EUB : case ECPGd_scale:
3435 peter_e 291 UIC 0 : mmfatal(PARSE_ERROR, "descriptor item \"%s\" is not implemented",
292 : descriptor_item_name(results->value));
293 : break;
6857 meskes 294 EUB :
6857 meskes 295 UIC 0 : case ECPGd_key_member:
296 : case ECPGd_name:
297 : case ECPGd_nullable:
298 : case ECPGd_octet:
299 : case ECPGd_ret_length:
6857 meskes 300 EUB : case ECPGd_ret_octet:
3435 peter_e 301 UIC 0 : mmfatal(PARSE_ERROR, "descriptor item \"%s\" cannot be set",
302 : descriptor_item_name(results->value));
303 : break;
6857 meskes 304 ECB :
6857 meskes 305 GIC 15 : case ECPGd_data:
306 : case ECPGd_indicator:
307 : case ECPGd_length:
308 : case ECPGd_type:
2858 meskes 309 ECB : {
2495 rhaas 310 GIC 15 : char *str_zero = mm_strdup("0");
2495 rhaas 311 ECB :
2310 tgl 312 CBC 15 : fprintf(base_yyout, "%s,", get_dtype(results->value));
2310 tgl 313 GIC 15 : ECPGdump_a_type(base_yyout, v->name, v->type, v->brace_level,
2118 tgl 314 ECB : NULL, NULL, -1, NULL, NULL, str_zero, NULL, NULL);
2858 meskes 315 GIC 15 : free(str_zero);
2858 meskes 316 ECB : }
6857 meskes 317 GIC 15 : break;
6857 meskes 318 ECB :
6857 meskes 319 GIC 15 : default:
320 : ;
321 : }
6857 meskes 322 ECB : }
6857 meskes 323 CBC 11 : drop_assignments();
2310 tgl 324 GIC 11 : fputs("ECPGd_EODT);\n", base_yyout);
6857 meskes 325 ECB :
6857 meskes 326 CBC 11 : whenever_action(2 | 1);
6857 meskes 327 GIC 11 : }
328 :
329 : /* I consider dynamic allocation overkill since at most two descriptor
330 : variables are possible per statement. (input and output descriptor)
331 : And descriptors are no normal variables, so they don't belong into
332 : the variable list.
333 : */
334 :
335 : #define MAX_DESCRIPTOR_NAMELEN 128
7836 bruce 336 ECB : struct variable *
7836 bruce 337 GIC 22 : descriptor_variable(const char *name, int input)
338 : {
339 : static char descriptor_names[2][MAX_DESCRIPTOR_NAMELEN];
340 : static struct ECPGtype descriptor_type = {ECPGt_descriptor, NULL, NULL, NULL, {NULL}, 0};
341 : static struct variable varspace[2] = {
342 : {descriptor_names[0], &descriptor_type, 0, NULL},
343 : {descriptor_names[1], &descriptor_type, 0, NULL}
344 : };
7836 bruce 345 ECB :
5905 peter_e 346 CBC 22 : strlcpy(descriptor_names[input], name, sizeof(descriptor_names[input]));
4055 peter_e 347 GIC 22 : return &varspace[input];
348 : }
349 :
4842 meskes 350 ECB : struct variable *
4842 meskes 351 GIC 24 : sqlda_variable(const char *name)
4842 meskes 352 ECB : {
4842 meskes 353 GIC 24 : struct variable *p = (struct variable *) mm_alloc(sizeof(struct variable));
4842 meskes 354 ECB :
4842 meskes 355 CBC 24 : p->name = mm_strdup(name);
356 24 : p->type = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
357 24 : p->type->type = ECPGt_sqlda;
358 24 : p->type->size = NULL;
359 24 : p->type->struct_sizeof = NULL;
360 24 : p->type->u.element = NULL;
4779 361 24 : p->type->counter = 0;
4842 362 24 : p->brace_level = 0;
4842 meskes 363 GIC 24 : p->next = NULL;
4842 meskes 364 ECB :
4842 meskes 365 GIC 24 : return p;
366 : }
|
