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 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
14 : * (authors) M. Kersten
15 : *
16 : * MAL builder
17 : * The MAL builder library containst the primitives to simplify construction
18 : * of programs by compilers. It has grown out of the MonetDB/SQL code generator.
19 : * The strings being passed as arguments are copied in the process.
20 : *
21 : */
22 : #include "monetdb_config.h"
23 : #include "mal_builder.h"
24 : #include "mal_function.h"
25 : #include "mal_namespace.h"
26 :
27 : InstrPtr
28 17263358 : newAssignmentArgs(MalBlkPtr mb, int args)
29 : {
30 17263358 : InstrPtr q = newInstructionArgs(mb, NULL, NULL, args);
31 17264968 : int k;
32 :
33 17264968 : if (q == NULL)
34 : return NULL;
35 17264967 : k = newTmpVariable(mb, TYPE_any);
36 17264405 : if (k < 0) {
37 : // construct an exception message to be passed to upper layers using ->errors
38 0 : str msg = createException(MAL, "newAssignment",
39 : "Can not allocate variable");
40 0 : addMalException(mb, msg);
41 0 : freeException(msg);
42 0 : freeInstruction(q);
43 0 : return NULL;
44 : }
45 17264405 : getArg(q, 0) = k;
46 17264405 : return q;
47 : }
48 :
49 : InstrPtr
50 3404876 : newAssignment(MalBlkPtr mb)
51 : {
52 3404876 : return newAssignmentArgs(mb, MAXARG);
53 : }
54 :
55 : InstrPtr
56 7079053 : newStmt(MalBlkPtr mb, const char *module, const char *name)
57 : {
58 7079053 : return newStmtArgs(mb, module, name, MAXARG);
59 : }
60 :
61 : InstrPtr
62 9593290 : newStmtArgs(MalBlkPtr mb, const char *module, const char *name, int args)
63 : {
64 9593290 : InstrPtr q;
65 9593290 : const char *mName = putName(module), *nName = putName(name);
66 :
67 9601644 : if (mName == NULL || nName == NULL)
68 : return NULL;
69 :
70 9601644 : q = newInstructionArgs(mb, mName, nName, args);
71 9600850 : if (q == NULL)
72 : return NULL;
73 :
74 9600850 : setDestVar(q, newTmpVariable(mb, TYPE_any));
75 9600449 : if (getDestVar(q) < 0) {
76 0 : str msg = createException(MAL, "newStmtArgs",
77 : "Can not allocate variable");
78 0 : addMalException(mb, msg);
79 0 : freeException(msg);
80 0 : freeInstruction(q);
81 0 : return NULL;
82 : }
83 : return q;
84 : }
85 :
86 : InstrPtr
87 0 : newReturnStmt(MalBlkPtr mb)
88 : {
89 0 : InstrPtr q = newAssignment(mb);
90 :
91 0 : if (q != NULL)
92 0 : q->barrier = RETURNsymbol;
93 0 : return q;
94 : }
95 :
96 : InstrPtr
97 13857660 : newFcnCallArgs(MalBlkPtr mb, const char *mod, const char *fcn, int args)
98 : {
99 13857660 : const char *fcnName, *modName;
100 13857660 : modName = putName(mod);
101 13859690 : fcnName = putName(fcn);
102 13859411 : if (modName == NULL || fcnName == NULL)
103 : return NULL;
104 :
105 13859411 : InstrPtr q = newAssignmentArgs(mb, args);
106 :
107 13859208 : if (q != NULL) {
108 13859208 : setModuleId(q, modName);
109 13859678 : setFunctionId(q, fcnName);
110 : }
111 : return q;
112 : }
113 :
114 : InstrPtr
115 13849383 : newFcnCall(MalBlkPtr mb, const char *mod, const char *fcn)
116 : {
117 13849383 : return newFcnCallArgs(mb, mod, fcn, MAXARG);
118 : }
119 :
120 : InstrPtr
121 0 : newComment(MalBlkPtr mb, const char *val)
122 : {
123 0 : InstrPtr q = newInstruction(mb, NULL, NULL);
124 0 : ValRecord cst;
125 0 : int k;
126 :
127 0 : if (q == NULL)
128 : return NULL;
129 0 : q->token = REMsymbol;
130 0 : q->barrier = 0;
131 0 : if (VALinit(&cst, TYPE_str, val) == NULL) {
132 0 : str msg = createException(MAL, "newComment", "Can not allocate comment");
133 0 : addMalException(mb, msg);
134 0 : freeException(msg);
135 0 : freeInstruction(q);
136 0 : return NULL;
137 : }
138 0 : k = defConstant(mb, TYPE_str, &cst);
139 0 : if (k < 0) {
140 0 : freeInstruction(q);
141 0 : return NULL;
142 : }
143 0 : getArg(q, 0) = k;
144 0 : clrVarConstant(mb, getArg(q, 0));
145 0 : setVarDisabled(mb, getArg(q, 0));
146 0 : return q;
147 : }
148 :
149 : InstrPtr
150 372 : newCatchStmt(MalBlkPtr mb, const char *nme)
151 : {
152 372 : InstrPtr q = newAssignment(mb);
153 372 : int i = findVariable(mb, nme);
154 :
155 372 : if (q == NULL)
156 : return NULL;
157 372 : q->barrier = CATCHsymbol;
158 372 : if (i < 0) {
159 186 : i = newVariable(mb, nme, strlen(nme), TYPE_str);
160 186 : if (i < 0) {
161 0 : str msg = createException(MAL, "newCatchStmt",
162 : "Can not allocate variable");
163 0 : addMalException(mb, msg);
164 0 : freeException(msg);
165 0 : freeInstruction(q);
166 0 : return NULL;
167 : }
168 : }
169 372 : getArg(q, 0) = i;
170 372 : return q;
171 : }
172 :
173 : InstrPtr
174 186 : newRaiseStmt(MalBlkPtr mb, const char *nme)
175 : {
176 186 : InstrPtr q = newAssignment(mb);
177 186 : int i = findVariable(mb, nme);
178 :
179 186 : if (q == NULL)
180 : return NULL;
181 186 : q->barrier = RAISEsymbol;
182 186 : if (i < 0) {
183 186 : i = newVariable(mb, nme, strlen(nme), TYPE_str);
184 186 : if (i < 0) {
185 0 : str msg = createException(MAL, "newRaiseStmt",
186 : "Can not allocate variable");
187 0 : addMalException(mb, msg);
188 0 : freeException(msg);
189 0 : freeInstruction(q);
190 0 : return NULL;
191 : }
192 : }
193 186 : getArg(q, 0) = i;
194 186 : return q;
195 : }
196 :
197 : InstrPtr
198 372 : newExitStmt(MalBlkPtr mb, const char *nme)
199 : {
200 372 : InstrPtr q = newAssignment(mb);
201 372 : int i = findVariable(mb, nme);
202 :
203 372 : if (q == NULL)
204 : return NULL;
205 372 : q->barrier = EXITsymbol;
206 372 : if (i < 0) {
207 0 : i = newVariable(mb, nme, strlen(nme), TYPE_str);
208 0 : if (i < 0) {
209 0 : str msg = createException(MAL, "newExitStmt",
210 : "Can not allocate variable");
211 0 : addMalException(mb, msg);
212 0 : freeException(msg);
213 0 : freeInstruction(q);
214 0 : return NULL;
215 : }
216 : }
217 372 : getArg(q, 0) = i;
218 372 : return q;
219 : }
220 :
221 : InstrPtr
222 570499 : pushEndInstruction(MalBlkPtr mb)
223 : {
224 570499 : if (mb->errors)
225 : return NULL;
226 570465 : InstrPtr q = newInstruction(mb, NULL, NULL);
227 :
228 570849 : if (q == NULL)
229 : return NULL;
230 570849 : q->token = ENDsymbol;
231 570849 : q->barrier = 0;
232 570849 : q->argc = 0;
233 570849 : q->retc = 0;
234 570849 : q->argv[0] = 0;
235 570849 : pushInstruction(mb, q);
236 570792 : if (mb->errors)
237 : return NULL;
238 : return q;
239 : }
240 :
241 : int
242 992607 : getIntConstant(MalBlkPtr mb, int val)
243 : {
244 992607 : int _t;
245 992607 : ValRecord cst = { .vtype = TYPE_int, .val.ival = val };
246 :
247 992607 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
248 992619 : if (_t < 0)
249 425883 : _t = defConstant(mb, TYPE_int, &cst);
250 992619 : return _t;
251 : }
252 :
253 : InstrPtr
254 21141932 : pushInt(MalBlkPtr mb, InstrPtr q, int val)
255 : {
256 21141932 : int _t;
257 :
258 21141932 : if (q == NULL || mb->errors)
259 : return q;
260 21145424 : ValRecord cst = { .vtype = TYPE_int, .val.ival = val };
261 21145424 : _t = defConstant(mb, TYPE_int, &cst);
262 21140558 : if (_t >= 0)
263 21141451 : return pushArgument(mb, q, _t);
264 : return q;
265 : }
266 :
267 : int
268 0 : getBteConstant(MalBlkPtr mb, bte val)
269 : {
270 0 : int _t;
271 0 : ValRecord cst = { .vtype = TYPE_bte, .val.btval = val };
272 :
273 0 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
274 0 : if (_t < 0)
275 0 : _t = defConstant(mb, TYPE_bte, &cst);
276 0 : return _t;
277 : }
278 :
279 : InstrPtr
280 0 : pushBte(MalBlkPtr mb, InstrPtr q, bte val)
281 : {
282 0 : int _t;
283 :
284 0 : if (q == NULL || mb->errors)
285 : return q;
286 0 : ValRecord cst = { .vtype = TYPE_bte, .val.btval = val };
287 0 : _t = defConstant(mb, TYPE_bte, &cst);
288 0 : if (_t >= 0)
289 0 : return pushArgument(mb, q, _t);
290 : return q;
291 : }
292 :
293 : int
294 0 : getOidConstant(MalBlkPtr mb, oid val)
295 : {
296 0 : int _t;
297 :
298 0 : ValRecord cst = { .vtype = TYPE_oid, .val.oval = val };
299 0 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
300 0 : if (_t < 0)
301 0 : _t = defConstant(mb, TYPE_oid, &cst);
302 0 : return _t;
303 : }
304 :
305 : InstrPtr
306 105 : pushOid(MalBlkPtr mb, InstrPtr q, oid val)
307 : {
308 105 : int _t;
309 :
310 105 : if (q == NULL || mb->errors)
311 : return q;
312 105 : ValRecord cst = { .vtype = TYPE_oid, .val.oval = val };
313 105 : _t = defConstant(mb, TYPE_oid, &cst);
314 105 : if (_t >= 0)
315 105 : return pushArgument(mb, q, _t);
316 : return q;
317 : }
318 :
319 : InstrPtr
320 0 : pushVoid(MalBlkPtr mb, InstrPtr q)
321 : {
322 0 : int _t;
323 :
324 0 : if (q == NULL || mb->errors)
325 : return q;
326 0 : ValRecord cst = { .vtype = TYPE_void, .val.oval = oid_nil };
327 0 : _t = defConstant(mb, TYPE_void, &cst);
328 0 : if (_t >= 0)
329 0 : return pushArgument(mb, q, _t);
330 : return q;
331 : }
332 :
333 : int
334 0 : getLngConstant(MalBlkPtr mb, lng val)
335 : {
336 0 : int _t;
337 :
338 0 : ValRecord cst = { .vtype = TYPE_lng, .val.lval = val };
339 0 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
340 0 : if (_t < 0)
341 0 : _t = defConstant(mb, TYPE_lng, &cst);
342 0 : return _t;
343 : }
344 :
345 : InstrPtr
346 14118133 : pushLng(MalBlkPtr mb, InstrPtr q, lng val)
347 : {
348 14118133 : int _t;
349 :
350 14118133 : if (q == NULL || mb->errors)
351 : return q;
352 14118155 : ValRecord cst = { .vtype = TYPE_lng, .val.lval = val };
353 14118155 : _t = defConstant(mb, TYPE_lng, &cst);
354 14117053 : if (_t >= 0)
355 14117072 : return pushArgument(mb, q, _t);
356 : return q;
357 : }
358 :
359 : int
360 0 : getShtConstant(MalBlkPtr mb, sht val)
361 : {
362 0 : int _t;
363 :
364 0 : ValRecord cst = { .vtype = TYPE_sht, .val.shval = val };
365 0 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
366 0 : if (_t < 0)
367 0 : _t = defConstant(mb, TYPE_sht, &cst);
368 0 : return _t;
369 : }
370 :
371 : InstrPtr
372 0 : pushSht(MalBlkPtr mb, InstrPtr q, sht val)
373 : {
374 0 : int _t;
375 :
376 0 : if (q == NULL || mb->errors)
377 : return q;
378 0 : ValRecord cst = { .vtype = TYPE_sht, .val.shval = val };
379 0 : _t = defConstant(mb, TYPE_sht, &cst);
380 0 : if (_t >= 0)
381 0 : return pushArgument(mb, q, _t);
382 : return q;
383 : }
384 :
385 : #ifdef HAVE_HGE
386 : int
387 0 : getHgeConstant(MalBlkPtr mb, hge val)
388 : {
389 0 : int _t;
390 :
391 0 : ValRecord cst = { .vtype = TYPE_hge, .val.hval = val };
392 0 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
393 0 : if (_t < 0)
394 0 : _t = defConstant(mb, TYPE_hge, &cst);
395 0 : return _t;
396 : }
397 :
398 : InstrPtr
399 0 : pushHge(MalBlkPtr mb, InstrPtr q, hge val)
400 : {
401 0 : int _t;
402 :
403 0 : if (q == NULL || mb->errors)
404 : return q;
405 0 : ValRecord cst = { .vtype = TYPE_hge, .val.hval = val };
406 0 : _t = defConstant(mb, TYPE_hge, &cst);
407 0 : if (_t >= 0)
408 0 : return pushArgument(mb, q, _t);
409 : return q;
410 : }
411 : #endif
412 :
413 : int
414 0 : getDblConstant(MalBlkPtr mb, dbl val)
415 : {
416 0 : int _t;
417 :
418 0 : ValRecord cst = { .vtype = TYPE_dbl, .val.dval = val };
419 0 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
420 0 : if (_t < 0)
421 0 : _t = defConstant(mb, TYPE_dbl, &cst);
422 0 : return _t;
423 : }
424 :
425 : InstrPtr
426 0 : pushDbl(MalBlkPtr mb, InstrPtr q, dbl val)
427 : {
428 0 : int _t;
429 :
430 0 : if (q == NULL || mb->errors)
431 : return q;
432 0 : ValRecord cst = { .vtype = TYPE_dbl, .val.dval = val };
433 0 : _t = defConstant(mb, TYPE_dbl, &cst);
434 0 : if (_t >= 0)
435 0 : return pushArgument(mb, q, _t);
436 : return q;
437 : }
438 :
439 : int
440 0 : getFltConstant(MalBlkPtr mb, flt val)
441 : {
442 0 : int _t;
443 :
444 0 : ValRecord cst = { .vtype = TYPE_flt, .val.fval = val };
445 0 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
446 0 : if (_t < 0)
447 0 : _t = defConstant(mb, TYPE_flt, &cst);
448 0 : return _t;
449 : }
450 :
451 : InstrPtr
452 0 : pushFlt(MalBlkPtr mb, InstrPtr q, flt val)
453 : {
454 0 : int _t;
455 :
456 0 : if (q == NULL || mb->errors)
457 : return q;
458 0 : ValRecord cst = { .vtype = TYPE_flt, .val.fval = val };
459 0 : _t = defConstant(mb, TYPE_flt, &cst);
460 0 : if (_t >= 0)
461 0 : return pushArgument(mb, q, _t);
462 : return q;
463 : }
464 :
465 : int
466 4045636 : getStrConstant(MalBlkPtr mb, str val)
467 : {
468 4045636 : int _t;
469 4045636 : ValRecord cst;
470 :
471 4045636 : VALset(&cst, TYPE_str, val);
472 4045717 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
473 4046026 : if (_t < 0) {
474 1092076 : if ((cst.val.sval = GDKmalloc(cst.len)) == NULL)
475 : return -1;
476 1092131 : memcpy(cst.val.sval, val, cst.len); /* includes terminating \0 */
477 1092131 : _t = defConstant(mb, TYPE_str, &cst);
478 : }
479 : return _t;
480 : }
481 :
482 : InstrPtr
483 3705730 : pushStr(MalBlkPtr mb, InstrPtr q, const char *Val)
484 : {
485 3705730 : int _t;
486 3705730 : ValRecord cst;
487 :
488 3705730 : if (q == NULL || mb->errors)
489 : return q;
490 3705877 : if (VALinit(&cst, TYPE_str, Val) == NULL) {
491 0 : str msg = createException(MAL, "pushStr",
492 : "Can not allocate string variable");
493 0 : addMalException(mb, msg);
494 0 : freeException(msg);
495 : } else {
496 3707012 : _t = defConstant(mb, TYPE_str, &cst);
497 3705494 : if (_t >= 0)
498 3705617 : return pushArgument(mb, q, _t);
499 : }
500 : return q;
501 : }
502 :
503 : int
504 0 : getBitConstant(MalBlkPtr mb, bit val)
505 : {
506 0 : int _t;
507 :
508 0 : ValRecord cst = { .vtype = TYPE_bit, .val.btval = val };
509 0 : _t = fndConstant(mb, &cst, MAL_VAR_WINDOW);
510 0 : if (_t < 0)
511 0 : _t = defConstant(mb, TYPE_bit, &cst);
512 0 : return _t;
513 : }
514 :
515 : InstrPtr
516 844328 : pushBit(MalBlkPtr mb, InstrPtr q, bit val)
517 : {
518 844328 : int _t;
519 :
520 844328 : if (q == NULL || mb->errors)
521 : return q;
522 844357 : ValRecord cst = { .vtype = TYPE_bit, .val.btval = val };
523 844357 : _t = defConstant(mb, TYPE_bit, &cst);
524 844218 : if (_t >= 0)
525 844219 : return pushArgument(mb, q, _t);
526 : return q;
527 : }
528 :
529 : InstrPtr
530 287650 : pushNil(MalBlkPtr mb, InstrPtr q, int tpe)
531 : {
532 287650 : int _t;
533 287650 : ValRecord cst = { .len = 0 };
534 :
535 287650 : if (q == NULL || mb->errors)
536 : return q;
537 287649 : if (!isaBatType(tpe)) {
538 287649 : assert(tpe < MAXATOMS); /* in particular, tpe!=TYPE_any */
539 287649 : if (tpe == TYPE_void) {
540 72 : cst.vtype = TYPE_void;
541 72 : cst.val.oval = oid_nil;
542 : } else {
543 287577 : if (VALinit(&cst, tpe, ATOMnilptr(tpe)) == NULL) {
544 0 : str msg = createException(MAL, "pushNil",
545 : "Can not allocate nil variable");
546 0 : addMalException(mb, msg);
547 0 : freeException(msg);
548 : }
549 : }
550 287649 : _t = defConstant(mb, tpe, &cst);
551 : } else {
552 0 : cst.vtype = TYPE_void;
553 0 : cst.bat = true;
554 0 : cst.val.bval = bat_nil;
555 0 : _t = defConstant(mb, newBatType(TYPE_void), &cst);
556 0 : getVarType(mb, _t) = tpe;
557 : }
558 287649 : if (_t >= 0) {
559 287649 : q = pushArgument(mb, q, _t);
560 : }
561 : return q;
562 : }
563 :
564 : InstrPtr
565 450191 : pushNilBat(MalBlkPtr mb, InstrPtr q)
566 : {
567 450191 : int _t;
568 450191 : ValRecord cst = { .bat = true, .vtype = TYPE_void, .val.bval = bat_nil };
569 :
570 450191 : if (q == NULL || mb->errors)
571 : return q;
572 450194 : _t = defConstant(mb, newBatType(TYPE_void), &cst);
573 450198 : getVarType(mb, _t) = newBatType(TYPE_any);
574 450198 : if (_t >= 0) {
575 450198 : q = pushArgument(mb, q, _t);
576 : }
577 : return q;
578 : }
579 :
580 :
581 : InstrPtr
582 0 : pushNilType(MalBlkPtr mb, InstrPtr q, char *tpe)
583 : {
584 0 : int _t, idx;
585 0 : str msg;
586 :
587 0 : if (q == NULL || mb->errors)
588 : return q;
589 0 : idx = getAtomIndex(tpe, strlen(tpe), TYPE_any);
590 0 : if (idx < 0 || idx >= GDKatomcnt || idx >= MAXATOMS) {
591 0 : msg = createException(MAL, "pushNilType",
592 : "Can not allocate type variable");
593 : } else {
594 0 : ValRecord cst = { .vtype = TYPE_void, .val.oval = oid_nil };
595 :
596 0 : msg = convertConstant(idx, &cst);
597 0 : if (msg == MAL_SUCCEED) {
598 0 : _t = defConstant(mb, idx, &cst);
599 0 : if (_t >= 0) {
600 0 : return pushArgument(mb, q, _t);
601 : }
602 : }
603 : }
604 0 : if (msg) {
605 0 : addMalException(mb, msg);
606 0 : freeException(msg);
607 : }
608 : return q;
609 : }
610 :
611 : InstrPtr
612 279440 : pushType(MalBlkPtr mb, InstrPtr q, int tpe)
613 : {
614 279440 : int _t;
615 279440 : str msg;
616 :
617 279440 : if (q == NULL || mb->errors)
618 : return q;
619 279455 : ValRecord cst = { .vtype = TYPE_void, .val.oval = oid_nil };
620 279455 : msg = convertConstant(tpe, &cst);
621 279334 : if (msg != MAL_SUCCEED) {
622 0 : addMalException(mb, msg);
623 0 : freeException(msg);
624 : } else {
625 279334 : _t = defConstant(mb, tpe, &cst);
626 279268 : if (_t >= 0) {
627 279277 : return pushArgument(mb, q, _t);
628 : }
629 : }
630 : return q;
631 : }
632 :
633 : InstrPtr
634 0 : pushZero(MalBlkPtr mb, InstrPtr q, int tpe)
635 : {
636 0 : int _t;
637 0 : str msg;
638 :
639 0 : if (q == NULL || mb->errors)
640 : return q;
641 0 : ValRecord cst = { .vtype = TYPE_int, .val.ival = 0 };
642 0 : msg = convertConstant(tpe, &cst);
643 0 : if (msg != MAL_SUCCEED) {
644 0 : addMalException(mb, msg);
645 0 : freeException(msg);
646 : } else {
647 0 : _t = defConstant(mb, tpe, &cst);
648 0 : if (_t >= 0)
649 0 : return pushArgument(mb, q, _t);
650 : }
651 : return q;
652 : }
653 :
654 : InstrPtr
655 1 : pushValue(MalBlkPtr mb, InstrPtr q, const ValRecord *vr)
656 : {
657 1 : int _t;
658 1 : ValRecord cst;
659 :
660 1 : if (q == NULL || mb->errors)
661 : return q;
662 1 : if (VALcopy(&cst, vr) == NULL) {
663 0 : str msg = createException(MAL, "pushValue", "Can not allocate variable");
664 0 : addMalException(mb, msg);
665 0 : freeException(msg);
666 : } else {
667 1 : int type = cst.bat?newBatType(cst.vtype):cst.vtype;
668 1 : _t = defConstant(mb, type, &cst);
669 1 : if (_t >= 0)
670 1 : return pushArgument(mb, q, _t);
671 : }
672 : return q;
673 : }
|
