Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
14 : * (author) M. Kersten
15 : * For documentation see website
16 : */
17 : #include "monetdb_config.h"
18 : #include "mal_function.h"
19 : #include "mal_resolve.h" /* for isPolymorphic() & chkProgram() */
20 : #include "mal_interpreter.h" /* for showErrors() */
21 : #include "mal_listing.h"
22 : #include "mal_namespace.h"
23 : #include "mal_private.h"
24 :
25 : Symbol
26 50642 : newFunctionArgs(const char *mod, const char *nme, int kind, int args)
27 : {
28 50642 : Symbol s;
29 :
30 50642 : if (mod == NULL || nme == NULL)
31 : return NULL;
32 :
33 50642 : s = newSymbol(nme, kind);
34 50642 : if (s == NULL)
35 : return NULL;
36 :
37 50642 : if (kind == FUNCTIONsymbol) {
38 50629 : int varid = newVariable(s->def, nme, strlen(nme), TYPE_any);
39 50622 : if (varid < 0) {
40 0 : freeSymbol(s);
41 0 : return NULL;
42 : }
43 :
44 50622 : if (args > 0) {
45 50611 : InstrPtr p = newInstructionArgs(NULL, mod, nme, args);
46 50616 : if (p == NULL) {
47 0 : freeSymbol(s);
48 0 : return NULL;
49 : }
50 50616 : p->token = kind;
51 50616 : p->barrier = 0;
52 50616 : setDestVar(p, varid);
53 50616 : pushInstruction(s->def, p);
54 50612 : if (s->def->errors) {
55 0 : freeSymbol(s);
56 0 : return NULL;
57 : }
58 : }
59 : }
60 : return s;
61 : }
62 :
63 : Symbol
64 49407 : newFunction(const char *mod, const char *nme, int kind)
65 : {
66 49407 : return newFunctionArgs(mod, nme, kind, MAXARG);
67 : }
68 :
69 : int
70 174899 : getPC(MalBlkPtr mb, InstrPtr p)
71 : {
72 174899 : int i;
73 1955517 : for (i = 0; i < mb->stop; i++)
74 1955524 : if (getInstrPtr(mb, i) == p)
75 174906 : return i;
76 : return -1;
77 : }
78 :
79 : /*
80 : * Checking the control flow structure is done by a single pass over the
81 : * MAL program after the program has been type-checked.
82 : * It should inspect all BARRIER and CATCH blocks for proper structure.
83 : * If the flow is correct and not dependent on an undefined typed instruction
84 : * we avoid doing this check any further.
85 : */
86 : #define DEPTH 128
87 :
88 : str
89 3601364 : chkFlow(MalBlkPtr mb)
90 : {
91 3601364 : int i, j, k, v, lastInstruction;
92 3601364 : int pc[DEPTH];
93 3601364 : int var[DEPTH];
94 3601364 : InstrPtr stmt[DEPTH];
95 3601364 : int btop = 0;
96 3601364 : int endseen = 0, retseen = 0;
97 3601364 : InstrPtr p, sig;
98 3601364 : str msg = MAL_SUCCEED;
99 3601364 : char name[IDLENGTH];
100 :
101 3601364 : if (mb->errors != MAL_SUCCEED)
102 : return mb->errors;
103 3603143 : sig = getInstrPtr(mb, 0);
104 3603143 : lastInstruction = mb->stop - 1;
105 244378608 : for (i = 0; i < mb->stop; i++) {
106 240775478 : p = getInstrPtr(mb, i);
107 : /* we have to keep track on the maximal arguments/block
108 : because it is needed by the interpreter */
109 240775478 : switch (p->barrier) {
110 278277 : case BARRIERsymbol:
111 : case CATCHsymbol:
112 278277 : if (btop == DEPTH)
113 0 : throw(MAL, "chkFlow", "%s.%s Too many nested MAL blocks",
114 : getModuleId(sig), getFunctionId(sig));
115 278277 : pc[btop] = i;
116 278277 : v = var[btop] = getDestVar(p);
117 278277 : stmt[btop] = p;
118 :
119 278999 : for (j = btop - 1; j >= 0; j--)
120 722 : if (v == var[j])
121 0 : throw(MAL, "chkFlow",
122 : "%s.%s recursive %s[%d] shields %s[%d]",
123 : getModuleId(sig), getFunctionId(sig), getVarNameIntoBuffer(mb, v, name),
124 0 : pc[j], getFcnName(mb), pc[i]);
125 :
126 278277 : btop++;
127 278277 : break;
128 278433 : case EXITsymbol:
129 278433 : v = getDestVar(p);
130 278433 : if (btop > 0 && var[btop - 1] != v) {
131 3 : char name2[IDLENGTH];
132 3 : throw(MAL, "chkFlow",
133 : "%s.%s exit-label '%s' does not match '%s'",
134 : getModuleId(sig), getFunctionId(sig), getVarNameIntoBuffer(mb, v, name),
135 : getVarNameIntoBuffer(mb, var[btop - 1], name2));
136 : }
137 278430 : if (btop == 0)
138 0 : throw(MAL, "chkFlow",
139 : "%s.%s exit-label '%s' without begin-label",
140 : getModuleId(sig), getFunctionId(sig), getVarNameIntoBuffer(mb, v, name));
141 : /* search the matching block */
142 278430 : for (j = btop - 1; j >= 0; j--)
143 278382 : if (var[j] == v)
144 : break;
145 278430 : if (j >= 0)
146 : btop = j;
147 : else
148 0 : btop--;
149 :
150 : /* retrofit LEAVE/REDO instructions */
151 278430 : stmt[btop]->jump = i;
152 28246357 : for (k = pc[btop]; k < i; k++) {
153 27967927 : InstrPtr p1 = getInstrPtr(mb, k);
154 27967927 : if (getDestVar(p1) == v) {
155 : /* handle assignments with leave/redo option */
156 287729 : if (p1->barrier == LEAVEsymbol)
157 607 : p1->jump = i;
158 287729 : if (p1->barrier == REDOsymbol)
159 9001 : p1->jump = pc[btop] + 1;
160 : }
161 : }
162 : break;
163 9622 : case LEAVEsymbol:
164 : case REDOsymbol:
165 9622 : v = getDestVar(p);
166 9631 : for (j = btop - 1; j >= 0; j--)
167 9623 : if (var[j] == v)
168 : break;
169 : if (j < 0) {
170 8 : throw(MAL, "chkFlow", "%s.%s label '%s' not in guarded block",
171 : getModuleId(sig), getFunctionId(sig),
172 : getVarNameIntoBuffer(mb, v, name));
173 : }
174 : break;
175 3634 : case RETURNsymbol: {
176 3634 : InstrPtr ps = getInstrPtr(mb, 0);
177 3634 : int e;
178 3634 : if (ps->retc != p->retc) {
179 2 : throw(MAL, "chkFlow", "%s.%s invalid return target!",
180 : getModuleId(sig), getFunctionId(sig));
181 3632 : } else if (ps->typeresolved)
182 22005 : for (e = 0; e < p->retc; e++) {
183 18382 : if (resolvedType(getArgType(mb, ps, e), getArgType(mb, p, e)) < 0) {
184 0 : str tpname = getTypeName(getArgType(mb, p, e));
185 0 : msg = createException(MAL,
186 : "%s.%s RETURN type mismatch at type '%s'\n",
187 0 : getModuleId(p) ? getModuleId(p) :
188 : "",
189 0 : getFunctionId(p) ?
190 : getFunctionId(p) : "", tpname);
191 0 : GDKfree(tpname);
192 0 : return msg;
193 : }
194 : }
195 : //if (btop == 0)
196 : retseen = 1;
197 : break;
198 : }
199 : case RAISEsymbol:
200 : endseen = 1;
201 : break;
202 : case ENDsymbol:
203 : endseen = 1;
204 : break;
205 240204869 : default:
206 240204869 : if (isaSignature(p)) {
207 33847478 : if (p->token == REMsymbol) {
208 : /* do nothing */
209 3602530 : } else if (i) {
210 0 : str l = instruction2str(mb, 0, p, TRUE);
211 0 : msg = createException(MAL, "%s.%s signature misplaced\n!%s",
212 : getModuleId(p), getFunctionId(p), l);
213 0 : GDKfree(l);
214 0 : return msg;
215 : }
216 : }
217 : }
218 : }
219 :
220 3603130 : if (lastInstruction < mb->stop - 1)
221 0 : throw(MAL, "chkFlow", "%s.%s instructions after END", getModuleId(sig),
222 : getFunctionId(sig));
223 :
224 3603130 : if (endseen && btop > 0)
225 0 : throw(MAL, "chkFlow", "barrier '%s' without exit in %s[%d]",
226 0 : getVarNameIntoBuffer(mb, var[btop - 1], name), getFcnName(mb), i);
227 3603130 : p = getInstrPtr(mb, 0);
228 3603130 : if (!isaSignature(p))
229 0 : throw(MAL, "chkFlow", "%s.%s signature missing", getModuleId(sig),
230 : getFunctionId(sig));
231 3603130 : if (retseen == 0) {
232 3600503 : if (getArgType(mb, p, 0) != TYPE_void && (p->token == FUNCTIONsymbol))
233 0 : throw(MAL, "chkFlow", "%s.%s RETURN missing", getModuleId(sig),
234 : getFunctionId(sig));
235 : }
236 : return MAL_SUCCEED;
237 : }
238 :
239 : /*
240 : * A code may contain temporary names for marking barrier blocks.
241 : * Since they are introduced by the compiler, the parser should locate
242 : * them itself when encountering the LEAVE,EXIT,REDO.
243 : * The starting position is mostly the last statement entered.
244 : * Purposely, the nameless envelops searches the name of the last
245 : * unclosed block. All others are ignored.
246 : */
247 : int
248 4 : getBarrierEnvelop(MalBlkPtr mb)
249 : {
250 4 : int pc;
251 4 : InstrPtr p;
252 10 : for (pc = mb->stop - 2; pc >= 0; pc--) {
253 9 : p = getInstrPtr(mb, pc);
254 9 : if (blockExit(p)) {
255 1 : int l = p->argv[0];
256 4 : for (; pc >= 0; pc--) {
257 4 : p = getInstrPtr(mb, pc);
258 4 : if (blockStart(p) && p->argv[0] == l)
259 : break;
260 : }
261 1 : continue;
262 : }
263 8 : if (blockStart(p))
264 3 : return p->argv[0];
265 : }
266 1 : return newTmpVariable(mb, TYPE_any);
267 : }
268 :
269 : static void
270 14 : replaceTypeVar(MalBlkPtr mb, InstrPtr p, int v, malType t)
271 : {
272 83 : for (int j = 0; j < mb->stop; j++) {
273 69 : p = getInstrPtr(mb, j);
274 69 : if (p->polymorphic) {
275 94 : for (int i = 0; i < p->argc; i++) {
276 68 : int x = getArgType(mb, p, i);
277 68 : if (isPolymorphic(x) && getTypeIndex(x) == v) {
278 33 : if (isaBatType(x)) {
279 17 : int tail = newBatType(t);
280 17 : setArgType(mb, p, i, tail);
281 : } else {
282 16 : setArgType(mb, p, i, t);
283 : }
284 : }
285 : }
286 : }
287 : }
288 14 : }
289 :
290 : /* insert a symbol into the symbol table just before the symbol
291 : * "before". */
292 : static void
293 11 : insertSymbolBefore(Module scope, Symbol prg, Symbol before)
294 : {
295 11 : int t;
296 11 : Symbol s;
297 :
298 11 : assert(strcmp(prg->name, before->name) == 0);
299 11 : t = getSymbolIndex(prg->name);
300 11 : assert(scope->space != NULL);
301 11 : assert(scope->space[t] != NULL);
302 11 : s = scope->space[t];
303 11 : prg->skip = before->skip;
304 11 : prg->peer = before;
305 11 : if (s == before) {
306 9 : scope->space[t] = prg;
307 : } else {
308 3 : for (;;) {
309 3 : assert(s != NULL);
310 3 : if (s->skip == before) {
311 0 : s->skip = prg;
312 : }
313 3 : if (s->peer == before) {
314 2 : s->peer = prg;
315 2 : break;
316 : }
317 : s = s->peer;
318 : }
319 : }
320 11 : }
321 :
322 : /*
323 : * Upon cloning a function we should remove all the polymorphic flags.
324 : * Otherwise we may end up with a recursive clone.
325 : */
326 : Symbol
327 11 : cloneFunction(Module scope, Symbol proc, MalBlkPtr mb, InstrPtr p)
328 : {
329 11 : Symbol new;
330 11 : int i, v;
331 11 : InstrPtr pp;
332 11 : str msg = MAL_SUCCEED;
333 :
334 11 : new = newFunctionArgs(scope->name, proc->name, proc->kind, -1);
335 11 : if (new == NULL) {
336 : return NULL;
337 : }
338 11 : freeMalBlk(new->def);
339 11 : if ((new->def = copyMalBlk(proc->def)) == NULL) {
340 0 : freeSymbol(new);
341 0 : return NULL;
342 : }
343 : /* now change the definition of the original proc */
344 : /* check for errors after fixation , TODO */
345 11 : pp = getSignature(new);
346 43 : for (i = 0; i < pp->argc; i++)
347 32 : if (isPolymorphic(v = getArgType(new->def, pp, i))) {
348 14 : int t = getArgType(mb, p, i);
349 :
350 14 : if (v == TYPE_any) {
351 : assert(0);
352 : replaceTypeVar(new->def, pp, v, t);
353 : }
354 14 : if (isaBatType(v)) {
355 14 : if (getTypeIndex(v))
356 14 : replaceTypeVar(new->def, pp, getTypeIndex(v), getBatType(t));
357 : } else
358 0 : replaceTypeVar(new->def, pp, getTypeIndex(v), t);
359 : }
360 : /* include the function at the proper place in the scope */
361 11 : insertSymbolBefore(scope, new, proc);
362 : /* clear polymorphic and type to force analysis */
363 76 : for (i = 0; i < new->def->stop; i++) {
364 54 : pp = getInstrPtr(new->def, i);
365 54 : pp->typeresolved = false;
366 54 : pp->polymorphic = 0;
367 : }
368 : /* clear type fixations */
369 85 : for (i = 0; i < new->def->vtop; i++)
370 74 : clrVarFixed(new->def, i);
371 :
372 :
373 : /* check for errors after fixation , TODO */
374 : /* beware, we should now ignore any cloning */
375 11 : if (proc->def->errors == 0) {
376 11 : msg = chkProgram(scope, new->def);
377 11 : if (msg)
378 3 : mb->errors = msg;
379 8 : else if (new->def->errors) {
380 0 : assert(mb->errors == NULL);
381 0 : mb->errors = new->def->errors;
382 0 : mb->errors = createMalException(mb, 0, TYPE, "Error in cloned function");
383 0 : new->def->errors = 0;
384 : }
385 : }
386 :
387 : return new;
388 : }
389 :
390 : /*
391 : * For commands we do not have to clone the routine. We merely have to
392 : * assure that the type-constraints are obeyed. The resulting type
393 : * is returned.
394 : */
395 : void
396 0 : debugFunction(stream *fd, MalBlkPtr mb, MalStkPtr stk, int flg, int first,
397 : int step)
398 : {
399 0 : int i, j;
400 0 : str ps;
401 0 : InstrPtr p;
402 :
403 0 : if (mb == NULL) {
404 0 : mnstr_printf(fd, "# function definition missing\n");
405 0 : return;
406 : }
407 0 : if (flg == 0 || step < 0 || first < 0)
408 : return;
409 :
410 0 : if (mb->errors)
411 0 : mnstr_printf(fd, "#errors seen: %s\n", mb->errors);
412 0 : for (i = first; i < first + step && i < mb->stop; i++) {
413 0 : ps = instruction2str(mb, stk, (p = getInstrPtr(mb, i)), flg);
414 0 : if (ps) {
415 0 : if (p->token == REMsymbol)
416 0 : mnstr_printf(fd, "%-40s\n", ps);
417 : else {
418 0 : mnstr_printf(fd, "%-40s\t#[%d] %s ", ps, i,
419 0 : (p->blk ? p->blk->binding : ""));
420 0 : if (flg & LIST_MAL_FLOW) {
421 0 : for (j = 0; j < p->retc; j++)
422 0 : mnstr_printf(fd, "%d ", getArg(p, j));
423 0 : if (p->argc - p->retc > 0)
424 0 : mnstr_printf(fd, "<- ");
425 0 : for (; j < p->argc; j++)
426 0 : mnstr_printf(fd, "%d ", getArg(p, j));
427 : }
428 0 : mnstr_printf(fd, "\n");
429 : }
430 0 : GDKfree(ps);
431 : } else
432 0 : mnstr_printf(fd, "#failed instruction2str()\n");
433 : }
434 : }
435 :
436 : void
437 58 : listFunction(stream *fd, MalBlkPtr mb, MalStkPtr stk, int flg, int first,
438 : int size)
439 : {
440 58 : int i;
441 58 : int sample = 256;
442 :
443 58 : if (mb == NULL) {
444 0 : mnstr_printf(fd, "# function definition missing\n");
445 0 : return;
446 : }
447 58 : if (flg == 0)
448 : return;
449 :
450 58 : assert(size >= 0);
451 58 : assert(first >= 0 && first < mb->stop);
452 58 : if (flg & LIST_MAL_MAPI) {
453 54 : size_t len = 0;
454 54 : str ps;
455 54 : mnstr_printf(fd, "&1 0 %d 1 %d\n", /* type id rows columns tuples */
456 : mb->stop, mb->stop);
457 54 : mnstr_printf(fd, "%% .explain # table_name\n");
458 54 : mnstr_printf(fd, "%% mal # name\n");
459 54 : mnstr_printf(fd, "%% clob # type\n");
460 2759 : for (i = first; i < first + size && i < mb->stop && sample-- > 0; i++) {
461 2651 : ps = instruction2str(mb, stk, getInstrPtr(mb, i), flg);
462 2651 : if (ps) {
463 2651 : size_t l = strlen(ps);
464 2651 : if (l > len)
465 : len = l;
466 2651 : GDKfree(ps);
467 : } else
468 0 : mnstr_printf(fd, "#failed instruction2str()\n");
469 : }
470 54 : mnstr_printf(fd, "%% %zu # length\n", len);
471 : }
472 2749 : for (i = first; i < first + size && i < mb->stop; i++)
473 2691 : printInstruction(fd, mb, stk, getInstrPtr(mb, i), flg);
474 : }
475 :
476 :
477 : void
478 58 : printFunction(stream *fd, MalBlkPtr mb, MalStkPtr stk, int flg)
479 : {
480 58 : int i, j;
481 58 : InstrPtr p;
482 :
483 :
484 : // Set the used bits properly
485 5953 : for (i = 0; i < mb->vtop; i++)
486 5895 : clrVarUsed(mb, i);
487 :
488 :
489 2749 : for (i = 0; i < mb->stop; i++) {
490 2691 : p = getInstrPtr(mb, i);
491 8883 : for (j = p->retc; j < p->argc; j++)
492 6192 : setVarUsed(mb, getArg(p, j));
493 2691 : if (p->barrier)
494 24 : for (j = 0; j < p->retc; j++)
495 12 : setVarUsed(mb, getArg(p, j));
496 : }
497 58 : listFunction(fd, mb, stk, flg, 0, mb->stop);
498 58 : }
499 :
500 : /* initialize the static scope boundaries for all variables */
501 : void
502 2884404 : setVariableScope(MalBlkPtr mb)
503 : {
504 2884404 : int pc, k, depth = 0, dflow = -1;
505 2884404 : InstrPtr p;
506 :
507 : /* reset the scope admin */
508 318358678 : for (k = 0; k < mb->vtop; k++)
509 315474274 : if (isVarConstant(mb, k)) {
510 85362156 : setVarScope(mb, k, 0);
511 85362156 : setVarDeclared(mb, k, 0);
512 85362156 : setVarUpdated(mb, k, 0);
513 85362156 : setVarEolife(mb, k, mb->stop);
514 : } else {
515 230112118 : setVarScope(mb, k, 0);
516 230112118 : setVarDeclared(mb, k, 0);
517 230112118 : setVarUpdated(mb, k, 0);
518 230112118 : setVarEolife(mb, k, 0);
519 : }
520 :
521 166533266 : for (pc = 0; pc < mb->stop; pc++) {
522 163648862 : p = getInstrPtr(mb, pc);
523 :
524 163648862 : if (blockStart(p)) {
525 492927 : if (getModuleId(p) && getFunctionId(p)
526 488376 : && strcmp(getModuleId(p), "language") == 0
527 475704 : && strcmp(getFunctionId(p), "dataflow") == 0) {
528 475728 : if (dflow != -1)
529 0 : addMalException(mb,
530 : "setLifeSpan nested dataflow blocks not allowed");
531 : dflow = depth;
532 : } else
533 17199 : depth++;
534 : }
535 :
536 727891239 : for (k = 0; k < p->argc; k++) {
537 564242377 : int v = getArg(p, k);
538 564242377 : if (isVarConstant(mb, v) && getVarUpdated(mb, v) == 0)
539 77660219 : setVarUpdated(mb, v, pc);
540 :
541 564242377 : if (getVarDeclared(mb, v) == 0) {
542 244292646 : setVarDeclared(mb, v, pc);
543 244292646 : setVarScope(mb, v, depth);
544 : }
545 564242377 : if (k < p->retc)
546 167355962 : setVarUpdated(mb, v, pc);
547 564242377 : if (getVarScope(mb, v) == depth)
548 564123588 : setVarEolife(mb, v, pc);
549 :
550 564242377 : if (k >= p->retc && getVarScope(mb, v) < depth)
551 73723 : setVarEolife(mb, v, -1);
552 : }
553 : /*
554 : * At a block exit we can finalize all variables defined within that block.
555 : * This does not hold for dataflow blocks. They merely direct the execution
556 : * thread, not the syntactic scope.
557 : */
558 163648862 : if (blockExit(p)) {
559 162058635 : for (k = 0; k < mb->vtop; k++)
560 161565757 : if (getVarEolife(mb, k) == 0 && getVarScope(mb, k) == depth)
561 50683501 : setVarEolife(mb, k, pc);
562 110882256 : else if (getVarEolife(mb, k) == -1)
563 44950 : setVarEolife(mb, k, pc);
564 :
565 492878 : if (dflow == depth)
566 : dflow = -1;
567 : else
568 17116 : depth--;
569 : }
570 163648862 : if (blockReturn(p)) {
571 26640 : for (k = 0; k < p->argc; k++)
572 23994 : setVarEolife(mb, getArg(p, k), pc);
573 : }
574 : }
575 318598641 : for (k = 0; k < mb->vtop; k++)
576 315714237 : if (getVarEolife(mb, k) == 0)
577 27454297 : setVarEolife(mb, k, mb->stop - 1);
578 2884404 : }
579 :
580 : int
581 0 : isLoopBarrier(MalBlkPtr mb, int pc)
582 : {
583 0 : InstrPtr p;
584 0 : int varid;
585 0 : p = getInstrPtr(mb, pc);
586 0 : if (p->barrier != BARRIERsymbol)
587 : return 0;
588 0 : varid = getDestVar(p);
589 0 : for (pc++; pc < mb->stop; pc++) {
590 0 : p = getInstrPtr(mb, pc);
591 0 : if (p->barrier == REDOsymbol && getDestVar(p) == varid)
592 : return 1;
593 0 : if (p->barrier == EXITsymbol && getDestVar(p) == varid)
594 : break;
595 : }
596 : return 0;
597 : }
598 :
599 : int
600 0 : getBlockBegin(MalBlkPtr mb, int pc)
601 : {
602 0 : InstrPtr p;
603 0 : int varid = 0, i;
604 :
605 0 : for (i = pc; i < mb->stop; i++) {
606 0 : p = getInstrPtr(mb, i);
607 0 : if (p->barrier == EXITsymbol) {
608 0 : varid = getDestVar(p);
609 0 : break;
610 : }
611 : }
612 0 : if (i == mb->stop)
613 : return 0;
614 :
615 0 : for (; pc > 0; pc--) {
616 0 : p = getInstrPtr(mb, pc);
617 0 : if ((p->barrier == BARRIERsymbol || p->barrier == CATCHsymbol) &&
618 0 : getDestVar(p) == varid)
619 0 : return pc;
620 : }
621 : return 0;
622 : }
623 :
624 : int
625 0 : getBlockExit(MalBlkPtr mb, int pc)
626 : {
627 0 : InstrPtr p;
628 0 : int varid;
629 0 : p = getInstrPtr(mb, pc);
630 0 : if (p->barrier != BARRIERsymbol && p->barrier != CATCHsymbol)
631 : return 0;
632 0 : varid = getDestVar(p);
633 0 : for (pc++; pc < mb->stop; pc++) {
634 0 : p = getInstrPtr(mb, pc);
635 0 : if (p->barrier == EXITsymbol && getDestVar(p) == varid)
636 0 : return pc;
637 : }
638 : return 0;
639 : }
640 :
641 : /*
642 : * Variable declaration
643 : * Variables are implicitly declared upon first use.
644 : * This feature may become a source of runtime errors and
645 : * complicates the analyse during optimization.
646 : * Therefore, in line with the flow of control check,
647 : * we make sure that all variables are properly initialized
648 : * before being used. Since barrier blocks may be skipped at
649 : * runtime, they actually introduce a separate scope.
650 : * Variables declared within a block may not be used outside it.
651 : * Variables can only be declared once.
652 : *
653 : * In many situation chkFlow and chkDeclarations should be called
654 : * together. Moreover, an erroneous chkFlow most likely implies
655 : * errors in the declarations as well.
656 : *
657 : * Since in interactive mode each statement is handled separately,
658 : * we have to remember the scope assigned to a variable.
659 : */
660 : void
661 0 : clrDeclarations(MalBlkPtr mb)
662 : {
663 0 : int i;
664 0 : for (i = 0; i < mb->vtop; i++) {
665 0 : clrVarInit(mb, i);
666 0 : clrVarUsed(mb, i);
667 0 : clrVarDisabled(mb, i);
668 : }
669 0 : }
670 :
671 : str
672 3603484 : chkDeclarations(MalBlkPtr mb)
673 : {
674 3603484 : int pc, i, k, l;
675 3603484 : InstrPtr p, sig;
676 3603484 : short blks[MAXDEPTH], top = 0, blkId = 1;
677 3603484 : int dflow = -1;
678 3603484 : str msg = MAL_SUCCEED;
679 3603484 : char name[IDLENGTH];
680 :
681 3603484 : if (mb->errors)
682 0 : return GDKstrdup(mb->errors);
683 3603484 : blks[top] = blkId;
684 :
685 : /* initialize the scope */
686 460136288 : for (i = 0; i < mb->vtop; i++)
687 456532804 : setVarScope(mb, i, 0);
688 :
689 : /* all signature variables are declared at outer level */
690 3603484 : sig = getInstrPtr(mb, 0);
691 7226612 : for (k = 0; k < sig->argc; k++)
692 3623128 : setVarScope(mb, getArg(sig, k), blkId);
693 :
694 240541767 : for (pc = 1; pc < mb->stop; pc++) {
695 236938288 : p = getInstrPtr(mb, pc);
696 236938288 : if (p->token == REMsymbol)
697 30248576 : continue;
698 : /* check correct use of the arguments */
699 813092348 : for (k = p->retc; k < p->argc; k++) {
700 606402641 : l = getArg(p, k);
701 606402641 : if (l < 0)
702 0 : throw(MAL, "chkFlow",
703 : "%s.%s Non-declared variable: pc=%d, var= %d",
704 : getModuleId(sig), getFunctionId(sig), pc, k);
705 606402641 : setVarUsed(mb, l);
706 606402641 : if (getVarScope(mb, l) == 0) {
707 : /*
708 : * The problem created here is that only variables are
709 : * recognized that are declared through instructions.
710 : * For interactive code, and code that is based on a global
711 : * stack this is insufficient. In those cases, the variable
712 : * can be defined in a previous execution.
713 : * We have to recognize if the declaration takes place
714 : * in the context of a global stack.
715 : */
716 249573228 : if (p->barrier == CATCHsymbol) {
717 0 : setVarScope(mb, l, blks[0]);
718 249573228 : } else if (!(isVarConstant(mb, l) || isVarTypedef(mb, l))
719 12615 : && !isVarInit(mb, l)) {
720 5 : throw(MAL, "chkFlow",
721 : "%s.%s '%s' may not be used before being initialized",
722 : getModuleId(sig), getFunctionId(sig), getVarNameIntoBuffer(mb, l, name));
723 : }
724 356829413 : } else if (!isVarInit(mb, l)) {
725 : /* is the block still active ? */
726 10803 : for (i = 0; i <= top; i++)
727 10803 : if (blks[i] == getVarScope(mb, l))
728 : break;
729 10803 : if (i > top || blks[i] != getVarScope(mb, l))
730 0 : throw(MAL, "chkFlow", "%s.%s '%s' used outside scope",
731 : getModuleId(sig), getFunctionId(sig), getVarNameIntoBuffer(mb, l, name));
732 : }
733 606402636 : if (blockCntrl(p) || blockStart(p))
734 345170 : setVarInit(mb, l);
735 : }
736 : /* define variables */
737 424488733 : for (k = 0; k < p->retc; k++) {
738 217799026 : l = getArg(p, k);
739 217799026 : if (isVarInit(mb, l) && getVarScope(mb, l) == 0) {
740 : /* first time we see this variable and it is already
741 : * initialized: assume it exists globally */
742 170646265 : setVarScope(mb, l, blks[0]);
743 : }
744 217799026 : setVarInit(mb, l);
745 217799026 : if (getVarScope(mb, l) == 0) {
746 : /* variable has not been defined yet */
747 : /* exceptions are always declared at level 1 */
748 46889415 : if (p->barrier == CATCHsymbol)
749 202 : setVarScope(mb, l, blks[0]);
750 : else
751 46889213 : setVarScope(mb, l, blks[top]);
752 : }
753 217799026 : if (blockCntrl(p) || blockStart(p))
754 322912 : setVarUsed(mb, l);
755 : }
756 206689707 : if (p->barrier && msg == MAL_SUCCEED) {
757 570586 : if (blockStart(p)) {
758 278313 : if (top == MAXDEPTH - 2)
759 0 : throw(MAL, "chkFlow",
760 : "%s.%s too deeply nested MAL program",
761 : getModuleId(sig), getFunctionId(sig));
762 278313 : blkId++;
763 278313 : if (getModuleId(p) && getFunctionId(p)
764 272437 : && strcmp(getModuleId(p), "language") == 0
765 264051 : && strcmp(getFunctionId(p), "dataflow") == 0) {
766 264060 : if (dflow != -1)
767 0 : throw(MAL, "chkFlow",
768 : "%s.%s setLifeSpan nested dataflow blocks not allowed",
769 : getModuleId(sig), getFunctionId(sig));
770 264060 : dflow = blkId;
771 : }
772 278313 : blks[++top] = blkId;
773 : }
774 570586 : if (blockExit(p) && top > 0) {
775 278393 : if (dflow == blks[top]) {
776 : dflow = -1;
777 : } else
778 : /*
779 : * At the end of the block we should reset the status of all variables
780 : * defined within the block. For, the block could have been skipped
781 : * leading to uninitialized variables.
782 : */
783 10805071 : for (l = 0; l < mb->vtop; l++)
784 10790769 : if (getVarScope(mb, l) == blks[top]) {
785 69226 : setVarScope(mb, l, 0);
786 69226 : clrVarInit(mb, l);
787 : }
788 278393 : top--;
789 : }
790 : }
791 : }
792 : return msg;
793 : }
|
