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 : #include "monetdb_config.h"
14 : #include "gdk.h"
15 : #include "mal_exception.h"
16 : #include "mal_interpreter.h"
17 :
18 : static str
19 27 : mythrow(enum malexception type, const char *fcn, const char *msg)
20 : {
21 27 : char *errbuf = GDKerrbuf;
22 27 : char *s;
23 :
24 27 : if (errbuf && *errbuf) {
25 27 : if (strncmp(errbuf, "!ERROR: ", 8) == 0)
26 27 : errbuf += 8;
27 27 : if (strchr(errbuf, '!') == errbuf + 5) {
28 0 : s = createException(type, fcn, "%s", errbuf);
29 27 : } else if ((s = strchr(errbuf, ':')) != NULL && s[1] == ' ') {
30 27 : s = createException(type, fcn, "%s", s + 2);
31 : } else {
32 0 : s = createException(type, fcn, "%s", errbuf);
33 : }
34 27 : GDKclrerr();
35 27 : return s;
36 : }
37 0 : return createException(type, fcn, "%s", msg);
38 : }
39 :
40 : static str
41 18223 : CMDbatUNARY(MalStkPtr stk, InstrPtr pci,
42 : BAT *(*batfunc)(BAT *, BAT *), const char *malfunc)
43 : {
44 18223 : bat bid;
45 18223 : BAT *bn, *b, *s = NULL;
46 :
47 18223 : bid = *getArgReference_bat(stk, pci, 1);
48 18223 : if ((b = BATdescriptor(bid)) == NULL)
49 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
50 18238 : if (pci->argc == 3) {
51 266 : bid = *getArgReference_bat(stk, pci, 2);
52 266 : if (!is_bat_nil(bid)) {
53 245 : if ((s = BATdescriptor(bid)) == NULL) {
54 0 : BBPunfix(b->batCacheid);
55 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
56 : }
57 : }
58 : }
59 :
60 18238 : bn = (*batfunc) (b, s);
61 18191 : BBPunfix(b->batCacheid);
62 18235 : BBPreclaim(s);
63 18236 : if (bn == NULL) {
64 0 : return mythrow(MAL, malfunc, OPERATION_FAILED);
65 : }
66 18236 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
67 18236 : BBPkeepref(bn);
68 18236 : return MAL_SUCCEED;
69 : }
70 :
71 : static str
72 0 : CMDbatUNARY1(MalStkPtr stk, InstrPtr pci,
73 : BAT *(*batfunc)(BAT *, BAT *), const char *malfunc)
74 : {
75 0 : bat bid;
76 0 : BAT *bn, *b, *s = NULL;
77 :
78 0 : bid = *getArgReference_bat(stk, pci, 1);
79 0 : if ((b = BATdescriptor(bid)) == NULL)
80 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
81 0 : if (pci->argc == 3) {
82 0 : bid = *getArgReference_bat(stk, pci, 2);
83 0 : if (!is_bat_nil(bid)) {
84 0 : if ((s = BATdescriptor(bid)) == NULL) {
85 0 : BBPunfix(b->batCacheid);
86 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
87 : }
88 : }
89 : }
90 :
91 0 : bn = (*batfunc) (b, s);
92 0 : BBPunfix(b->batCacheid);
93 0 : BBPreclaim(s);
94 0 : if (bn == NULL) {
95 0 : return mythrow(MAL, malfunc, OPERATION_FAILED);
96 : }
97 0 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
98 0 : BBPkeepref(bn);
99 0 : return MAL_SUCCEED;
100 : }
101 :
102 : static str
103 0 : CMDbatISZERO(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
104 : {
105 0 : (void) cntxt;
106 0 : (void) mb;
107 :
108 0 : return CMDbatUNARY(stk, pci, BATcalciszero, "batcalc.iszero");
109 : }
110 :
111 : static str
112 3771 : CMDbatISNIL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
113 : {
114 3771 : (void) cntxt;
115 3771 : (void) mb;
116 :
117 3771 : return CMDbatUNARY(stk, pci, BATcalcisnil, "batcalc.isnil");
118 : }
119 :
120 : static str
121 4636 : CMDbatISNOTNIL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
122 : {
123 4636 : (void) cntxt;
124 4636 : (void) mb;
125 :
126 4636 : return CMDbatUNARY(stk, pci, BATcalcisnotnil, "batcalc.isnotnil");
127 : }
128 :
129 : static str
130 1733 : CMDbatNOT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
131 : {
132 1733 : (void) cntxt;
133 1733 : (void) mb;
134 :
135 1733 : return CMDbatUNARY(stk, pci, BATcalcnot, "batcalc.not");
136 : }
137 :
138 : static str
139 7846 : CMDbatABS(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
140 : {
141 7846 : (void) cntxt;
142 7846 : (void) mb;
143 :
144 7846 : return CMDbatUNARY(stk, pci, BATcalcabsolute, "batcalc.abs");
145 : }
146 :
147 : static str
148 0 : CMDbatINCR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
149 : {
150 0 : (void) cntxt;
151 0 : (void) mb;
152 :
153 0 : return CMDbatUNARY1(stk, pci, BATcalcincr, "batcalc.incr");
154 : }
155 :
156 : static str
157 0 : CMDbatDECR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
158 : {
159 0 : (void) cntxt;
160 0 : (void) mb;
161 :
162 0 : return CMDbatUNARY1(stk, pci, BATcalcdecr, "batcalc.decr");
163 : }
164 :
165 : static str
166 223 : CMDbatNEG(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
167 : {
168 223 : (void) cntxt;
169 223 : (void) mb;
170 :
171 223 : return CMDbatUNARY(stk, pci, BATcalcnegate, "batcalc.neg");
172 : }
173 :
174 : static str
175 14 : CMDbatSIGN(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
176 : {
177 14 : (void) cntxt;
178 14 : (void) mb;
179 :
180 14 : return CMDbatUNARY(stk, pci, BATcalcsign, "batcalc.sign");
181 : }
182 :
183 : static int
184 0 : calctype(int tp1, int tp2)
185 : {
186 0 : int tp1s = ATOMbasetype(tp1);
187 0 : int tp2s = ATOMbasetype(tp2);
188 0 : if (tp1s == TYPE_str && tp2s == TYPE_str)
189 : return TYPE_str;
190 0 : if (tp1s < TYPE_flt && tp2s < TYPE_flt) {
191 0 : if (tp1s > tp2s)
192 : return tp1;
193 0 : if (tp1s < tp2s)
194 : return tp2;
195 0 : return MAX(tp1, tp2);
196 : }
197 0 : if (tp1s == TYPE_dbl || tp2s == TYPE_dbl)
198 : return TYPE_dbl;
199 0 : if (tp1s == TYPE_flt || tp2s == TYPE_flt)
200 : return TYPE_flt;
201 : #ifdef HAVE_HGE
202 0 : if (tp1s == TYPE_hge || tp2s == TYPE_hge)
203 0 : return TYPE_hge;
204 : #endif
205 : return TYPE_lng;
206 : }
207 :
208 : static int
209 0 : calctypeenlarge(int tp1, int tp2)
210 : {
211 0 : tp1 = calctype(tp1, tp2);
212 0 : switch (tp1) {
213 : case TYPE_bte:
214 : return TYPE_sht;
215 0 : case TYPE_sht:
216 0 : return TYPE_int;
217 0 : case TYPE_int:
218 0 : return TYPE_lng;
219 : #ifdef HAVE_HGE
220 0 : case TYPE_lng:
221 0 : return TYPE_hge;
222 : #endif
223 0 : case TYPE_flt:
224 0 : return TYPE_dbl;
225 0 : default:
226 : /* we shouldn't get here */
227 0 : return tp1;
228 : }
229 : }
230 :
231 : static int
232 0 : calcdivtype(int tp1, int tp2)
233 : {
234 : /* if right hand side is floating point, the result is floating
235 : * point, otherwise the result has the type of the left hand
236 : * side */
237 0 : tp1 = ATOMbasetype(tp1);
238 0 : tp2 = ATOMbasetype(tp2);
239 0 : if (tp1 == TYPE_dbl || tp2 == TYPE_dbl)
240 : return TYPE_dbl;
241 0 : if (tp1 == TYPE_flt || tp2 == TYPE_flt)
242 0 : return TYPE_flt;
243 : return tp1;
244 : }
245 :
246 : #if 0
247 : static int
248 : calcdivtypeflt(int tp1, int tp2)
249 : {
250 : (void) tp1;
251 : (void) tp2;
252 : return TYPE_flt;
253 : }
254 :
255 : static int
256 : calcdivtypedbl(int tp1, int tp2)
257 : {
258 : (void) tp1;
259 : (void) tp2;
260 : return TYPE_dbl;
261 : }
262 : #endif
263 :
264 : static int
265 0 : calcmodtype(int tp1, int tp2)
266 : {
267 0 : tp1 = ATOMbasetype(tp1);
268 0 : tp2 = ATOMbasetype(tp2);
269 0 : assert(tp1 > 0 && tp1 < TYPE_str && tp1 != TYPE_ptr);
270 0 : assert(tp2 > 0 && tp2 < TYPE_str && tp2 != TYPE_ptr);
271 0 : if (tp1 == TYPE_dbl || tp2 == TYPE_dbl)
272 : return TYPE_dbl;
273 0 : if (tp1 == TYPE_flt || tp2 == TYPE_flt)
274 : return TYPE_flt;
275 0 : return MIN(tp1, tp2);
276 : }
277 :
278 : /* MAL function has one of the following signatures:
279 : * # without candidate list
280 : * func(b1:bat, b2:bat) :bat
281 : * func(b1:bat, v2:any) :bat
282 : * func(v1:any, b2:bat) :bat
283 : * # with candidate list
284 : * func(b1:bat, b2:bat, s1:bat, s2:bat) :bat
285 : * func(b1:bat, v2:any, s1:bat) :bat
286 : * func(v1:any, b2:bat, s2:bat) :bat
287 : */
288 : static str
289 258514 : CMDbatBINARY2(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci,
290 : BAT *(*batfunc)(BAT *, BAT *, BAT *, BAT *, int),
291 : BAT * (batfunc1)(BAT *, const ValRecord *, BAT *, int),
292 : BAT * (batfunc2)(const ValRecord *, BAT *, BAT *, int),
293 : int(*typefunc)(int, int), const char *malfunc)
294 : {
295 258514 : bat bid;
296 258514 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
297 258514 : int tp1, tp2, tp3;
298 :
299 258514 : tp1 = getArgType(mb, pci, 1); /*stk->stk[getArg(pci, 1)].vtype;*/ /* first argument */
300 258514 : tp2 = getArgType(mb, pci, 2); /*stk->stk[getArg(pci, 2)].vtype;*/ /* second argument */
301 258514 : tp3 = getArgType(mb, pci, 0); /* return argument */
302 258514 : assert(isaBatType(tp3));
303 258514 : tp3 = getBatType(tp3);
304 :
305 258514 : if (isaBatType(tp1)) {
306 257824 : bid = *getArgReference_bat(stk, pci, 1);
307 257824 : b1 = BATdescriptor(bid);
308 258691 : if (b1 == NULL)
309 0 : goto bailout;
310 : }
311 :
312 259381 : if (isaBatType(tp2)) {
313 97307 : bid = *getArgReference_bat(stk, pci, 2);
314 97307 : b2 = BATdescriptor(bid);
315 97322 : if (b2 == NULL)
316 0 : goto bailout;
317 : }
318 :
319 259396 : if (pci->argc > 4) {
320 96522 : assert(pci->argc == 5);
321 96522 : bid = *getArgReference_bat(stk, pci, 4);
322 96522 : if (!is_bat_nil(bid)) {
323 7128 : s2 = BATdescriptor(bid);
324 7130 : if (s2 == NULL)
325 0 : goto bailout;
326 : }
327 : }
328 259398 : if (pci->argc > 3) {
329 259384 : bid = *getArgReference_bat(stk, pci, 3);
330 259384 : if (!is_bat_nil(bid)) {
331 80464 : s1 = BATdescriptor(bid);
332 80494 : if (s1 == NULL)
333 0 : goto bailout;
334 80494 : if (b1 == NULL) {
335 24 : s2 = s1;
336 24 : s1 = NULL;
337 : }
338 : }
339 : }
340 :
341 259428 : if (b1 && b2) {
342 96495 : if (tp3 == TYPE_any)
343 0 : tp3 = (*typefunc) (b1->ttype, b2->ttype);
344 96495 : bn = (*batfunc) (b1, b2, s1, s2, tp3);
345 162933 : } else if (b1) {
346 162131 : if (tp3 == TYPE_any)
347 0 : tp3 = (*typefunc) (b1->ttype, tp2);
348 162131 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1, tp3);
349 802 : } else if (b2) {
350 802 : if (tp3 == TYPE_any)
351 0 : tp3 = (*typefunc) (tp1, b2->ttype);
352 802 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2, tp3);
353 : } else
354 0 : goto bailout; /* cannot happen */
355 258767 : BBPreclaim(b1);
356 259372 : BBPreclaim(b2);
357 259319 : BBPreclaim(s1);
358 259401 : BBPreclaim(s2);
359 259423 : if (bn == NULL)
360 10 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
361 259413 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
362 259413 : BBPkeepref(bn);
363 259413 : return MAL_SUCCEED;
364 :
365 0 : bailout:
366 0 : BBPreclaim(b1);
367 0 : BBPreclaim(b2);
368 : /* cannot happen
369 : BBPreclaim(s1);
370 : */
371 0 : BBPreclaim(s2);
372 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
373 : }
374 :
375 : /* MAL function has one of the signatures for CMDbatBINARY2, or one of
376 : * the following:
377 : * # without candidate list
378 : * func(b1:bat, b2:bat) :bat
379 : * func(b1:bat, v2:any) :bat
380 : * func(v1:any, b2:bat) :bat
381 : * # with candidate list
382 : * func(b1:bat, b2:bat, s1:bat, s2:bat) :bat
383 : * func(b1:bat, v2:any, s1:bat) :bat
384 : * func(v1:any, b2:bat, s2:bat) :bat
385 : */
386 : static str
387 858 : CMDbatBINARY1(MalStkPtr stk, InstrPtr pci,
388 : BAT *(*batfunc)(BAT *, BAT *, BAT *, BAT *),
389 : BAT * (*batfunc1)(BAT *, const ValRecord *, BAT *),
390 : BAT * (*batfunc2)(const ValRecord *, BAT *, BAT *),
391 : const char *malfunc)
392 : {
393 858 : bat bid;
394 858 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
395 :
396 858 : if (stk->stk[getArg(pci, 1)].bat) {
397 861 : bid = *getArgReference_bat(stk, pci, 1);
398 861 : b1 = BATdescriptor(bid);
399 867 : if (b1 == NULL)
400 0 : goto bailout;
401 : }
402 :
403 864 : if (stk->stk[getArg(pci, 2)].bat) {
404 6 : bid = *getArgReference_bat(stk, pci, 2);
405 6 : b2 = BATdescriptor(bid);
406 6 : if (b2 == NULL)
407 0 : goto bailout;
408 : }
409 :
410 864 : if (pci->argc > 4) {
411 0 : assert(pci->argc == 5);
412 0 : bid = *getArgReference_bat(stk, pci, 4);
413 0 : if (!is_bat_nil(bid)) {
414 0 : s2 = BATdescriptor(bid);
415 0 : if (s2 == NULL)
416 0 : goto bailout;
417 : }
418 : }
419 864 : if (pci->argc > 3) {
420 1 : bid = *getArgReference_bat(stk, pci, 3);
421 1 : if (!is_bat_nil(bid)) {
422 0 : s1 = BATdescriptor(bid);
423 0 : if (s1 == NULL)
424 0 : goto bailout;
425 0 : if (b1 == NULL) {
426 0 : s2 = s1;
427 0 : s1 = NULL;
428 : }
429 : }
430 : }
431 :
432 864 : if (b1 && b2)
433 5 : bn = (*batfunc) (b1, b2, s1, s2);
434 859 : else if (b1)
435 858 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1);
436 1 : else if (b2)
437 1 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2);
438 : else
439 0 : goto bailout; /* cannot happen */
440 866 : BBPreclaim(b1);
441 866 : BBPreclaim(b2);
442 865 : BBPreclaim(s1);
443 866 : BBPreclaim(s2);
444 866 : if (bn == NULL)
445 0 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
446 866 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
447 866 : BBPkeepref(bn);
448 866 : return MAL_SUCCEED;
449 :
450 0 : bailout:
451 0 : BBPreclaim(b1);
452 0 : BBPreclaim(b2);
453 : /* cannot happen
454 : BBPreclaim(s1);
455 : */
456 0 : BBPreclaim(s2);
457 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
458 : }
459 :
460 : /* MAL function has one of the signatures for CMDbatBINARY2, or one of
461 : * the following:
462 : * # without candidate list
463 : * func(b1:bat, b2:bat, nil_matches:bit) :bat
464 : * func(b1:bat, v2:any, nil_matches:bit) :bat
465 : * func(v1:any, b2:bat, nil_matches:bit) :bat
466 : * # with candidate list
467 : * func(b1:bat, b2:bat, s1:bat, s2:bat, nil_matches:bit) :bat
468 : * func(b1:bat, v2:any, s1:bat, nil_matches:bit) :bat
469 : * func(v1:any, b2:bat, s2:bat, nil_matches:bit) :bat
470 : */
471 : static str
472 125706 : CMDbatBINARY1a(MalStkPtr stk, InstrPtr pci,
473 : BAT *(*batfunc)(BAT *, BAT *, BAT *, BAT *, bool),
474 : BAT * (*batfunc1)(BAT *, const ValRecord *, BAT *, bool),
475 : BAT * (*batfunc2)(const ValRecord *, BAT *, BAT *, bool),
476 : bool nil_matches, const char *malfunc)
477 : {
478 125706 : bat bid;
479 125706 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
480 :
481 125706 : if (stk->stk[getArg(pci, 1)].bat) {
482 125511 : bid = *getArgReference_bat(stk, pci, 1);
483 125511 : b1 = BATdescriptor(bid);
484 125937 : if (b1 == NULL)
485 0 : goto bailout;
486 : }
487 :
488 126132 : if (stk->stk[getArg(pci, 2)].bat) {
489 90224 : bid = *getArgReference_bat(stk, pci, 2);
490 90224 : b2 = BATdescriptor(bid);
491 90217 : if (b2 == NULL)
492 0 : goto bailout;
493 : }
494 :
495 126125 : if (pci->argc > 5) {
496 6 : assert(pci->argc == 6);
497 6 : nil_matches = *getArgReference_bit(stk, pci, 5);
498 : }
499 126125 : if (pci->argc > 4) {
500 1476 : if (stk->stk[getArg(pci, 4)].bat) {
501 1476 : bid = *getArgReference_bat(stk, pci, 4);
502 1476 : if (!is_bat_nil(bid)) {
503 170 : s2 = BATdescriptor(bid);
504 170 : if (s2 == NULL)
505 0 : goto bailout;
506 : }
507 : } else {
508 0 : assert(pci->argc == 5);
509 0 : nil_matches = *getArgReference_bit(stk, pci, 4);
510 : }
511 : }
512 126125 : if (pci->argc > 3) {
513 37598 : if (stk->stk[getArg(pci, 3)].bat) {
514 24203 : bid = *getArgReference_bat(stk, pci, 3);
515 24203 : if (!is_bat_nil(bid)) {
516 23723 : s1 = BATdescriptor(bid);
517 23745 : if (s1 == NULL)
518 0 : goto bailout;
519 23745 : if (b1 == NULL) {
520 79 : s2 = s1;
521 79 : s1 = NULL;
522 : }
523 : }
524 : } else {
525 13395 : assert(pci->argc == 4);
526 13395 : nil_matches = *getArgReference_bit(stk, pci, 3);
527 : }
528 : }
529 :
530 126147 : if (b1 && b2)
531 89861 : bn = (*batfunc) (b1, b2, s1, s2, nil_matches);
532 36286 : else if (b1)
533 35992 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1, nil_matches);
534 294 : else if (b2)
535 294 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2, nil_matches);
536 : else
537 0 : goto bailout; /* cannot happen */
538 126133 : BBPreclaim(b1);
539 126106 : BBPreclaim(b2);
540 126172 : BBPreclaim(s1);
541 126178 : BBPreclaim(s2);
542 126126 : if (bn == NULL)
543 0 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
544 126126 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
545 126126 : BBPkeepref(bn);
546 126126 : return MAL_SUCCEED;
547 :
548 0 : bailout:
549 0 : BBPreclaim(b1);
550 0 : BBPreclaim(b2);
551 : /* cannot happen
552 : BBPreclaim(s1);
553 : */
554 0 : BBPreclaim(s2);
555 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
556 : }
557 :
558 : /* MAL function has one of the signatures for CMDbatBINARY2
559 : */
560 : static str
561 88239 : CMDbatBINARY0(MalStkPtr stk, InstrPtr pci,
562 : BAT *(*batfunc)(BAT *, BAT *, BAT *, BAT *),
563 : BAT * (*batfunc1)(BAT *, const ValRecord *, BAT *),
564 : BAT * (*batfunc2)(const ValRecord *, BAT *, BAT *),
565 : const char *malfunc)
566 : {
567 88239 : bat bid;
568 88239 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
569 :
570 88239 : if (stk->stk[getArg(pci, 1)].bat) {
571 88124 : bid = *getArgReference_bat(stk, pci, 1);
572 88124 : b1 = BATdescriptor(bid);
573 88553 : if (b1 == NULL)
574 0 : goto bailout;
575 : }
576 :
577 88668 : if (stk->stk[getArg(pci, 2)].bat) {
578 84147 : bid = *getArgReference_bat(stk, pci, 2);
579 84147 : b2 = BATdescriptor(bid);
580 84106 : if (b2 == NULL)
581 0 : goto bailout;
582 : }
583 :
584 88627 : if (pci->argc > 4) {
585 19550 : assert(pci->argc == 5);
586 19550 : bid = *getArgReference_bat(stk, pci, 4);
587 19550 : if (!is_bat_nil(bid)) {
588 4328 : s2 = BATdescriptor(bid);
589 4328 : if (s2 == NULL)
590 0 : goto bailout;
591 : }
592 : }
593 88627 : if (pci->argc > 3) {
594 20173 : bid = *getArgReference_bat(stk, pci, 3);
595 20173 : if (!is_bat_nil(bid)) {
596 15447 : s1 = BATdescriptor(bid);
597 15447 : if (s1 == NULL)
598 0 : goto bailout;
599 15447 : if (b1 == NULL) {
600 1 : s2 = s1;
601 1 : s1 = NULL;
602 : }
603 : }
604 : }
605 :
606 88627 : if (b1 && b2)
607 83967 : bn = (*batfunc) (b1, b2, s1, s2);
608 4660 : else if (b1)
609 4531 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1);
610 129 : else if (b2)
611 129 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2);
612 : else
613 0 : goto bailout; /* cannot happen */
614 88419 : BBPreclaim(b1);
615 88644 : BBPreclaim(b2);
616 88515 : BBPreclaim(s1);
617 88562 : BBPreclaim(s2);
618 88631 : if (bn == NULL)
619 2 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
620 88629 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
621 88629 : BBPkeepref(bn);
622 88629 : return MAL_SUCCEED;
623 :
624 0 : bailout:
625 0 : BBPreclaim(b1);
626 0 : BBPreclaim(b2);
627 : /* cannot happen
628 : BBPreclaim(s1);
629 : */
630 0 : BBPreclaim(s2);
631 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
632 : }
633 :
634 : static str
635 399 : CMDbatMIN(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
636 : {
637 399 : (void) cntxt;
638 399 : (void) mb;
639 :
640 399 : return CMDbatBINARY0(stk, pci, BATcalcmin, BATcalcmincst, BATcalccstmin,
641 : "batcalc.min");
642 : }
643 :
644 : static str
645 127 : CMDbatMIN_no_nil(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
646 : {
647 127 : (void) cntxt;
648 127 : (void) mb;
649 :
650 127 : return CMDbatBINARY0(stk, pci, BATcalcmin_no_nil, BATcalcmincst_no_nil,
651 : BATcalccstmin_no_nil, "batcalc.min_no_nil");
652 : }
653 :
654 : static str
655 14 : CMDbatMAX(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
656 : {
657 14 : (void) cntxt;
658 14 : (void) mb;
659 :
660 14 : return CMDbatBINARY0(stk, pci, BATcalcmax, BATcalcmaxcst, BATcalccstmax,
661 : "batcalc.max");
662 : }
663 :
664 : static str
665 18 : CMDbatMAX_no_nil(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
666 : {
667 18 : (void) cntxt;
668 18 : (void) mb;
669 :
670 18 : return CMDbatBINARY0(stk, pci, BATcalcmax_no_nil, BATcalcmaxcst_no_nil,
671 : BATcalccstmax_no_nil, "batcalc.max_no_nil");
672 : }
673 :
674 : static str
675 127966 : CMDbatADDsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
676 : {
677 127966 : (void) cntxt;
678 :
679 127966 : return CMDbatBINARY2(mb, stk, pci, BATcalcadd, BATcalcaddcst, BATcalccstadd,
680 : calctype, "batcalc.+");
681 : }
682 :
683 : static str
684 31407 : CMDbatADDenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
685 : {
686 31407 : (void) cntxt;
687 :
688 31407 : return CMDbatBINARY2(mb, stk, pci, BATcalcadd, BATcalcaddcst, BATcalccstadd,
689 : calctypeenlarge, "batcalc.add_enlarge");
690 : }
691 :
692 : static str
693 23144 : CMDbatSUBsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
694 : {
695 23144 : (void) cntxt;
696 :
697 23144 : return CMDbatBINARY2(mb, stk, pci, BATcalcsub, BATcalcsubcst, BATcalccstsub,
698 : calctype, "batcalc.-");
699 : }
700 :
701 : static str
702 25609 : CMDbatSUBenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
703 : {
704 25609 : (void) cntxt;
705 :
706 25609 : return CMDbatBINARY2(mb, stk, pci, BATcalcsub, BATcalcsubcst, BATcalccstsub,
707 : calctypeenlarge, "batcalc.sub_enlarge");
708 : }
709 :
710 : static str
711 31204 : CMDbatMULsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
712 : {
713 31204 : (void) cntxt;
714 :
715 31204 : return CMDbatBINARY2(mb, stk, pci, BATcalcmul, BATcalcmulcst, BATcalccstmul,
716 : calctype, "batcalc.*");
717 : }
718 :
719 : static str
720 13999 : CMDbatMULenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
721 : {
722 13999 : (void) cntxt;
723 :
724 13999 : return CMDbatBINARY2(mb, stk, pci, BATcalcmul, BATcalcmulcst, BATcalccstmul,
725 : calctypeenlarge, "batcalc.mul_enlarge");
726 : }
727 :
728 : static str
729 5106 : CMDbatDIVsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
730 : {
731 5106 : (void) cntxt;
732 :
733 5106 : return CMDbatBINARY2(mb, stk, pci, BATcalcdiv, BATcalcdivcst, BATcalccstdiv,
734 : calcdivtype, "batcalc./");
735 : }
736 :
737 : static str
738 668 : CMDbatMODsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
739 : {
740 668 : (void) cntxt;
741 :
742 668 : return CMDbatBINARY2(mb, stk, pci, BATcalcmod, BATcalcmodcst, BATcalccstmod,
743 : calcmodtype, "batcalc.%");
744 : }
745 :
746 : static str
747 17 : CMDbatXOR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
748 : {
749 17 : (void) cntxt;
750 17 : (void) mb;
751 :
752 17 : return CMDbatBINARY0(stk, pci, BATcalcxor, BATcalcxorcst, BATcalccstxor,
753 : "batcalc.xor");
754 : }
755 :
756 : static str
757 5458 : CMDbatOR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
758 : {
759 5458 : (void) cntxt;
760 5458 : (void) mb;
761 :
762 5458 : return CMDbatBINARY0(stk, pci, BATcalcor, BATcalcorcst, BATcalccstor,
763 : "batcalc.or");
764 : }
765 :
766 : static str
767 12188 : CMDbatAND(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
768 : {
769 12188 : (void) cntxt;
770 12188 : (void) mb;
771 :
772 12188 : return CMDbatBINARY0(stk, pci, BATcalcand, BATcalcandcst, BATcalccstand,
773 : "batcalc.and");
774 : }
775 :
776 : static str
777 3 : CMDbatLSHsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
778 : {
779 3 : (void) cntxt;
780 3 : (void) mb;
781 :
782 3 : return CMDbatBINARY1(stk, pci, BATcalclsh, BATcalclshcst, BATcalccstlsh,
783 : "batcalc.<<");
784 : }
785 :
786 : static str
787 860 : CMDbatRSHsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
788 : {
789 860 : (void) cntxt;
790 860 : (void) mb;
791 :
792 860 : return CMDbatBINARY1(stk, pci, BATcalcrsh, BATcalcrshcst, BATcalccstrsh,
793 : "batcalc.>>");
794 : }
795 :
796 : static str
797 15490 : CMDbatLT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
798 : {
799 15490 : (void) cntxt;
800 15490 : (void) mb;
801 :
802 15490 : return CMDbatBINARY0(stk, pci, BATcalclt, BATcalcltcst, BATcalccstlt,
803 : "batcalc.<");
804 : }
805 :
806 : static str
807 10167 : CMDbatLE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
808 : {
809 10167 : (void) cntxt;
810 10167 : (void) mb;
811 :
812 10167 : return CMDbatBINARY0(stk, pci, BATcalcle, BATcalclecst, BATcalccstle,
813 : "batcalc.<=");
814 : }
815 :
816 : static str
817 38580 : CMDbatGT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
818 : {
819 38580 : (void) cntxt;
820 38580 : (void) mb;
821 :
822 38580 : return CMDbatBINARY0(stk, pci, BATcalcgt, BATcalcgtcst, BATcalccstgt,
823 : "batcalc.>");
824 : }
825 :
826 : static str
827 5999 : CMDbatGE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
828 : {
829 5999 : (void) cntxt;
830 5999 : (void) mb;
831 :
832 5999 : return CMDbatBINARY0(stk, pci, BATcalcge, BATcalcgecst, BATcalccstge,
833 : "batcalc.>=");
834 : }
835 :
836 : static str
837 123871 : CMDbatEQ(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
838 : {
839 123871 : (void) cntxt;
840 123871 : (void) mb;
841 :
842 123871 : return CMDbatBINARY1a(stk, pci, BATcalceq, BATcalceqcst, BATcalccsteq,
843 : false, "batcalc.==");
844 : }
845 :
846 : static str
847 2050 : CMDbatNE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
848 : {
849 2050 : (void) cntxt;
850 2050 : (void) mb;
851 :
852 2050 : return CMDbatBINARY1a(stk, pci, BATcalcne, BATcalcnecst, BATcalccstne,
853 : false, "batcalc.!=");
854 : }
855 :
856 : static str
857 0 : CMDbatCMP(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
858 : {
859 0 : (void) cntxt;
860 0 : (void) mb;
861 :
862 0 : return CMDbatBINARY0(stk, pci, BATcalccmp, BATcalccmpcst, BATcalccstcmp,
863 : "batcalc.cmp");
864 : }
865 :
866 : static str
867 25367 : CMDbatBETWEEN(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
868 : {
869 25367 : bat bid;
870 25367 : BAT *bn, *b = NULL, *lo = NULL, *hi = NULL, *s = NULL, *slo = NULL,
871 25367 : *shi = NULL;
872 25367 : int tp1, tp2, tp3, tp;
873 25367 : int bc = 0; /* number of extra BAT arguments */
874 25367 : bool symmetric, linc, hinc, nils_false, anti, has_cand = false;
875 :
876 25367 : (void) cntxt;
877 25367 : (void) mb;
878 :
879 25367 : tp1 = getArgType(mb, pci, 1);
880 25367 : tp2 = getArgType(mb, pci, 2);
881 25367 : tp3 = getArgType(mb, pci, 3);
882 25367 : if (!isaBatType(tp1))
883 0 : goto bailout;
884 25367 : bid = *getArgReference_bat(stk, pci, 1);
885 25367 : b = BATdescriptor(bid);
886 25352 : if (b == NULL)
887 0 : goto bailout;
888 25352 : if (isaBatType(tp2)) {
889 25223 : bid = *getArgReference_bat(stk, pci, 2);
890 25223 : lo = BATdescriptor(bid);
891 25230 : if (lo == NULL)
892 0 : goto bailout;
893 : }
894 25359 : if (isaBatType(tp3)) {
895 25202 : bid = *getArgReference_bat(stk, pci, 3);
896 25202 : hi = BATdescriptor(bid);
897 25211 : if (hi == NULL)
898 0 : goto bailout;
899 : }
900 25368 : tp = getArgType(mb, pci, 4);
901 25368 : if (isaBatType(tp)) {
902 11574 : bid = *getArgReference_bat(stk, pci, 4);
903 11574 : has_cand = true;
904 11574 : if (!is_bat_nil(bid)) {
905 1396 : s = BATdescriptor(bid);
906 1397 : if (s == NULL)
907 0 : goto bailout;
908 : }
909 : bc++;
910 : }
911 25369 : if (has_cand && lo) {
912 11449 : tp = getArgType(mb, pci, 4 + bc);
913 11449 : if (isaBatType(tp)) {
914 11449 : bid = *getArgReference_bat(stk, pci, 4 + bc);
915 11449 : if (!is_bat_nil(bid)) {
916 1826 : slo = BATdescriptor(bid);
917 1828 : if (slo == NULL)
918 0 : goto bailout;
919 : }
920 11451 : bc++;
921 : } else {
922 0 : if (s == NULL) {
923 : /* apparently the extra bat was a NIL conditional
924 : * execution bat */
925 : has_cand = false;
926 : } else
927 0 : goto bailout;
928 : }
929 : }
930 25371 : if (has_cand && hi) {
931 11409 : tp = getArgType(mb, pci, 4 + bc);
932 11409 : if (!isaBatType(tp))
933 0 : goto bailout;
934 11409 : bid = *getArgReference_bat(stk, pci, 4 + bc);
935 11409 : if (!is_bat_nil(bid)) {
936 860 : shi = BATdescriptor(bid);
937 860 : if (shi == NULL)
938 0 : goto bailout;
939 : }
940 11409 : bc++;
941 : }
942 :
943 25371 : symmetric = *getArgReference_bit(stk, pci, bc + 4);
944 25371 : linc = *getArgReference_bit(stk, pci, bc + 5);
945 25371 : hinc = *getArgReference_bit(stk, pci, bc + 6);
946 25371 : nils_false = *getArgReference_bit(stk, pci, bc + 7);
947 25371 : anti = *getArgReference_bit(stk, pci, bc + 8);
948 :
949 25371 : if (b && lo && hi)
950 25100 : bn = BATcalcbetween(b, lo, hi, s, slo, shi,
951 : symmetric, linc, hinc, nils_false, anti);
952 271 : else if (b && lo)
953 68 : bn = BATcalcbetweenbatcst(b, lo, &stk->stk[getArg(pci, 3)], s, slo,
954 : symmetric, linc, hinc, nils_false, anti);
955 203 : else if (b && hi)
956 48 : bn = BATcalcbetweencstbat(b, &stk->stk[getArg(pci, 2)], hi, s, shi,
957 : symmetric, linc, hinc, nils_false, anti);
958 : else
959 155 : bn = BATcalcbetweencstcst(b, &stk->stk[getArg(pci, 2)],
960 155 : &stk->stk[getArg(pci, 3)], s,
961 : symmetric, linc, hinc, nils_false, anti);
962 25269 : BBPunfix(b->batCacheid);
963 25415 : BBPreclaim(lo);
964 25425 : BBPreclaim(hi);
965 25403 : BBPreclaim(s);
966 25411 : BBPreclaim(slo);
967 25424 : BBPreclaim(shi);
968 25423 : if (bn == NULL)
969 0 : return mythrow(MAL, "batcalc.between", OPERATION_FAILED);
970 25423 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
971 25423 : BBPkeepref(bn);
972 25423 : return MAL_SUCCEED;
973 :
974 0 : bailout:
975 0 : BBPreclaim(b);
976 0 : BBPreclaim(lo);
977 0 : BBPreclaim(hi);
978 0 : BBPreclaim(s);
979 0 : BBPreclaim(slo);
980 : /* cannot happen
981 : BBPreclaim(shi);
982 : */
983 0 : throw(MAL, "batcalc.between", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
984 : }
985 :
986 : static str
987 7987 : CMDcalcavg(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
988 : {
989 7987 : dbl avg;
990 7987 : BUN vals;
991 7987 : bat bid;
992 7987 : BAT *b, *s = NULL;
993 7987 : gdk_return ret;
994 7987 : int scale = 0;
995 :
996 7987 : (void) cntxt;
997 7987 : (void) mb;
998 :
999 7987 : bid = *getArgReference_bat(stk, pci, pci->retc + 0);
1000 7987 : if ((b = BATdescriptor(bid)) == NULL)
1001 0 : throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1002 7988 : if ((pci->argc == pci->retc + 2 &&
1003 0 : stk->stk[pci->argv[pci->retc + 1]].bat) ||
1004 7988 : pci->argc == pci->retc + 3) {
1005 0 : bid = *getArgReference_bat(stk, pci, pci->retc + 1);
1006 0 : if (!is_bat_nil(bid) && (s = BATdescriptor(bid)) == NULL) {
1007 0 : BBPunfix(b->batCacheid);
1008 0 : throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1009 : }
1010 : }
1011 7988 : if (pci->argc >= pci->retc + 2 &&
1012 0 : stk->stk[pci->argv[pci->argc - 1]].vtype == TYPE_int) {
1013 0 : scale = *getArgReference_int(stk, pci, pci->argc - 1);
1014 : }
1015 7988 : ret = BATcalcavg(b, s, &avg, &vals, scale);
1016 7987 : BBPunfix(b->batCacheid);
1017 7988 : BBPreclaim(s);
1018 7987 : if (ret != GDK_SUCCEED)
1019 0 : return mythrow(MAL, "aggr.avg", OPERATION_FAILED);
1020 7987 : *getArgReference_dbl(stk, pci, 0) = avg;
1021 7987 : if (pci->retc == 2)
1022 7941 : *getArgReference_lng(stk, pci, 1) = vals;
1023 : return MAL_SUCCEED;
1024 : }
1025 :
1026 : static str
1027 84017 : CMDconvertbat(MalStkPtr stk, InstrPtr pci, int tp)
1028 : {
1029 84017 : bat bid;
1030 84017 : BAT *b, *bn, *s = NULL;
1031 :
1032 84017 : bid = *getArgReference_bat(stk, pci, 1);
1033 84017 : if ((b = BATdescriptor(bid)) == NULL)
1034 0 : throw(MAL, "batcalc.convert", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1035 84174 : if (pci->argc == 3) {
1036 83107 : bid = *getArgReference_bat(stk, pci, 2);
1037 83107 : if (!is_bat_nil(bid) && (s = BATdescriptor(bid)) == NULL) {
1038 0 : BBPunfix(b->batCacheid);
1039 0 : throw(MAL, "batcalc.convert",
1040 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1041 : }
1042 17529 : if (s && ATOMtype(s->ttype) != TYPE_oid) {
1043 0 : BBPunfix(b->batCacheid);
1044 0 : BBPreclaim(s);
1045 0 : throw(MAL, "batcalc.convert", SQLSTATE(42000) ILLEGAL_ARGUMENT);
1046 : }
1047 : }
1048 :
1049 84176 : bn = BATconvert(b, s, tp, 0, 0, 0);
1050 83936 : BBPunfix(b->batCacheid);
1051 84165 : BBPreclaim(s);
1052 84140 : if (bn == NULL) {
1053 15 : char buf[20];
1054 15 : snprintf(buf, sizeof(buf), "batcalc.%s", ATOMname(tp));
1055 15 : return mythrow(MAL, buf, OPERATION_FAILED);
1056 : }
1057 84125 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
1058 84125 : BBPkeepref(bn);
1059 84125 : return MAL_SUCCEED;
1060 : }
1061 :
1062 : static str
1063 298 : CMDconvertsignal_bit(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1064 : {
1065 298 : (void) cntxt;
1066 298 : (void) mb;
1067 :
1068 298 : return CMDconvertbat(stk, pci, TYPE_bit);
1069 : }
1070 :
1071 : static str
1072 574 : CMDconvertsignal_bte(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1073 : {
1074 574 : (void) cntxt;
1075 574 : (void) mb;
1076 :
1077 574 : return CMDconvertbat(stk, pci, TYPE_bte);
1078 : }
1079 :
1080 : static str
1081 9147 : CMDconvertsignal_sht(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1082 : {
1083 9147 : (void) cntxt;
1084 9147 : (void) mb;
1085 :
1086 9147 : return CMDconvertbat(stk, pci, TYPE_sht);
1087 : }
1088 :
1089 : static str
1090 11292 : CMDconvertsignal_int(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1091 : {
1092 11292 : (void) cntxt;
1093 11292 : (void) mb;
1094 :
1095 11292 : return CMDconvertbat(stk, pci, TYPE_int);
1096 : }
1097 :
1098 : static str
1099 59456 : CMDconvertsignal_lng(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1100 : {
1101 59456 : (void) cntxt;
1102 59456 : (void) mb;
1103 :
1104 59456 : return CMDconvertbat(stk, pci, TYPE_lng);
1105 : }
1106 :
1107 : #ifdef HAVE_HGE
1108 :
1109 : static str
1110 171 : CMDconvertsignal_hge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1111 : {
1112 171 : (void) cntxt;
1113 171 : (void) mb;
1114 :
1115 171 : return CMDconvertbat(stk, pci, TYPE_hge);
1116 : }
1117 : #endif
1118 :
1119 : static str
1120 270 : CMDconvertsignal_flt(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1121 : {
1122 270 : (void) cntxt;
1123 270 : (void) mb;
1124 :
1125 270 : return CMDconvertbat(stk, pci, TYPE_flt);
1126 : }
1127 :
1128 : static str
1129 2633 : CMDconvertsignal_dbl(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1130 : {
1131 2633 : (void) cntxt;
1132 2633 : (void) mb;
1133 :
1134 2633 : return CMDconvertbat(stk, pci, TYPE_dbl);
1135 : }
1136 :
1137 : static str
1138 15 : CMDconvertsignal_oid(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1139 : {
1140 15 : (void) cntxt;
1141 15 : (void) mb;
1142 :
1143 15 : return CMDconvertbat(stk, pci, TYPE_oid);
1144 : }
1145 :
1146 : static str
1147 194 : CMDconvertsignal_str(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1148 : {
1149 194 : (void) cntxt;
1150 194 : (void) mb;
1151 :
1152 194 : return CMDconvertbat(stk, pci, TYPE_str);
1153 : }
1154 :
1155 : static str
1156 4660 : CMDifthen(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1157 : {
1158 4660 : BAT *b = NULL, *b1 = NULL, *b2 = NULL, *bn;
1159 4660 : int tp0, tp1, tp2;
1160 4660 : bat *ret;
1161 4660 : BUN cnt = BUN_NONE;
1162 :
1163 4660 : (void) cntxt;
1164 :
1165 4660 : if (pci->argc != 4)
1166 0 : throw(MAL, "batcalc.ifthen", "Operation not supported.");
1167 :
1168 4660 : ret = getArgReference_bat(stk, pci, 0);
1169 4660 : tp0 = stk->stk[getArg(pci, 1)].vtype;
1170 4660 : tp1 = getArgType(mb, pci, 2);
1171 4660 : tp2 = getArgType(mb, pci, 3);
1172 4660 : if (stk->stk[getArg(pci, 1)].bat) {
1173 4663 : b = BATdescriptor(*getArgReference_bat(stk, pci, 1));
1174 4676 : if (b == NULL)
1175 0 : throw(MAL, "batcalc.ifthenelse",
1176 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1177 4676 : cnt = BATcount(b);
1178 : }
1179 4673 : if (isaBatType(tp1)) {
1180 269 : b1 = BATdescriptor(*getArgReference_bat(stk, pci, 2));
1181 269 : if (b1 == NULL) {
1182 0 : BBPreclaim(b);
1183 0 : throw(MAL, "batcalc.ifthenelse",
1184 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1185 : }
1186 269 : if (cnt == BUN_NONE)
1187 0 : cnt = BATcount(b1);
1188 269 : else if (BATcount(b1) != cnt) {
1189 0 : BBPunfix(b->batCacheid);
1190 0 : throw(MAL, "batcalc.ifthenelse", ILLEGAL_ARGUMENT);
1191 : }
1192 : }
1193 4673 : if (isaBatType(tp2)) {
1194 2854 : b2 = BATdescriptor(*getArgReference_bat(stk, pci, 3));
1195 2854 : if (b2 == NULL) {
1196 0 : BBPreclaim(b);
1197 0 : BBPreclaim(b1);
1198 0 : throw(MAL, "batcalc.ifthenelse",
1199 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1200 : }
1201 2854 : if (cnt == BUN_NONE)
1202 4673 : cnt = BATcount(b2);
1203 2854 : else if (BATcount(b2) != cnt) {
1204 0 : BBPreclaim(b);
1205 0 : BBPreclaim(b1);
1206 0 : throw(MAL, "batcalc.ifthenelse", ILLEGAL_ARGUMENT);
1207 : }
1208 : }
1209 4673 : if (b == NULL && b1 == NULL && b2 == NULL) {
1210 : /* at least one BAT required */
1211 0 : throw(MAL, "batcalc.ifthenelse", ILLEGAL_ARGUMENT);
1212 : }
1213 4673 : if (b != NULL) {
1214 4673 : if (b1 != NULL) {
1215 268 : if (b2 != NULL) {
1216 72 : bn = BATcalcifthenelse(b, b1, b2);
1217 : } else {
1218 196 : bn = BATcalcifthenelsecst(b, b1, &stk->stk[getArg(pci, 3)]);
1219 : }
1220 : } else {
1221 4405 : if (b2 != NULL) {
1222 2781 : bn = BATcalcifthencstelse(b, &stk->stk[getArg(pci, 2)], b2);
1223 : } else {
1224 1624 : bn = BATcalcifthencstelsecst(b, &stk->stk[getArg(pci, 2)],
1225 1624 : &stk->stk[getArg(pci, 3)]);
1226 : }
1227 : }
1228 : } else {
1229 0 : bit v;
1230 0 : if (tp0 == TYPE_msk)
1231 0 : v = (bit) *getArgReference_msk(stk, pci, 1);
1232 : else
1233 0 : v = *getArgReference_bit(stk, pci, 1);
1234 0 : if (is_bit_nil(v)) {
1235 0 : if (b1 != NULL)
1236 0 : bn = BATconstant(b1->hseqbase, b1->ttype, ATOMnilptr(b1->ttype),
1237 : BATcount(b1), TRANSIENT);
1238 : else
1239 0 : bn = BATconstant(b2->hseqbase, b2->ttype, ATOMnilptr(b2->ttype),
1240 : BATcount(b2), TRANSIENT);
1241 0 : } else if (v) {
1242 0 : if (b1 != NULL)
1243 0 : bn = COLcopy(b1, b1->ttype, false, TRANSIENT);
1244 : else
1245 0 : bn = BATconstant(b2->hseqbase, b2->ttype,
1246 0 : VALptr(&stk->stk[getArg(pci, 2)]),
1247 : BATcount(b2), TRANSIENT);
1248 : } else {
1249 0 : if (b2 != NULL)
1250 0 : bn = COLcopy(b2, b2->ttype, false, TRANSIENT);
1251 : else
1252 0 : bn = BATconstant(b1->hseqbase, b1->ttype,
1253 0 : VALptr(&stk->stk[getArg(pci, 3)]),
1254 : BATcount(b1), TRANSIENT);
1255 : }
1256 : }
1257 4661 : BBPreclaim(b);
1258 4675 : BBPreclaim(b1);
1259 4676 : BBPreclaim(b2);
1260 4675 : if (bn == NULL) {
1261 0 : return mythrow(MAL, "batcalc.ifthenelse", OPERATION_FAILED);
1262 : }
1263 4675 : *ret = bn->batCacheid;
1264 4675 : BBPkeepref(bn);
1265 4675 : return MAL_SUCCEED;
1266 : }
1267 :
1268 : #include "mel.h"
1269 :
1270 : static str
1271 352 : batcalc_init(void)
1272 : {
1273 352 : int types[16], cur = 0, *tp;
1274 352 : int specials[4];
1275 352 : int *integer, *floats, *extra;
1276 :
1277 352 : types[cur++] = TYPE_bit;
1278 352 : integer = types+cur;
1279 352 : types[cur++] = TYPE_bte;
1280 352 : types[cur++] = TYPE_sht;
1281 352 : types[cur++] = TYPE_int;
1282 352 : types[cur++] = TYPE_lng;
1283 : #ifdef HAVE_HGE
1284 352 : types[cur++] = TYPE_hge;
1285 : #endif
1286 352 : floats = types+cur;
1287 352 : types[cur++] = TYPE_flt;
1288 352 : types[cur++] = TYPE_dbl;
1289 352 : extra = types+cur;
1290 352 : types[cur++] = TYPE_oid;
1291 352 : types[cur++] = TYPE_str;
1292 :
1293 352 : cur = 0;
1294 352 : specials[cur++] = TYPE_bit;
1295 352 : specials[cur++] = TYPE_oid;
1296 352 : specials[cur++] = TYPE_str;
1297 :
1298 352 : mel_func_arg cand = { .type = TYPE_oid, .isbat=1 };
1299 :
1300 352 : int err=0;
1301 : /* for all numeric types, use reverse order */
1302 2816 : for(tp = integer; tp < extra && !err; tp++) {
1303 2464 : mel_func_arg ret = { .type = TYPE_bit, .isbat=1 };
1304 2464 : mel_func_arg arg = { .type = *tp, .isbat=1 };
1305 :
1306 2464 : err += melFunction(false, "batcalc", "iszero", (MALfcn)&CMDbatISZERO, "CMDbatISZERO", false, "Unary check for zero over the tail of the bat", 1, 2, ret, arg);
1307 2464 : err += melFunction(false, "batcalc", "iszero", (MALfcn)&CMDbatISZERO, "CMDbatISZERO", false, "Unary check for zero over the tail of the bat with candidates list", 1, 3, ret, arg, cand);
1308 : }
1309 3168 : for(tp = types; tp < extra && !err; tp++) { /* bit + numeric */
1310 2816 : mel_func_arg ret = { .type = *tp, .isbat =1 };
1311 2816 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1312 :
1313 2816 : err += melFunction(false, "batcalc", "not", (MALfcn)&CMDbatNOT, "CMDbatNOT", false, "Unary bitwise not over the tail of the bat", 1, 2, ret, arg);
1314 2816 : err += melFunction(false, "batcalc", "not", (MALfcn)&CMDbatNOT, "CMDbatNOT", false, "Unary bitwise not over the tail of the bat with candidates list", 1, 3, ret, arg, cand);
1315 : }
1316 2816 : for(tp = integer; tp < extra && !err; tp++) {
1317 2464 : mel_func_arg ret = { .type = TYPE_bte, .isbat =1 };
1318 2464 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1319 :
1320 2464 : err += melFunction(false, "batcalc", "sign", (MALfcn)&CMDbatSIGN, "CMDbatSIGN", false, "Unary sign (-1,0,1) over the tail of the bat", 1, 2, ret, arg);
1321 2464 : err += melFunction(false, "batcalc", "sign", (MALfcn)&CMDbatSIGN, "CMDbatSIGN", false, "Unary sign (-1,0,1) over the tail of the bat with candidates list", 1, 3, ret, arg, cand);
1322 : }
1323 2816 : for(tp = integer; tp < extra && !err; tp++) {
1324 2464 : mel_func_arg ret = { .type = *tp, .isbat =1 };
1325 2464 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1326 :
1327 2464 : err += melFunction(false, "batcalc", "abs", (MALfcn)&CMDbatABS, "CMDbatABS", false, "Unary abs over the tail of the bat", 1, 2, ret, arg);
1328 2464 : err += melFunction(false, "batcalc", "abs", (MALfcn)&CMDbatABS, "CMDbatABS", false, "Unary abs over the tail of the bat with candidates list", 1, 3, ret, arg, cand);
1329 :
1330 2464 : err += melFunction(false, "batcalc", "-", (MALfcn)&CMDbatNEG, "CMDbatNEG", false, "Unary neg over the tail of the bat", 1, 2, ret, arg);
1331 2464 : err += melFunction(false, "batcalc", "-", (MALfcn)&CMDbatNEG, "CMDbatNEG", false, "Unary neg over the tail of the bat with candidates list", 1, 3, ret, arg, cand);
1332 :
1333 2464 : err += melFunction(false, "batcalc", "++", (MALfcn)&CMDbatINCR, "CMDbatINCR", false, "Unary increment over the tail of the bat", 1, 2, ret, arg);
1334 2464 : err += melFunction(false, "batcalc", "++", (MALfcn)&CMDbatINCR, "CMDbatINCR", false, "Unary increment over the tail of the bat with candidates list", 1, 3, ret, arg, cand);
1335 :
1336 2464 : err += melFunction(false, "batcalc", "--", (MALfcn)&CMDbatDECR, "CMDbatDECR", false, "Unary decrement over the tail of the bat", 1, 2, ret, arg);
1337 2464 : err += melFunction(false, "batcalc", "--", (MALfcn)&CMDbatDECR, "CMDbatDECR", false, "Unary decrement over the tail of the bat with candidates list", 1, 3, ret, arg, cand);
1338 : }
1339 : /* possibly add the min/max + _no_nil */
1340 : /* binops on numeric types */
1341 352 : struct {
1342 : char *op;
1343 : char *fname;
1344 : char *fname_el;
1345 : MALfcn fcn;
1346 : MALfcn fcn_el;
1347 : char *comment;
1348 : char *comment_v;
1349 : char *comment_v_;
1350 : char *comment_el;
1351 : char *comment_el_v;
1352 : char *comment_el_v_;
1353 352 : } funcs[3] = {
1354 : {
1355 : .op = "+",
1356 : .fcn = (MALfcn)CMDbatADDsignal,
1357 : .fname = "CMDbatADDsignal",
1358 : .fcn_el = (MALfcn)&CMDbatADDenlarge,
1359 : .fname_el = "CMDbatADDenlarge",
1360 : .comment = "Return B1 + B2 with candidates list, signal error on overflow",
1361 : .comment_v = "Return B + V with candidates list, signal error on overflow",
1362 : .comment_v_ = "Return V + B with candidates list, signal error on overflow",
1363 : .comment_el = "Return B1 + B2 with candidates list, guarantee no overflow by returning larger type",
1364 : .comment_el_v = "Return B + V with candidates list, guarantee no overflow by returning larger type",
1365 : .comment_el_v_ = "Return V + B with candidates list, guarantee no overflow by returning larger type",
1366 : }, {
1367 : .op = "-",
1368 : .fcn = (MALfcn)CMDbatSUBsignal,
1369 : .fname = "CMDbatSUBsignal",
1370 : .fcn_el = (MALfcn)&CMDbatSUBenlarge,
1371 : .fname_el = "CMDbatSUBenlarge",
1372 : .comment = "Return B1 - B2 with candidates list, signal error on overflow",
1373 : .comment_v = "Return B - V with candidates list, signal error on overflow",
1374 : .comment_v_ = "Return V - B with candidates list, signal error on overflow",
1375 : .comment_el = "Return B1 - B2 with candidates list, guarantee no overflow by returning larger type",
1376 : .comment_el_v = "Return B - V with candidates list, guarantee no overflow by returning larger type",
1377 : .comment_el_v_ = "Return V - B with candidates list, guarantee no overflow by returning larger type",
1378 : }, {
1379 : .op = "*",
1380 : .fcn = (MALfcn)CMDbatMULsignal,
1381 : .fname = "CMDbatMULsignal",
1382 : .fcn_el = (MALfcn)&CMDbatMULenlarge,
1383 : .fname_el = "CMDbatMULenlarge",
1384 : .comment = "Return B1 * B2 with candidates list, signal error on overflow",
1385 : .comment_v = "Return B * V with candidates list, signal error on overflow",
1386 : .comment_v_ = "Return V * B with candidates list, signal error on overflow",
1387 : .comment_el = "Return B1 * B2 with candidates list, guarantee no overflow by returning larger type",
1388 : .comment_el_v = "Return B * V with candidates list, guarantee no overflow by returning larger type",
1389 : .comment_el_v_ = "Return V * B with candidates list, guarantee no overflow by returning larger type",
1390 : }
1391 : };
1392 1408 : for (int f=0; f<3; f++) {
1393 : int *tp1, *tp2, *rt;
1394 8448 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1395 59136 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1396 413952 : for(rt = extra-1; rt >= integer && !err; rt--) {
1397 362208 : if (f!=3 && (*rt < *tp1 || *rt < *tp2))
1398 214368 : continue;
1399 147840 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1400 147840 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1401 147840 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1402 147840 : mel_func_arg varg1 = { .type = *tp1 };
1403 147840 : mel_func_arg varg2 = { .type = *tp2 };
1404 :
1405 147840 : if (*rt == *tp1 || *rt == *tp2 || f==3) {
1406 51744 : err += melFunction(false, "batcalc", funcs[f].op, funcs[f].fcn, funcs[f].fname, false, funcs[f].comment, 1, 5, ret, arg1, arg2, cand, cand);
1407 51744 : err += melFunction(false, "batcalc", funcs[f].op, funcs[f].fcn, funcs[f].fname, false, funcs[f].comment_v, 1, 4, ret, arg1, varg2, cand);
1408 51744 : err += melFunction(false, "batcalc", funcs[f].op, funcs[f].fcn, funcs[f].fname, false, funcs[f].comment_v_, 1, 4, ret, varg1, arg2, cand);
1409 : } else {
1410 96096 : err += melFunction(false, "batcalc", funcs[f].op, funcs[f].fcn_el, funcs[f].fname_el, false, funcs[f].comment_el, 1, 5, ret, arg1, arg2, cand, cand);
1411 96096 : err += melFunction(false, "batcalc", funcs[f].op, funcs[f].fcn_el, funcs[f].fname_el, false, funcs[f].comment_el_v, 1, 4, ret, arg1, varg2, cand);
1412 96096 : err += melFunction(false, "batcalc", funcs[f].op, funcs[f].fcn_el, funcs[f].fname_el, false, funcs[f].comment_el_v_, 1, 4, ret, varg1, arg2, cand);
1413 : }
1414 : }
1415 : }
1416 : }
1417 : }
1418 : { /* multiplication between integers and floating-points, returning integers */
1419 : int *tp1, *tp2, *tp3;
1420 2112 : for(tp1 = integer; tp1 < floats && !err; tp1++) {
1421 5280 : for(tp2 = floats; tp2 < extra && !err; tp2++) {
1422 21120 : for(tp3 = integer; tp3 < floats && !err; tp3++) {
1423 17600 : int in1 = *tp3, in2 = *tp2;
1424 :
1425 52800 : for (int i = 0 ; i < 2 ; i++) {
1426 35200 : mel_func_arg ret = { .type = *tp1, .isbat =1 };
1427 35200 : mel_func_arg arg1 = { .type = in1, .isbat =1 };
1428 35200 : mel_func_arg arg2 = { .type = in2, .isbat =1 };
1429 35200 : mel_func_arg varg1 = { .type = in1 };
1430 35200 : mel_func_arg varg2 = { .type = in2 };
1431 :
1432 35200 : err += melFunction(false, "batcalc", funcs[2].op, funcs[2].fcn, funcs[2].fname, false, funcs[2].comment, 1, 5, ret, arg1, arg2, cand, cand);
1433 35200 : err += melFunction(false, "batcalc", funcs[2].op, funcs[2].fcn, funcs[2].fname, false, funcs[2].comment_v, 1, 4, ret, arg1, varg2, cand);
1434 35200 : err += melFunction(false, "batcalc", funcs[2].op, funcs[2].fcn, funcs[2].fname, false, funcs[2].comment_v_, 1, 4, ret, varg1, arg2, cand);
1435 :
1436 : /* swap variables */
1437 35200 : in1 ^= in2;
1438 35200 : in2 ^= in1;
1439 35200 : in1 ^= in2;
1440 : }
1441 : }
1442 : }
1443 : }
1444 : }
1445 352 : struct {
1446 : char *op;
1447 : char *fname;
1448 : char *fname_el;
1449 : MALfcn fcn;
1450 : MALfcn fcn_el;
1451 : char *comment;
1452 : char *comment_v;
1453 : char *comment_v_;
1454 : char *comment_el;
1455 : char *comment_el_v;
1456 : char *comment_el_v_;
1457 352 : } div = {
1458 : .op = "/",
1459 : .fcn = (MALfcn)CMDbatDIVsignal,
1460 : .fname = "CMDbatDIVsignal",
1461 : .comment = "Return B1 / B2 with candidates list, signal error on overflow",
1462 : .comment_v = "Return B / V with candidates list, signal error on overflow",
1463 : .comment_v_ = "Return V / B with candidates list, signal error on overflow",
1464 : };
1465 352 : int *tp1, *tp2, *rt;
1466 2816 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1467 19712 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1468 86240 : for(rt = extra-1; rt >= tp1 && !err; rt--) {
1469 68992 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1470 68992 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1471 68992 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1472 68992 : mel_func_arg varg1 = { .type = *tp1 };
1473 68992 : mel_func_arg varg2 = { .type = *tp2 };
1474 :
1475 68992 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment, 1, 5, ret, arg1, arg2, cand, cand);
1476 68992 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment_v, 1, 4, ret, arg1, varg2, cand);
1477 68992 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment_v_, 1, 4, ret, varg1, arg2, cand);
1478 : }
1479 : }
1480 : }
1481 : /* division between integers and floating-points, returning integers */
1482 1056 : for(tp1 = floats; tp1 < extra && !err; tp1++) {
1483 4224 : for(tp2 = integer; tp2 < floats && !err; tp2++) {
1484 21120 : for(rt = integer; rt < floats && !err; rt++) {
1485 17600 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1486 17600 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1487 17600 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1488 17600 : mel_func_arg varg1 = { .type = *tp1 };
1489 17600 : mel_func_arg varg2 = { .type = *tp2 };
1490 :
1491 17600 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment, 1, 5, ret, arg1, arg2, cand, cand);
1492 17600 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment_v, 1, 4, ret, arg1, varg2, cand);
1493 17600 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment_v_, 1, 4, ret, varg1, arg2, cand);
1494 : }
1495 : }
1496 : }
1497 : struct {
1498 : char *op;
1499 : char *fname;
1500 : MALfcn fcn;
1501 : char *comment;
1502 : char *comment_v;
1503 : char *comment_v_;
1504 : } mods = {
1505 : .op = "%",
1506 : .fcn = (MALfcn)CMDbatMODsignal,
1507 : .fname = "CMDbatMODsignal",
1508 : .comment = "Return B1 % B2 with candidates list, signal error on overflow",
1509 : .comment_v = "Return B % V with candidates list, signal error on overflow",
1510 : .comment_v_ = "Return V % B with candidates list, signal error on overflow",
1511 : };
1512 2816 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1513 19712 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1514 137984 : for(rt = extra-1; rt >= integer && !err; rt--) {
1515 120736 : if (rt < tp1 && rt < tp2)
1516 86592 : continue;
1517 88704 : if (*rt == TYPE_dbl) {
1518 17248 : if (*tp1 != TYPE_dbl || *tp2 != TYPE_dbl)
1519 16896 : continue;
1520 71456 : } else if (*rt == TYPE_flt) {
1521 16896 : if (*tp1 != TYPE_flt || *tp2 != TYPE_flt)
1522 16544 : continue;
1523 : } else {
1524 54560 : if (*tp1 == TYPE_flt || *tp2 == TYPE_flt || *tp1 == TYPE_dbl || *tp2 == TYPE_dbl)
1525 21120 : continue;
1526 : }
1527 34144 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1528 34144 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1529 34144 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1530 34144 : mel_func_arg varg1 = { .type = *tp1 };
1531 34144 : mel_func_arg varg2 = { .type = *tp2 };
1532 :
1533 34144 : err += melFunction(false, "batcalc", mods.op, mods.fcn, mods.fname, false, mods.comment, 1, 5, ret, arg1, arg2, cand, cand);
1534 34144 : err += melFunction(false, "batcalc", mods.op, mods.fcn, mods.fname, false, mods.comment_v, 1, 4, ret, arg1, varg2, cand);
1535 34144 : err += melFunction(false, "batcalc", mods.op, mods.fcn, mods.fname, false, mods.comment_v_, 1, 4, ret, varg1, arg2, cand);
1536 : }
1537 : }
1538 : }
1539 352 : struct {
1540 : char *op;
1541 : char *fname;
1542 : MALfcn fcn;
1543 : char *comment;
1544 : char *comment_v;
1545 : char *comment_v_;
1546 352 : } logops[3] = {
1547 : {
1548 : .op = "and",
1549 : .fcn = (MALfcn)CMDbatAND,
1550 : .fname = "CMDbatAND",
1551 : .comment = "Return B1 and B2",
1552 : .comment_v = "Return B and V",
1553 : .comment_v_ = "Return V and B",
1554 : }, {
1555 : .op = "or",
1556 : .fcn = (MALfcn)CMDbatOR,
1557 : .fname = "CMDbatOR",
1558 : .comment = "Return B1 or B2",
1559 : .comment_v = "Return B or V",
1560 : .comment_v_ = "Return V or B",
1561 : }, {
1562 : .op = "xor",
1563 : .fcn = (MALfcn)CMDbatXOR,
1564 : .fname = "CMDbatXOR",
1565 : .comment = "Return B1 xor B2",
1566 : .comment_v = "Return B xor V",
1567 : .comment_v_ = "Return V xor B",
1568 : }
1569 : };
1570 1408 : for (int f=0; f<3; f++) {
1571 9504 : for(tp = types+0; tp < extra && !err; tp++) {
1572 8448 : mel_func_arg ret = { .type = *tp, .isbat =1 };
1573 8448 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1574 8448 : mel_func_arg varg = { .type = *tp };
1575 :
1576 8448 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment, 1, 3, ret, arg, arg);
1577 8448 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment, 1, 5, ret, arg, arg, cand, cand);
1578 8448 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment_v, 1, 3, ret, arg, varg);
1579 8448 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment_v, 1, 4, ret, arg, varg, cand);
1580 8448 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment_v_, 1, 3, ret, varg, arg);
1581 8448 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment_v_, 1, 4, ret, varg, arg, cand);
1582 : }
1583 : }
1584 352 : struct {
1585 : char *op;
1586 : char *fname;
1587 : MALfcn fcn;
1588 : char *comment;
1589 : char *comment_v;
1590 : char *comment_v_;
1591 352 : } shifts[2] = {
1592 : {
1593 : .op = "<<",
1594 : .fcn = (MALfcn)CMDbatLSHsignal,
1595 : .fname = "CMDbatLSHsignal",
1596 : .comment = "Return B1 << B2, raise error on out of range second operand",
1597 : .comment_v = "Return B << V, raise error on out of range second operand",
1598 : .comment_v_ = "Return B << V, raise error on out of range second operand",
1599 : }, {
1600 : .op = ">>",
1601 : .fcn = (MALfcn)CMDbatRSHsignal,
1602 : .fname = "CMDbatRSHsignal",
1603 : .comment = "Return B1 >> B2, raise error on out of range second operand",
1604 : .comment_v = "Return B >> V, raise error on out of range second operand",
1605 : .comment_v_ = "Return B >> V, raise error on out of range second operand",
1606 : }
1607 : };
1608 1056 : for (int f=0; f<2; f++) {
1609 : int *tp1, *tp2;
1610 4224 : for(tp1 = integer; tp1 < floats && !err; tp1++) {
1611 21120 : for(tp2 = integer; tp2 < floats && !err; tp2++) {
1612 17600 : mel_func_arg ret = { .type = *tp1, .isbat =1 };
1613 17600 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1614 17600 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1615 17600 : mel_func_arg varg1 = { .type = *tp1 };
1616 17600 : mel_func_arg varg2 = { .type = *tp2 };
1617 :
1618 17600 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment, 1, 3, ret, arg1, arg2);
1619 17600 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment, 1, 5, ret, arg1, arg2, cand, cand);
1620 17600 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment_v, 1, 3, ret, arg1, varg2);
1621 17600 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment_v, 1, 4, ret, arg1, varg2, cand);
1622 17600 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment_v_, 1, 3, ret, varg1, arg2);
1623 17600 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment_v_, 1, 4, ret, varg1, arg2, cand);
1624 : }
1625 : }
1626 : }
1627 :
1628 352 : struct {
1629 : char *op;
1630 : char *fname;
1631 : MALfcn fcn;
1632 : char *comment;
1633 : char *comment_v;
1634 : char *comment_v_;
1635 352 : } cmps[6] = {
1636 : {
1637 : .op = "<",
1638 : .fcn = (MALfcn)CMDbatLT,
1639 : .fname = "CMDbatLT",
1640 : .comment = "Return B1 < B2",
1641 : .comment_v = "Return B < V",
1642 : .comment_v_ = "Return B < V",
1643 : }, {
1644 : .op = "<=",
1645 : .fcn = (MALfcn)CMDbatLE,
1646 : .fname = "CMDbatLE",
1647 : .comment = "Return B1 <= B2",
1648 : .comment_v = "Return B <= V",
1649 : .comment_v_ = "Return B <= V",
1650 : }, {
1651 : .op = ">",
1652 : .fcn = (MALfcn)CMDbatGT,
1653 : .fname = "CMDbatGT",
1654 : .comment = "Return B1 > B2",
1655 : .comment_v = "Return B > V",
1656 : .comment_v_ = "Return B > V",
1657 : }, {
1658 : .op = ">=",
1659 : .fcn = (MALfcn)CMDbatGE,
1660 : .fname = "CMDbatGE",
1661 : .comment = "Return B1 >= B2",
1662 : .comment_v = "Return B >= V",
1663 : .comment_v_ = "Return B >= V",
1664 : }, {
1665 : .op = "==",
1666 : .fcn = (MALfcn)CMDbatEQ,
1667 : .fname = "CMDbatEQ",
1668 : .comment = "Return B1 == B2",
1669 : .comment_v = "Return B == V",
1670 : .comment_v_ = "Return B == V",
1671 : }, {
1672 : .op = "!=",
1673 : .fcn = (MALfcn)CMDbatNE,
1674 : .fname = "CMDbatNE",
1675 : .comment = "Return B1 != B2",
1676 : .comment_v = "Return B != V",
1677 : .comment_v_ = "Return B != V",
1678 : }
1679 : };
1680 352 : int newtypes[6] = { ATOMindex("json"), ATOMindex("inet"), ATOMindex("uuid"), TYPE_date, TYPE_daytime, TYPE_timestamp };
1681 2464 : for (int f=0; f<6; f++) {
1682 2112 : mel_func_arg ret = { .type = TYPE_bit, .isbat =1 };
1683 2112 : mel_func_arg arg = { .type = TYPE_any, .isbat =1, .nr=1 };
1684 2112 : mel_func_arg varg = { .type = TYPE_any, .nr=1 };
1685 :
1686 2112 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 3, ret, arg, arg);
1687 2112 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 5, ret, arg, arg, cand, cand);
1688 2112 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 3, ret, arg, varg);
1689 2112 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 4, ret, arg, varg, cand);
1690 2112 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 3, ret, varg, arg);
1691 2112 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 4, ret, varg, arg, cand);
1692 :
1693 2112 : if (strcmp(cmps[f].op,"==")==0 || strcmp(cmps[f].op,"!=")==0) {
1694 704 : mel_func_arg nil_matches = { .type = TYPE_bit };
1695 :
1696 704 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 4, ret, arg, arg, nil_matches);
1697 704 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 6, ret, arg, arg, cand, cand, nil_matches);
1698 704 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 4, ret, arg, varg, nil_matches);
1699 704 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 5, ret, arg, varg, cand, nil_matches);
1700 704 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 4, ret, varg, arg, nil_matches);
1701 704 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 5, ret, varg, arg, cand, nil_matches);
1702 : }
1703 :
1704 : /* uuid, json, inet and mtime (date, daytime, timestamp) */
1705 14784 : for (int nt = 0; nt < 6; nt++) {
1706 12672 : mel_func_arg ret = { .type = TYPE_bit, .isbat =1 };
1707 12672 : mel_func_arg arg = { .type = newtypes[nt], .isbat =1, .nr=1 };
1708 12672 : mel_func_arg varg = { .type = newtypes[nt], .nr=1 };
1709 :
1710 12672 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 3, ret, arg, arg);
1711 12672 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 5, ret, arg, arg, cand, cand);
1712 12672 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 3, ret, arg, varg);
1713 12672 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 4, ret, arg, varg, cand);
1714 12672 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 3, ret, varg, arg);
1715 12672 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 4, ret, varg, arg, cand);
1716 :
1717 12672 : if (strcmp(cmps[f].op,"==")==0 || strcmp(cmps[f].op,"!=")==0) {
1718 4224 : mel_func_arg nil_matches = { .type = TYPE_bit };
1719 :
1720 4224 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 4, ret, arg, arg, nil_matches);
1721 4224 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 6, ret, arg, arg, cand, cand, nil_matches);
1722 4224 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 4, ret, arg, varg, nil_matches);
1723 4224 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 5, ret, arg, varg, cand, nil_matches);
1724 4224 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 4, ret, varg, arg, nil_matches);
1725 4224 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 5, ret, varg, arg, cand, nil_matches);
1726 : }
1727 : }
1728 :
1729 : int *tp1, *tp2;
1730 12672 : for(tp1 = integer; tp1 < floats && !err; tp1++) {
1731 63360 : for(tp2 = integer; tp2 < floats && !err; tp2++) {
1732 52800 : if (*tp1 == *tp2)
1733 10560 : continue;
1734 42240 : mel_func_arg ret = { .type = TYPE_bit, .isbat =1 };
1735 42240 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1736 42240 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1737 42240 : mel_func_arg varg1 = { .type = *tp1 };
1738 42240 : mel_func_arg varg2 = { .type = *tp2 };
1739 :
1740 42240 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 3, ret, arg1, arg2);
1741 42240 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 5, ret, arg1, arg2, cand, cand);
1742 42240 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 3, ret, arg1, varg2);
1743 42240 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 4, ret, arg1, varg2, cand);
1744 42240 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 3, ret, varg1, arg2);
1745 42240 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 4, ret, varg1, arg2, cand);
1746 :
1747 42240 : if (strcmp(cmps[f].op,"==")==0 || strcmp(cmps[f].op,"!=")==0) {
1748 14080 : mel_func_arg nil_matches = { .type = TYPE_bit };
1749 :
1750 14080 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 4, ret, arg1, arg2, nil_matches);
1751 14080 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 6, ret, arg1, arg2, cand, cand, nil_matches);
1752 14080 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 4, ret, arg1, varg2, nil_matches);
1753 14080 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 5, ret, arg1, varg2, cand, nil_matches);
1754 14080 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 4, ret, varg1, arg2, nil_matches);
1755 14080 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 5, ret, varg1, arg2, cand, nil_matches);
1756 : }
1757 : }
1758 : }
1759 : }
1760 :
1761 : struct {
1762 : char *op;
1763 : char *fname;
1764 : MALfcn fcn;
1765 : char *comment;
1766 : char *comment_v;
1767 : char *comment_v_;
1768 : } cmp = {
1769 : .op = "cmp",
1770 : .fcn = (MALfcn)CMDbatCMP,
1771 : .fname = "CMDbatCMP",
1772 : .comment = "Return -1/0/1 if B1 </==/> B2",
1773 : .comment_v = "Return -1/0/1 if B </==/> V",
1774 : .comment_v_ = "Return -1/0/1 if V </==/> B",
1775 : };
1776 1408 : for(int i = 0; i < 3 && !err; i++) {
1777 1056 : int tp = specials[i];
1778 1056 : mel_func_arg ret = { .type = TYPE_bte, .isbat =1 };
1779 1056 : mel_func_arg arg = { .type = tp, .isbat =1 };
1780 1056 : mel_func_arg varg = { .type = tp };
1781 :
1782 1056 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 3, ret, arg, arg);
1783 1056 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 5, ret, arg, arg, cand, cand);
1784 1056 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 3, ret, arg, varg);
1785 1056 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 4, ret, arg, varg, cand);
1786 1056 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 3, ret, varg, arg);
1787 1056 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 4, ret, varg, arg, cand);
1788 : }
1789 2816 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1790 19712 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1791 17248 : mel_func_arg ret = { .type = TYPE_bte, .isbat =1 };
1792 17248 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1793 17248 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1794 17248 : mel_func_arg varg1 = { .type = *tp1 };
1795 17248 : mel_func_arg varg2 = { .type = *tp2 };
1796 :
1797 17248 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 3, ret, arg1, arg2);
1798 17248 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 5, ret, arg1, arg2, cand, cand);
1799 17248 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 3, ret, arg1, varg2);
1800 17248 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 4, ret, arg1, varg2, cand);
1801 17248 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 3, ret, varg1, arg2);
1802 17248 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 4, ret, varg1, arg2, cand);
1803 : }
1804 : }
1805 2816 : for(tp = integer; tp < extra && !err; tp++) {
1806 2464 : mel_func_arg ret = { .type = TYPE_dbl };
1807 2464 : mel_func_arg nr = { .type = TYPE_lng };
1808 2464 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1809 2464 : mel_func_arg scale = { .type = TYPE_int };
1810 :
1811 2464 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average of non-nil values of B", 1, 2, ret, arg);
1812 2464 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average of non-nil values of B with candidates list", 1, 3, ret, arg, cand);
1813 2464 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average and number of non-nil values of B", 2, 3, ret, nr, arg);
1814 2464 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average and number of non-nil values of B with candidates list", 2, 4, ret, nr, arg, cand);
1815 2464 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average of non-nil values of B", 1, 3, ret, arg, scale);
1816 2464 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average of non-nil values of B with candidates list", 1, 4, ret, arg, cand, scale);
1817 2464 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average and number of non-nil values of B", 2, 4, ret, nr, arg, scale);
1818 2464 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average and number of non-nil values of B with candidates list", 2, 5, ret, nr, arg, cand, scale);
1819 : }
1820 :
1821 352 : struct {
1822 : int type;
1823 : char *name;
1824 : char *fname;
1825 : MALfcn fcn;
1826 352 : } typeops[10] = {
1827 : {
1828 : .type = TYPE_bit,
1829 : .name = "bit",
1830 : .fname = "CMDconvertsignal_bit",
1831 : .fcn = (MALfcn)CMDconvertsignal_bit,
1832 : }, {
1833 : .type = TYPE_bte,
1834 : .name = "bte",
1835 : .fname = "CMDconvertsignal_bte",
1836 : .fcn = (MALfcn)CMDconvertsignal_bte,
1837 : }, {
1838 : .type = TYPE_sht,
1839 : .name = "sht",
1840 : .fname = "CMDconvertsignal_sht",
1841 : .fcn = (MALfcn)CMDconvertsignal_sht,
1842 : }, {
1843 : .type = TYPE_int,
1844 : .name = "int",
1845 : .fname = "CMDconvertsignal_int",
1846 : .fcn = (MALfcn)CMDconvertsignal_int,
1847 : }, {
1848 : .type = TYPE_lng,
1849 : .name = "lng",
1850 : .fname = "CMDconvertsignal_lng",
1851 : .fcn = (MALfcn)CMDconvertsignal_lng,
1852 : #ifdef HAVE_HGE
1853 : }, {
1854 : .type = TYPE_hge,
1855 : .name = "hge",
1856 : .fname = "CMDconvertsignal_hge",
1857 : .fcn = (MALfcn)CMDconvertsignal_hge,
1858 : #endif
1859 : }, {
1860 : .type = TYPE_flt,
1861 : .name = "flt",
1862 : .fname = "CMDconvertsignal_flt",
1863 : .fcn = (MALfcn)CMDconvertsignal_flt,
1864 : }, {
1865 : .type = TYPE_dbl,
1866 : .name = "dbl",
1867 : .fname = "CMDconvertsignal_dbl",
1868 : .fcn = (MALfcn)CMDconvertsignal_dbl,
1869 : }, {
1870 : .type = TYPE_oid,
1871 : .name = "oid",
1872 : .fname = "CMDconvertsignal_oid",
1873 : .fcn = (MALfcn)CMDconvertsignal_oid,
1874 : }, {
1875 : .type = TYPE_str,
1876 : .name = "str",
1877 : .fname = "CMDconvertsignal_str",
1878 : .fcn = (MALfcn)CMDconvertsignal_str,
1879 : }
1880 : };
1881 : #ifdef HAVE_HGE
1882 352 : int typeopslen = 10;
1883 : #else
1884 : int typeopslen = 9;
1885 : #endif
1886 3872 : for(int t = 0; t<typeopslen; t++) {
1887 : /* from any 2 string */
1888 3520 : mel_func_arg ret = { .type = typeops[t].type, .isbat =1 };
1889 3520 : if (strcmp(typeops[t].name, "str")==0) {
1890 352 : mel_func_arg arg = { .type = TYPE_any, .isbat =1 };
1891 :
1892 352 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 2, ret, arg);
1893 352 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 3, ret, arg, cand);
1894 : } else {
1895 34848 : for(int p = 0; p<typeopslen; p++) {
1896 31680 : mel_func_arg arg = { .type = typeops[p].type, .isbat =1 };
1897 :
1898 31680 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 2, ret, arg);
1899 31680 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 3, ret, arg, cand);
1900 : }
1901 : }
1902 : }
1903 352 : return MAL_SUCCEED;
1904 : }
1905 :
1906 : static mel_func batcalc_init_funcs[] = {
1907 : /* batcalc */
1908 : pattern("batcalc", "isnil", CMDbatISNIL, false, "Unary check for nil over the tail of the bat", args(1,2, batarg("",bit),batargany("b",0))),
1909 : pattern("batcalc", "isnil", CMDbatISNIL, false, "Unary check for nil over the tail of the bat with candidates list", args(1,3, batarg("",bit),batargany("b",0),batarg("s",oid))),
1910 : pattern("batcalc", "isnotnil", CMDbatISNOTNIL, false, "Unary check for notnil over the tail of the bat", args(1,2, batarg("",bit),batargany("b",0))),
1911 : pattern("batcalc", "isnotnil", CMDbatISNOTNIL, false, "Unary check for notnil over the tail of the bat with candidates list", args(1,3, batarg("",bit),batargany("b",0),batarg("s",oid))),
1912 : pattern("batcalc", "min", CMDbatMIN, false, "Return bat with minimum value of each pair of inputs", args(1,3, batargany("",1),batargany("b1",1),batargany("b2",1))),
1913 : pattern("batcalc", "min", CMDbatMIN, false, "Return bat with minimum value of each pair of inputs", args(1,5, batargany("",1),batargany("b1",1),batargany("b2",1),batarg("s1",oid),batarg("s2",oid))),
1914 : pattern("batcalc", "min", CMDbatMIN, false, "Return bat with minimum value of each pair of inputs", args(1,3, batargany("",1),batargany("b",1),argany("v",1))),
1915 : pattern("batcalc", "min", CMDbatMIN, false, "Return bat with minimum value of each pair of inputs", args(1,4, batargany("",1),batargany("b",1),argany("v",1),batarg("s",oid))),
1916 : pattern("batcalc", "min", CMDbatMIN, false, "Return bat with minimum value of each pair of inputs", args(1,3, batargany("",1),argany("v",1),batargany("b",1))),
1917 : pattern("batcalc", "min", CMDbatMIN, false, "Return bat with minimum value of each pair of inputs", args(1,4, batargany("",1),argany("v",1),batargany("b",1),batarg("s",oid))),
1918 : pattern("batcalc", "min_no_nil", CMDbatMIN_no_nil, false, "Return bat with minimum value of each pair of inputs, ignoring nil values", args(1,3, batargany("",1),batargany("b1",1),batargany("b2",1))),
1919 : pattern("batcalc", "min_no_nil", CMDbatMIN_no_nil, false, "Return bat with minimum value of each pair of inputs, ignoring nil values", args(1,5, batargany("",1),batargany("b1",1),batargany("b2",1),batarg("s1",oid),batarg("s2",oid))),
1920 : pattern("batcalc", "min_no_nil", CMDbatMIN_no_nil, false, "Return bat with minimum value of each pair of inputs, ignoring nil values", args(1,3, batargany("",1),batargany("b",1),argany("v",1))),
1921 : pattern("batcalc", "min_no_nil", CMDbatMIN_no_nil, false, "Return bat with minimum value of each pair of inputs, ignoring nil values", args(1,4, batargany("",1),batargany("b",1),argany("v",1),batarg("s",oid))),
1922 : pattern("batcalc", "min_no_nil", CMDbatMIN_no_nil, false, "Return bat with minimum value of each pair of inputs, ignoring nil values", args(1,3, batargany("",1),argany("v",1),batargany("b",1))),
1923 : pattern("batcalc", "min_no_nil", CMDbatMIN_no_nil, false, "Return bat with minimum value of each pair of inputs, ignoring nil values", args(1,4, batargany("",1),argany("v",1),batargany("b",1),batarg("s",oid))),
1924 : pattern("batcalc", "max", CMDbatMAX, false, "Return bat with maximum value of each pair of inputs", args(1,3, batargany("",1),batargany("b1",1),batargany("b2",1))),
1925 : pattern("batcalc", "max", CMDbatMAX, false, "Return bat with maximum value of each pair of inputs", args(1,5, batargany("",1),batargany("b1",1),batargany("b2",1),batarg("s1",oid),batarg("s2",oid))),
1926 : pattern("batcalc", "max", CMDbatMAX, false, "Return bat with maximum value of each pair of inputs", args(1,3, batargany("",1),batargany("b",1),argany("v",1))),
1927 : pattern("batcalc", "max", CMDbatMAX, false, "Return bat with maximum value of each pair of inputs", args(1,4, batargany("",1),batargany("b",1),argany("v",1),batarg("s",oid))),
1928 : pattern("batcalc", "max", CMDbatMAX, false, "Return bat with maximum value of each pair of inputs", args(1,3, batargany("",1),argany("v",1),batargany("b",1))),
1929 : pattern("batcalc", "max", CMDbatMAX, false, "Return bat with maximum value of each pair of inputs", args(1,4, batargany("",1),argany("v",1),batargany("b",1),batarg("s",oid))),
1930 : pattern("batcalc", "max_no_nil", CMDbatMAX_no_nil, false, "Return bat with maximum value of each pair of inputs, ignoring nil values", args(1,3, batargany("",1),batargany("b1",1),batargany("b2",1))),
1931 : pattern("batcalc", "max_no_nil", CMDbatMAX_no_nil, false, "Return bat with maximum value of each pair of inputs, ignoring nil values", args(1,5, batargany("",1),batargany("b1",1),batargany("b2",1),batarg("s1",oid),batarg("s2",oid))),
1932 : pattern("batcalc", "max_no_nil", CMDbatMAX_no_nil, false, "Return bat with maximum value of each pair of inputs, ignoring nil values", args(1,3, batargany("",1),batargany("b",1),argany("v",1))),
1933 : pattern("batcalc", "max_no_nil", CMDbatMAX_no_nil, false, "Return bat with maximum value of each pair of inputs, ignoring nil values", args(1,4, batargany("",1),batargany("b",1),argany("v",1),batarg("s",oid))),
1934 : pattern("batcalc", "max_no_nil", CMDbatMAX_no_nil, false, "Return bat with maximum value of each pair of inputs, ignoring nil values", args(1,3, batargany("",1),argany("v",1),batargany("b",1))),
1935 : pattern("batcalc", "max_no_nil", CMDbatMAX_no_nil, false, "Return bat with maximum value of each pair of inputs, ignoring nil values", args(1,4, batargany("",1),argany("v",1),batargany("b",1),batarg("s",oid))),
1936 :
1937 : pattern("batcalc", "+", CMDbatADDsignal, false, "Return concatenation of B1 and B2 with candidates list", args(1,5, batarg("",str),batarg("b1",str),batarg("b2",str),batarg("s1",oid),batarg("s2",oid))),
1938 : pattern("batcalc", "+", CMDbatADDsignal, false, "Return concatenation of B and V with candidates list", args(1,4, batarg("",str),batarg("b",str),arg("v",str),batarg("s",oid))),
1939 : pattern("batcalc", "+", CMDbatADDsignal, false, "Return concatenation of V and B with candidates list", args(1,4, batarg("",str),arg("v",str),batarg("b",str),batarg("s",oid))),
1940 :
1941 : pattern("batmmath", "fmod", CMDbatMODsignal, false, "", args(1,3, batarg("",dbl),batarg("x",dbl),arg("y",dbl))),
1942 : pattern("batmmath", "fmod", CMDbatMODsignal, false, "", args(1,4, batarg("",dbl),batarg("x",dbl),arg("y",dbl),batarg("s",oid))),
1943 : pattern("batmmath", "fmod", CMDbatMODsignal, false, "", args(1,3, batarg("",flt),batarg("x",flt),arg("y",flt))),
1944 : pattern("batmmath", "fmod", CMDbatMODsignal, false, "", args(1,4, batarg("",flt),batarg("x",flt),arg("y",flt),batarg("s",oid))),
1945 :
1946 : pattern("batcalc", "between", CMDbatBETWEEN, false, "B between V1 and V2 (or vice versa)", args(1,9, batarg("",bit),batargany("b",1),batargany("v1",1),batargany("v2",1),arg("sym",bit),arg("linc",bit),arg("hinc",bit),arg("nils_false",bit),arg("anti",bit))),
1947 : pattern("batcalc", "between", CMDbatBETWEEN, false, "B between V1 and V2 (or vice versa) with candidates list", args(1,12, batarg("",bit),batargany("b",1),batargany("v1",1),batargany("v2",1),batarg("s",oid),batarg("s1",oid),batarg("s2",oid),arg("sym",bit),arg("linc",bit),arg("hinc",bit),arg("nils_false",bit),arg("anti",bit))),
1948 : pattern("batcalc", "between", CMDbatBETWEEN, false, "B between V1 and V2 (or vice versa)", args(1,9, batarg("",bit),batargany("b",1),batargany("v1",1),argany("v2",1),arg("sym",bit),arg("linc",bit),arg("hinc",bit),arg("nils_false",bit),arg("anti",bit))),
1949 : pattern("batcalc", "between", CMDbatBETWEEN, false, "B between V1 and V2 (or vice versa) with candidates list", args(1,11, batarg("",bit),batargany("b",1),batargany("v1",1),argany("v2",1),batarg("s",oid),batarg("s1",oid),arg("sym",bit),arg("linc",bit),arg("hinc",bit),arg("nils_false",bit),arg("anti",bit))),
1950 : pattern("batcalc", "between", CMDbatBETWEEN, false, "B between V1 and V2 (or vice versa)", args(1,9, batarg("",bit),batargany("b",1),argany("v1",1),batargany("v2",1),arg("sym",bit),arg("linc",bit),arg("hinc",bit),arg("nils_false",bit),arg("anti",bit))),
1951 : pattern("batcalc", "between", CMDbatBETWEEN, false, "B between V1 and V2 (or vice versa) with candidates list", args(1,11, batarg("",bit),batargany("b",1),argany("v1",1),batargany("v2",1),batarg("s",oid),batarg("s2",oid),arg("sym",bit),arg("linc",bit),arg("hinc",bit),arg("nils_false",bit),arg("anti",bit))),
1952 : pattern("batcalc", "between", CMDbatBETWEEN, false, "B between V1 and V2 (or vice versa)", args(1,9, batarg("",bit),batargany("b",1),argany("v1",1),argany("v2",1),arg("sym",bit),arg("linc",bit),arg("hinc",bit),arg("nils_false",bit),arg("anti",bit))),
1953 : pattern("batcalc", "between", CMDbatBETWEEN, false, "B between V1 and V2 (or vice versa) with candidates list", args(1,10, batarg("",bit),batargany("b",1),argany("v1",1),argany("v2",1),batarg("s",oid),arg("sym",bit),arg("linc",bit),arg("hinc",bit),arg("nils_false",bit),arg("anti",bit))),
1954 :
1955 : pattern("aggr", "avg", CMDcalcavg, false, "Gives the avg of all tail values", args(1,2, arg("",dbl),batargany("b",1))),
1956 : pattern("aggr", "avg", CMDcalcavg, false, "Gives the avg of all tail values", args(1,3, arg("",dbl),batargany("b",1),arg("scale",int))),
1957 :
1958 : pattern("batcalc", "ifthenelse", CMDifthen, false, "If-then-else operation to assemble a conditional result", args(1,4, batargany("",1),arg("v",bit),batargany("b1",1),batargany("b2",1))),
1959 : pattern("batcalc", "ifthenelse", CMDifthen, false, "If-then-else operation to assemble a conditional result", args(1,4, batargany("",1),arg("v",bit),argany("v1",1),batargany("b2",1))),
1960 : pattern("batcalc", "ifthenelse", CMDifthen, false, "If-then-else operation to assemble a conditional result", args(1,4, batargany("",1),arg("v",bit),batargany("b1",1),argany("v2",1))),
1961 : pattern("batcalc", "ifthenelse", CMDifthen, false, "If-then-else operation to assemble a conditional result", args(1,4, batargany("",1),batarg("b",bit),argany("v1",1),argany("v2",1))),
1962 : pattern("batcalc", "ifthenelse", CMDifthen, false, "If-then-else operation to assemble a conditional result", args(1,4, batargany("",1),batarg("b",bit),batargany("b1",1),argany("v2",1))),
1963 : pattern("batcalc", "ifthenelse", CMDifthen, false, "If-then-else operation to assemble a conditional result", args(1,4, batargany("",1),batarg("b",bit),argany("v1",1),batargany("b2",1))),
1964 : pattern("batcalc", "ifthenelse", CMDifthen, false, "If-then-else operation to assemble a conditional result", args(1,4, batargany("",1),batarg("b",bit),batargany("b1",1),batargany("b2",1))),
1965 :
1966 : { .imp=NULL }
1967 :
1968 : };
1969 : #include "mal_import.h"
1970 : #ifdef _MSC_VER
1971 : #undef read
1972 : #pragma section(".CRT$XCU",read)
1973 : #endif
1974 345 : LIB_STARTUP_FUNC(init_batcalc_mal)
1975 345 : { mal_module2("batcalc", NULL, batcalc_init_funcs, &batcalc_init, NULL); }
|
