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 26 : mythrow(enum malexception type, const char *fcn, const char *msg)
20 : {
21 26 : char *errbuf = GDKerrbuf;
22 26 : char *s;
23 :
24 26 : if (errbuf && *errbuf) {
25 26 : if (strncmp(errbuf, "!ERROR: ", 8) == 0)
26 26 : errbuf += 8;
27 26 : if (strchr(errbuf, '!') == errbuf + 5) {
28 0 : s = createException(type, fcn, "%s", errbuf);
29 26 : } else if ((s = strchr(errbuf, ':')) != NULL && s[1] == ' ') {
30 26 : s = createException(type, fcn, "%s", s + 2);
31 : } else {
32 0 : s = createException(type, fcn, "%s", errbuf);
33 : }
34 26 : GDKclrerr();
35 26 : return s;
36 : }
37 0 : return createException(type, fcn, "%s", msg);
38 : }
39 :
40 : static str
41 17448 : CMDbatUNARY(MalStkPtr stk, InstrPtr pci,
42 : BAT *(*batfunc)(BAT *, BAT *), const char *malfunc)
43 : {
44 17448 : bat bid;
45 17448 : BAT *bn, *b, *s = NULL;
46 :
47 17448 : bid = *getArgReference_bat(stk, pci, 1);
48 17448 : if ((b = BATdescriptor(bid)) == NULL)
49 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
50 17464 : if (pci->argc == 3) {
51 265 : bid = *getArgReference_bat(stk, pci, 2);
52 265 : if (!is_bat_nil(bid)) {
53 244 : 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 17464 : bn = (*batfunc) (b, s);
61 17434 : BBPunfix(b->batCacheid);
62 17455 : BBPreclaim(s);
63 17452 : if (bn == NULL) {
64 0 : return mythrow(MAL, malfunc, OPERATION_FAILED);
65 : }
66 17452 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
67 17452 : BBPkeepref(bn);
68 17452 : 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 3433 : CMDbatISNIL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
113 : {
114 3433 : (void) cntxt;
115 3433 : (void) mb;
116 :
117 3433 : return CMDbatUNARY(stk, pci, BATcalcisnil, "batcalc.isnil");
118 : }
119 :
120 : static str
121 4591 : CMDbatISNOTNIL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
122 : {
123 4591 : (void) cntxt;
124 4591 : (void) mb;
125 :
126 4591 : return CMDbatUNARY(stk, pci, BATcalcisnotnil, "batcalc.isnotnil");
127 : }
128 :
129 : static str
130 1343 : CMDbatNOT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
131 : {
132 1343 : (void) cntxt;
133 1343 : (void) mb;
134 :
135 1343 : 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 225600 : 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 225600 : bat bid;
296 225600 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
297 225600 : int tp1, tp2, tp3;
298 :
299 225600 : tp1 = getArgType(mb, pci, 1); /*stk->stk[getArg(pci, 1)].vtype;*/ /* first argument */
300 225600 : tp2 = getArgType(mb, pci, 2); /*stk->stk[getArg(pci, 2)].vtype;*/ /* second argument */
301 225600 : tp3 = getArgType(mb, pci, 0); /* return argument */
302 225600 : assert(isaBatType(tp3));
303 225600 : tp3 = getBatType(tp3);
304 :
305 225600 : if (isaBatType(tp1)) {
306 224923 : bid = *getArgReference_bat(stk, pci, 1);
307 224923 : b1 = BATdescriptor(bid);
308 225520 : if (b1 == NULL)
309 0 : goto bailout;
310 : }
311 :
312 226197 : if (isaBatType(tp2)) {
313 95981 : bid = *getArgReference_bat(stk, pci, 2);
314 95981 : b2 = BATdescriptor(bid);
315 95995 : if (b2 == NULL)
316 0 : goto bailout;
317 : }
318 :
319 226211 : if (pci->argc > 4) {
320 95230 : assert(pci->argc == 5);
321 95230 : bid = *getArgReference_bat(stk, pci, 4);
322 95230 : if (!is_bat_nil(bid)) {
323 7087 : s2 = BATdescriptor(bid);
324 7092 : if (s2 == NULL)
325 0 : goto bailout;
326 : }
327 : }
328 226216 : if (pci->argc > 3) {
329 226231 : bid = *getArgReference_bat(stk, pci, 3);
330 226231 : if (!is_bat_nil(bid)) {
331 49541 : s1 = BATdescriptor(bid);
332 49560 : if (s1 == NULL)
333 0 : goto bailout;
334 49560 : if (b1 == NULL) {
335 24 : s2 = s1;
336 24 : s1 = NULL;
337 : }
338 : }
339 : }
340 :
341 226235 : if (b1 && b2) {
342 95243 : if (tp3 == TYPE_any)
343 0 : tp3 = (*typefunc) (b1->ttype, b2->ttype);
344 95243 : bn = (*batfunc) (b1, b2, s1, s2, tp3);
345 130992 : } else if (b1) {
346 130247 : if (tp3 == TYPE_any)
347 0 : tp3 = (*typefunc) (b1->ttype, tp2);
348 130247 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1, tp3);
349 745 : } else if (b2) {
350 745 : if (tp3 == TYPE_any)
351 0 : tp3 = (*typefunc) (tp1, b2->ttype);
352 745 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2, tp3);
353 : } else
354 0 : goto bailout; /* cannot happen */
355 225544 : BBPreclaim(b1);
356 226238 : BBPreclaim(b2);
357 226192 : BBPreclaim(s1);
358 226011 : BBPreclaim(s2);
359 226234 : if (bn == NULL)
360 10 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
361 226224 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
362 226224 : BBPkeepref(bn);
363 226224 : 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 551 : 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 551 : bat bid;
394 551 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
395 :
396 551 : if (stk->stk[getArg(pci, 1)].bat) {
397 551 : bid = *getArgReference_bat(stk, pci, 1);
398 551 : b1 = BATdescriptor(bid);
399 552 : if (b1 == NULL)
400 0 : goto bailout;
401 : }
402 :
403 552 : 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 552 : 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 552 : 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 552 : if (b1 && b2)
433 5 : bn = (*batfunc) (b1, b2, s1, s2);
434 547 : else if (b1)
435 546 : 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 553 : BBPreclaim(b1);
441 553 : BBPreclaim(b2);
442 553 : BBPreclaim(s1);
443 553 : BBPreclaim(s2);
444 552 : if (bn == NULL)
445 0 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
446 552 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
447 552 : BBPkeepref(bn);
448 552 : 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 99100 : 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 99100 : bat bid;
479 99100 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
480 :
481 99100 : if (stk->stk[getArg(pci, 1)].bat) {
482 98880 : bid = *getArgReference_bat(stk, pci, 1);
483 98880 : b1 = BATdescriptor(bid);
484 99275 : if (b1 == NULL)
485 0 : goto bailout;
486 : }
487 :
488 99495 : if (stk->stk[getArg(pci, 2)].bat) {
489 80290 : bid = *getArgReference_bat(stk, pci, 2);
490 80290 : b2 = BATdescriptor(bid);
491 80279 : if (b2 == NULL)
492 0 : goto bailout;
493 : }
494 :
495 99484 : if (pci->argc > 5) {
496 6 : assert(pci->argc == 6);
497 6 : nil_matches = *getArgReference_bit(stk, pci, 5);
498 : }
499 99484 : if (pci->argc > 4) {
500 1379 : if (stk->stk[getArg(pci, 4)].bat) {
501 1379 : bid = *getArgReference_bat(stk, pci, 4);
502 1379 : if (!is_bat_nil(bid)) {
503 159 : s2 = BATdescriptor(bid);
504 160 : 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 99485 : if (pci->argc > 3) {
513 21613 : if (stk->stk[getArg(pci, 3)].bat) {
514 8435 : bid = *getArgReference_bat(stk, pci, 3);
515 8435 : if (!is_bat_nil(bid)) {
516 7954 : s1 = BATdescriptor(bid);
517 7958 : if (s1 == NULL)
518 0 : goto bailout;
519 7958 : if (b1 == NULL) {
520 79 : s2 = s1;
521 79 : s1 = NULL;
522 : }
523 : }
524 : } else {
525 13178 : assert(pci->argc == 4);
526 13178 : nil_matches = *getArgReference_bit(stk, pci, 3);
527 : }
528 : }
529 :
530 99489 : if (b1 && b2)
531 80014 : bn = (*batfunc) (b1, b2, s1, s2, nil_matches);
532 19475 : else if (b1)
533 19217 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1, nil_matches);
534 258 : else if (b2)
535 258 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2, nil_matches);
536 : else
537 0 : goto bailout; /* cannot happen */
538 99410 : BBPreclaim(b1);
539 99496 : BBPreclaim(b2);
540 99499 : BBPreclaim(s1);
541 99420 : BBPreclaim(s2);
542 99507 : if (bn == NULL)
543 0 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
544 99507 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
545 99507 : BBPkeepref(bn);
546 99507 : 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 86035 : 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 86035 : bat bid;
568 86035 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
569 :
570 86035 : if (stk->stk[getArg(pci, 1)].bat) {
571 85968 : bid = *getArgReference_bat(stk, pci, 1);
572 85968 : b1 = BATdescriptor(bid);
573 86335 : if (b1 == NULL)
574 0 : goto bailout;
575 : }
576 :
577 86402 : if (stk->stk[getArg(pci, 2)].bat) {
578 82968 : bid = *getArgReference_bat(stk, pci, 2);
579 82968 : b2 = BATdescriptor(bid);
580 82970 : if (b2 == NULL)
581 0 : goto bailout;
582 : }
583 :
584 86404 : if (pci->argc > 4) {
585 19398 : assert(pci->argc == 5);
586 19398 : bid = *getArgReference_bat(stk, pci, 4);
587 19398 : if (!is_bat_nil(bid)) {
588 4328 : s2 = BATdescriptor(bid);
589 4328 : if (s2 == NULL)
590 0 : goto bailout;
591 : }
592 : }
593 86404 : if (pci->argc > 3) {
594 19997 : bid = *getArgReference_bat(stk, pci, 3);
595 19997 : if (!is_bat_nil(bid)) {
596 15424 : s1 = BATdescriptor(bid);
597 15420 : if (s1 == NULL)
598 0 : goto bailout;
599 15420 : if (b1 == NULL) {
600 1 : s2 = s1;
601 1 : s1 = NULL;
602 : }
603 : }
604 : }
605 :
606 86400 : if (b1 && b2)
607 82792 : bn = (*batfunc) (b1, b2, s1, s2);
608 3608 : else if (b1)
609 3491 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1);
610 117 : else if (b2)
611 117 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2);
612 : else
613 0 : goto bailout; /* cannot happen */
614 86215 : BBPreclaim(b1);
615 86438 : BBPreclaim(b2);
616 86420 : BBPreclaim(s1);
617 86438 : BBPreclaim(s2);
618 86368 : if (bn == NULL)
619 2 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
620 86366 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
621 86366 : BBPkeepref(bn);
622 86366 : 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 396 : CMDbatMIN(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
636 : {
637 396 : (void) cntxt;
638 396 : (void) mb;
639 :
640 396 : return CMDbatBINARY0(stk, pci, BATcalcmin, BATcalcmincst, BATcalccstmin,
641 : "batcalc.min");
642 : }
643 :
644 : static str
645 130 : CMDbatMIN_no_nil(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
646 : {
647 130 : (void) cntxt;
648 130 : (void) mb;
649 :
650 130 : 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 103346 : CMDbatADDsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
676 : {
677 103346 : (void) cntxt;
678 :
679 103346 : return CMDbatBINARY2(mb, stk, pci, BATcalcadd, BATcalcaddcst, BATcalccstadd,
680 : calctype, "batcalc.+");
681 : }
682 :
683 : static str
684 23275 : CMDbatADDenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
685 : {
686 23275 : (void) cntxt;
687 :
688 23275 : return CMDbatBINARY2(mb, stk, pci, BATcalcadd, BATcalcaddcst, BATcalccstadd,
689 : calctypeenlarge, "batcalc.add_enlarge");
690 : }
691 :
692 : static str
693 23061 : CMDbatSUBsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
694 : {
695 23061 : (void) cntxt;
696 :
697 23061 : return CMDbatBINARY2(mb, stk, pci, BATcalcsub, BATcalcsubcst, BATcalccstsub,
698 : calctype, "batcalc.-");
699 : }
700 :
701 : static str
702 25606 : CMDbatSUBenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
703 : {
704 25606 : (void) cntxt;
705 :
706 25606 : return CMDbatBINARY2(mb, stk, pci, BATcalcsub, BATcalcsubcst, BATcalccstsub,
707 : calctypeenlarge, "batcalc.sub_enlarge");
708 : }
709 :
710 : static str
711 31094 : CMDbatMULsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
712 : {
713 31094 : (void) cntxt;
714 :
715 31094 : return CMDbatBINARY2(mb, stk, pci, BATcalcmul, BATcalcmulcst, BATcalccstmul,
716 : calctype, "batcalc.*");
717 : }
718 :
719 : static str
720 13992 : CMDbatMULenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
721 : {
722 13992 : (void) cntxt;
723 :
724 13992 : return CMDbatBINARY2(mb, stk, pci, BATcalcmul, BATcalcmulcst, BATcalccstmul,
725 : calctypeenlarge, "batcalc.mul_enlarge");
726 : }
727 :
728 : static str
729 5039 : CMDbatDIVsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
730 : {
731 5039 : (void) cntxt;
732 :
733 5039 : return CMDbatBINARY2(mb, stk, pci, BATcalcdiv, BATcalcdivcst, BATcalccstdiv,
734 : calcdivtype, "batcalc./");
735 : }
736 :
737 : static str
738 616 : CMDbatMODsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
739 : {
740 616 : (void) cntxt;
741 :
742 616 : 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 5405 : CMDbatOR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
758 : {
759 5405 : (void) cntxt;
760 5405 : (void) mb;
761 :
762 5405 : return CMDbatBINARY0(stk, pci, BATcalcor, BATcalcorcst, BATcalccstor,
763 : "batcalc.or");
764 : }
765 :
766 : static str
767 10577 : CMDbatAND(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
768 : {
769 10577 : (void) cntxt;
770 10577 : (void) mb;
771 :
772 10577 : 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 549 : CMDbatRSHsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
788 : {
789 549 : (void) cntxt;
790 549 : (void) mb;
791 :
792 549 : return CMDbatBINARY1(stk, pci, BATcalcrsh, BATcalcrshcst, BATcalccstrsh,
793 : "batcalc.>>");
794 : }
795 :
796 : static str
797 15426 : CMDbatLT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
798 : {
799 15426 : (void) cntxt;
800 15426 : (void) mb;
801 :
802 15426 : return CMDbatBINARY0(stk, pci, BATcalclt, BATcalcltcst, BATcalccstlt,
803 : "batcalc.<");
804 : }
805 :
806 : static str
807 10151 : CMDbatLE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
808 : {
809 10151 : (void) cntxt;
810 10151 : (void) mb;
811 :
812 10151 : return CMDbatBINARY0(stk, pci, BATcalcle, BATcalclecst, BATcalccstle,
813 : "batcalc.<=");
814 : }
815 :
816 : static str
817 38158 : CMDbatGT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
818 : {
819 38158 : (void) cntxt;
820 38158 : (void) mb;
821 :
822 38158 : return CMDbatBINARY0(stk, pci, BATcalcgt, BATcalcgtcst, BATcalccstgt,
823 : "batcalc.>");
824 : }
825 :
826 : static str
827 5985 : CMDbatGE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
828 : {
829 5985 : (void) cntxt;
830 5985 : (void) mb;
831 :
832 5985 : return CMDbatBINARY0(stk, pci, BATcalcge, BATcalcgecst, BATcalccstge,
833 : "batcalc.>=");
834 : }
835 :
836 : static str
837 97361 : CMDbatEQ(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
838 : {
839 97361 : (void) cntxt;
840 97361 : (void) mb;
841 :
842 97361 : return CMDbatBINARY1a(stk, pci, BATcalceq, BATcalceqcst, BATcalccsteq,
843 : false, "batcalc.==");
844 : }
845 :
846 : static str
847 1905 : CMDbatNE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
848 : {
849 1905 : (void) cntxt;
850 1905 : (void) mb;
851 :
852 1905 : 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 25368 : if (b == NULL)
887 0 : goto bailout;
888 25368 : if (isaBatType(tp2)) {
889 25205 : bid = *getArgReference_bat(stk, pci, 2);
890 25205 : lo = BATdescriptor(bid);
891 25227 : if (lo == NULL)
892 0 : goto bailout;
893 : }
894 25390 : if (isaBatType(tp3)) {
895 25204 : bid = *getArgReference_bat(stk, pci, 3);
896 25204 : hi = BATdescriptor(bid);
897 25206 : if (hi == NULL)
898 0 : goto bailout;
899 : }
900 25392 : tp = getArgType(mb, pci, 4);
901 25392 : if (isaBatType(tp)) {
902 11567 : bid = *getArgReference_bat(stk, pci, 4);
903 11567 : has_cand = true;
904 11567 : if (!is_bat_nil(bid)) {
905 1394 : s = BATdescriptor(bid);
906 1394 : if (s == NULL)
907 0 : goto bailout;
908 : }
909 : bc++;
910 : }
911 25392 : if (has_cand && lo) {
912 11450 : tp = getArgType(mb, pci, 4 + bc);
913 11450 : if (isaBatType(tp)) {
914 11450 : bid = *getArgReference_bat(stk, pci, 4 + bc);
915 11450 : if (!is_bat_nil(bid)) {
916 1826 : slo = BATdescriptor(bid);
917 1828 : if (slo == NULL)
918 0 : goto bailout;
919 : }
920 11452 : 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 25394 : if (has_cand && hi) {
931 11416 : tp = getArgType(mb, pci, 4 + bc);
932 11416 : if (!isaBatType(tp))
933 0 : goto bailout;
934 11416 : bid = *getArgReference_bat(stk, pci, 4 + bc);
935 11416 : if (!is_bat_nil(bid)) {
936 855 : shi = BATdescriptor(bid);
937 857 : if (shi == NULL)
938 0 : goto bailout;
939 : }
940 11418 : bc++;
941 : }
942 :
943 25396 : symmetric = *getArgReference_bit(stk, pci, bc + 4);
944 25396 : linc = *getArgReference_bit(stk, pci, bc + 5);
945 25396 : hinc = *getArgReference_bit(stk, pci, bc + 6);
946 25396 : nils_false = *getArgReference_bit(stk, pci, bc + 7);
947 25396 : anti = *getArgReference_bit(stk, pci, bc + 8);
948 :
949 25396 : if (b && lo && hi)
950 25127 : bn = BATcalcbetween(b, lo, hi, s, slo, shi,
951 : symmetric, linc, hinc, nils_false, anti);
952 269 : 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 201 : else if (b && hi)
956 45 : bn = BATcalcbetweencstbat(b, &stk->stk[getArg(pci, 2)], hi, s, shi,
957 : symmetric, linc, hinc, nils_false, anti);
958 : else
959 156 : bn = BATcalcbetweencstcst(b, &stk->stk[getArg(pci, 2)],
960 156 : &stk->stk[getArg(pci, 3)], s,
961 : symmetric, linc, hinc, nils_false, anti);
962 25246 : BBPunfix(b->batCacheid);
963 25403 : BBPreclaim(lo);
964 25421 : BBPreclaim(hi);
965 25415 : BBPreclaim(s);
966 25417 : BBPreclaim(slo);
967 25402 : BBPreclaim(shi);
968 25426 : if (bn == NULL)
969 0 : return mythrow(MAL, "batcalc.between", OPERATION_FAILED);
970 25426 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
971 25426 : BBPkeepref(bn);
972 25426 : 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 7973 : CMDcalcavg(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
988 : {
989 7973 : dbl avg;
990 7973 : BUN vals;
991 7973 : bat bid;
992 7973 : BAT *b, *s = NULL;
993 7973 : gdk_return ret;
994 7973 : int scale = 0;
995 :
996 7973 : (void) cntxt;
997 7973 : (void) mb;
998 :
999 7973 : bid = *getArgReference_bat(stk, pci, pci->retc + 0);
1000 7973 : if ((b = BATdescriptor(bid)) == NULL)
1001 0 : throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1002 7976 : if ((pci->argc == pci->retc + 2 &&
1003 0 : stk->stk[pci->argv[pci->retc + 1]].bat) ||
1004 7976 : 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 7976 : 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 7976 : ret = BATcalcavg(b, s, &avg, &vals, scale);
1016 7972 : BBPunfix(b->batCacheid);
1017 7976 : BBPreclaim(s);
1018 7976 : if (ret != GDK_SUCCEED)
1019 0 : return mythrow(MAL, "aggr.avg", OPERATION_FAILED);
1020 7976 : *getArgReference_dbl(stk, pci, 0) = avg;
1021 7976 : if (pci->retc == 2)
1022 7934 : *getArgReference_lng(stk, pci, 1) = vals;
1023 : return MAL_SUCCEED;
1024 : }
1025 :
1026 : static str
1027 75285 : CMDconvertbat(MalStkPtr stk, InstrPtr pci, int tp)
1028 : {
1029 75285 : bat bid;
1030 75285 : BAT *b, *bn, *s = NULL;
1031 :
1032 75285 : bid = *getArgReference_bat(stk, pci, 1);
1033 75285 : if ((b = BATdescriptor(bid)) == NULL)
1034 0 : throw(MAL, "batcalc.convert", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1035 75387 : if (pci->argc == 3) {
1036 74327 : bid = *getArgReference_bat(stk, pci, 2);
1037 74327 : 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 13800 : 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 75385 : bn = BATconvert(b, s, tp, 0, 0, 0);
1050 75202 : BBPunfix(b->batCacheid);
1051 75372 : BBPreclaim(s);
1052 75377 : if (bn == NULL) {
1053 14 : char buf[20];
1054 14 : snprintf(buf, sizeof(buf), "batcalc.%s", ATOMname(tp));
1055 14 : return mythrow(MAL, buf, OPERATION_FAILED);
1056 : }
1057 75363 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
1058 75363 : BBPkeepref(bn);
1059 75363 : 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 141 : CMDconvertsignal_bte(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1073 : {
1074 141 : (void) cntxt;
1075 141 : (void) mb;
1076 :
1077 141 : return CMDconvertbat(stk, pci, TYPE_bte);
1078 : }
1079 :
1080 : static str
1081 5101 : CMDconvertsignal_sht(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1082 : {
1083 5101 : (void) cntxt;
1084 5101 : (void) mb;
1085 :
1086 5101 : return CMDconvertbat(stk, pci, TYPE_sht);
1087 : }
1088 :
1089 : static str
1090 7192 : CMDconvertsignal_int(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1091 : {
1092 7192 : (void) cntxt;
1093 7192 : (void) mb;
1094 :
1095 7192 : return CMDconvertbat(stk, pci, TYPE_int);
1096 : }
1097 :
1098 : static str
1099 59342 : CMDconvertsignal_lng(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1100 : {
1101 59342 : (void) cntxt;
1102 59342 : (void) mb;
1103 :
1104 59342 : return CMDconvertbat(stk, pci, TYPE_lng);
1105 : }
1106 :
1107 : #ifdef HAVE_HGE
1108 :
1109 : static str
1110 156 : CMDconvertsignal_hge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1111 : {
1112 156 : (void) cntxt;
1113 156 : (void) mb;
1114 :
1115 156 : return CMDconvertbat(stk, pci, TYPE_hge);
1116 : }
1117 : #endif
1118 :
1119 : static str
1120 269 : CMDconvertsignal_flt(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1121 : {
1122 269 : (void) cntxt;
1123 269 : (void) mb;
1124 :
1125 269 : return CMDconvertbat(stk, pci, TYPE_flt);
1126 : }
1127 :
1128 : static str
1129 2601 : CMDconvertsignal_dbl(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1130 : {
1131 2601 : (void) cntxt;
1132 2601 : (void) mb;
1133 :
1134 2601 : 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 190 : CMDconvertsignal_str(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1148 : {
1149 190 : (void) cntxt;
1150 190 : (void) mb;
1151 :
1152 190 : return CMDconvertbat(stk, pci, TYPE_str);
1153 : }
1154 :
1155 : static str
1156 4406 : CMDifthen(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1157 : {
1158 4406 : BAT *b = NULL, *b1 = NULL, *b2 = NULL, *bn;
1159 4406 : int tp0, tp1, tp2;
1160 4406 : bat *ret;
1161 4406 : BUN cnt = BUN_NONE;
1162 :
1163 4406 : (void) cntxt;
1164 :
1165 4406 : if (pci->argc != 4)
1166 0 : throw(MAL, "batcalc.ifthen", "Operation not supported.");
1167 :
1168 4406 : ret = getArgReference_bat(stk, pci, 0);
1169 4406 : tp0 = stk->stk[getArg(pci, 1)].vtype;
1170 4406 : tp1 = getArgType(mb, pci, 2);
1171 4406 : tp2 = getArgType(mb, pci, 3);
1172 4406 : if (stk->stk[getArg(pci, 1)].bat) {
1173 4409 : b = BATdescriptor(*getArgReference_bat(stk, pci, 1));
1174 4415 : if (b == NULL)
1175 0 : throw(MAL, "batcalc.ifthenelse",
1176 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1177 4415 : cnt = BATcount(b);
1178 : }
1179 4412 : 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 4412 : if (isaBatType(tp2)) {
1194 2755 : b2 = BATdescriptor(*getArgReference_bat(stk, pci, 3));
1195 2756 : 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 2756 : if (cnt == BUN_NONE)
1202 4413 : cnt = BATcount(b2);
1203 2756 : else if (BATcount(b2) != cnt) {
1204 0 : BBPreclaim(b);
1205 0 : BBPreclaim(b1);
1206 0 : throw(MAL, "batcalc.ifthenelse", ILLEGAL_ARGUMENT);
1207 : }
1208 : }
1209 4413 : if (b == NULL && b1 == NULL && b2 == NULL) {
1210 : /* at least one BAT required */
1211 0 : throw(MAL, "batcalc.ifthenelse", ILLEGAL_ARGUMENT);
1212 : }
1213 4413 : if (b != NULL) {
1214 4413 : if (b1 != NULL) {
1215 269 : if (b2 != NULL) {
1216 72 : bn = BATcalcifthenelse(b, b1, b2);
1217 : } else {
1218 197 : bn = BATcalcifthenelsecst(b, b1, &stk->stk[getArg(pci, 3)]);
1219 : }
1220 : } else {
1221 4144 : if (b2 != NULL) {
1222 2684 : bn = BATcalcifthencstelse(b, &stk->stk[getArg(pci, 2)], b2);
1223 : } else {
1224 1460 : bn = BATcalcifthencstelsecst(b, &stk->stk[getArg(pci, 2)],
1225 1460 : &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 4411 : BBPreclaim(b);
1258 4415 : BBPreclaim(b1);
1259 4415 : BBPreclaim(b2);
1260 4414 : if (bn == NULL) {
1261 0 : return mythrow(MAL, "batcalc.ifthenelse", OPERATION_FAILED);
1262 : }
1263 4414 : *ret = bn->batCacheid;
1264 4414 : BBPkeepref(bn);
1265 4414 : return MAL_SUCCEED;
1266 : }
1267 :
1268 : #include "mel.h"
1269 :
1270 : static str
1271 330 : batcalc_init(void)
1272 : {
1273 330 : int types[16], cur = 0, *tp;
1274 330 : int specials[4];
1275 330 : int *integer, *floats, *extra;
1276 :
1277 330 : types[cur++] = TYPE_bit;
1278 330 : integer = types+cur;
1279 330 : types[cur++] = TYPE_bte;
1280 330 : types[cur++] = TYPE_sht;
1281 330 : types[cur++] = TYPE_int;
1282 330 : types[cur++] = TYPE_lng;
1283 : #ifdef HAVE_HGE
1284 330 : types[cur++] = TYPE_hge;
1285 : #endif
1286 330 : floats = types+cur;
1287 330 : types[cur++] = TYPE_flt;
1288 330 : types[cur++] = TYPE_dbl;
1289 330 : extra = types+cur;
1290 330 : types[cur++] = TYPE_oid;
1291 330 : types[cur++] = TYPE_str;
1292 :
1293 330 : cur = 0;
1294 330 : specials[cur++] = TYPE_bit;
1295 330 : specials[cur++] = TYPE_oid;
1296 330 : specials[cur++] = TYPE_str;
1297 :
1298 330 : mel_func_arg cand = { .type = TYPE_oid, .isbat=1 };
1299 :
1300 330 : int err=0;
1301 : /* for all numeric types, use reverse order */
1302 2640 : for(tp = integer; tp < extra && !err; tp++) {
1303 2310 : mel_func_arg ret = { .type = TYPE_bit, .isbat=1 };
1304 2310 : mel_func_arg arg = { .type = *tp, .isbat=1 };
1305 :
1306 2310 : err += melFunction(false, "batcalc", "iszero", (MALfcn)&CMDbatISZERO, "CMDbatISZERO", false, "Unary check for zero over the tail of the bat", 1, 2, ret, arg);
1307 2310 : 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 2970 : for(tp = types; tp < extra && !err; tp++) { /* bit + numeric */
1310 2640 : mel_func_arg ret = { .type = *tp, .isbat =1 };
1311 2640 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1312 :
1313 2640 : err += melFunction(false, "batcalc", "not", (MALfcn)&CMDbatNOT, "CMDbatNOT", false, "Unary bitwise not over the tail of the bat", 1, 2, ret, arg);
1314 2640 : 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 2640 : for(tp = integer; tp < extra && !err; tp++) {
1317 2310 : mel_func_arg ret = { .type = TYPE_bte, .isbat =1 };
1318 2310 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1319 :
1320 2310 : 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 2310 : 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 2640 : for(tp = integer; tp < extra && !err; tp++) {
1324 2310 : mel_func_arg ret = { .type = *tp, .isbat =1 };
1325 2310 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1326 :
1327 2310 : err += melFunction(false, "batcalc", "abs", (MALfcn)&CMDbatABS, "CMDbatABS", false, "Unary abs over the tail of the bat", 1, 2, ret, arg);
1328 2310 : 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 2310 : err += melFunction(false, "batcalc", "-", (MALfcn)&CMDbatNEG, "CMDbatNEG", false, "Unary neg over the tail of the bat", 1, 2, ret, arg);
1331 2310 : 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 2310 : err += melFunction(false, "batcalc", "++", (MALfcn)&CMDbatINCR, "CMDbatINCR", false, "Unary increment over the tail of the bat", 1, 2, ret, arg);
1334 2310 : 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 2310 : err += melFunction(false, "batcalc", "--", (MALfcn)&CMDbatDECR, "CMDbatDECR", false, "Unary decrement over the tail of the bat", 1, 2, ret, arg);
1337 2310 : 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 330 : 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 330 : } 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 1320 : for (int f=0; f<3; f++) {
1393 : int *tp1, *tp2, *rt;
1394 7920 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1395 55440 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1396 388080 : for(rt = extra-1; rt >= integer && !err; rt--) {
1397 339570 : if (f!=3 && (*rt < *tp1 || *rt < *tp2))
1398 200970 : continue;
1399 138600 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1400 138600 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1401 138600 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1402 138600 : mel_func_arg varg1 = { .type = *tp1 };
1403 138600 : mel_func_arg varg2 = { .type = *tp2 };
1404 :
1405 138600 : if (*rt == *tp1 || *rt == *tp2 || f==3) {
1406 48510 : 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 48510 : 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 48510 : 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 90090 : 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 90090 : 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 90090 : 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 1980 : for(tp1 = integer; tp1 < floats && !err; tp1++) {
1421 4950 : for(tp2 = floats; tp2 < extra && !err; tp2++) {
1422 19800 : for(tp3 = integer; tp3 < floats && !err; tp3++) {
1423 16500 : int in1 = *tp3, in2 = *tp2;
1424 :
1425 49500 : for (int i = 0 ; i < 2 ; i++) {
1426 33000 : mel_func_arg ret = { .type = *tp1, .isbat =1 };
1427 33000 : mel_func_arg arg1 = { .type = in1, .isbat =1 };
1428 33000 : mel_func_arg arg2 = { .type = in2, .isbat =1 };
1429 33000 : mel_func_arg varg1 = { .type = in1 };
1430 33000 : mel_func_arg varg2 = { .type = in2 };
1431 :
1432 33000 : 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 33000 : 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 33000 : 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 33000 : in1 ^= in2;
1438 33000 : in2 ^= in1;
1439 33000 : in1 ^= in2;
1440 : }
1441 : }
1442 : }
1443 : }
1444 : }
1445 330 : 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 330 : } 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 330 : int *tp1, *tp2, *rt;
1466 2640 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1467 18480 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1468 80850 : for(rt = extra-1; rt >= tp1 && !err; rt--) {
1469 64680 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1470 64680 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1471 64680 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1472 64680 : mel_func_arg varg1 = { .type = *tp1 };
1473 64680 : mel_func_arg varg2 = { .type = *tp2 };
1474 :
1475 64680 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment, 1, 5, ret, arg1, arg2, cand, cand);
1476 64680 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment_v, 1, 4, ret, arg1, varg2, cand);
1477 64680 : 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 990 : for(tp1 = floats; tp1 < extra && !err; tp1++) {
1483 3960 : for(tp2 = integer; tp2 < floats && !err; tp2++) {
1484 19800 : for(rt = integer; rt < floats && !err; rt++) {
1485 16500 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1486 16500 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1487 16500 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1488 16500 : mel_func_arg varg1 = { .type = *tp1 };
1489 16500 : mel_func_arg varg2 = { .type = *tp2 };
1490 :
1491 16500 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment, 1, 5, ret, arg1, arg2, cand, cand);
1492 16500 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment_v, 1, 4, ret, arg1, varg2, cand);
1493 16500 : 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 2640 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1513 18480 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1514 129360 : for(rt = extra-1; rt >= integer && !err; rt--) {
1515 113190 : if (rt < tp1 && rt < tp2)
1516 81180 : continue;
1517 83160 : if (*rt == TYPE_dbl) {
1518 16170 : if (*tp1 != TYPE_dbl || *tp2 != TYPE_dbl)
1519 15840 : continue;
1520 66990 : } else if (*rt == TYPE_flt) {
1521 15840 : if (*tp1 != TYPE_flt || *tp2 != TYPE_flt)
1522 15510 : continue;
1523 : } else {
1524 51150 : if (*tp1 == TYPE_flt || *tp2 == TYPE_flt || *tp1 == TYPE_dbl || *tp2 == TYPE_dbl)
1525 19800 : continue;
1526 : }
1527 32010 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1528 32010 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1529 32010 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1530 32010 : mel_func_arg varg1 = { .type = *tp1 };
1531 32010 : mel_func_arg varg2 = { .type = *tp2 };
1532 :
1533 32010 : err += melFunction(false, "batcalc", mods.op, mods.fcn, mods.fname, false, mods.comment, 1, 5, ret, arg1, arg2, cand, cand);
1534 32010 : err += melFunction(false, "batcalc", mods.op, mods.fcn, mods.fname, false, mods.comment_v, 1, 4, ret, arg1, varg2, cand);
1535 32010 : err += melFunction(false, "batcalc", mods.op, mods.fcn, mods.fname, false, mods.comment_v_, 1, 4, ret, varg1, arg2, cand);
1536 : }
1537 : }
1538 : }
1539 330 : struct {
1540 : char *op;
1541 : char *fname;
1542 : MALfcn fcn;
1543 : char *comment;
1544 : char *comment_v;
1545 : char *comment_v_;
1546 330 : } 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 1320 : for (int f=0; f<3; f++) {
1571 8910 : for(tp = types+0; tp < extra && !err; tp++) {
1572 7920 : mel_func_arg ret = { .type = *tp, .isbat =1 };
1573 7920 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1574 7920 : mel_func_arg varg = { .type = *tp };
1575 :
1576 7920 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment, 1, 3, ret, arg, arg);
1577 7920 : 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 7920 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment_v, 1, 3, ret, arg, varg);
1579 7920 : 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 7920 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment_v_, 1, 3, ret, varg, arg);
1581 7920 : 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 330 : struct {
1585 : char *op;
1586 : char *fname;
1587 : MALfcn fcn;
1588 : char *comment;
1589 : char *comment_v;
1590 : char *comment_v_;
1591 330 : } 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 990 : for (int f=0; f<2; f++) {
1609 : int *tp1, *tp2;
1610 3960 : for(tp1 = integer; tp1 < floats && !err; tp1++) {
1611 19800 : for(tp2 = integer; tp2 < floats && !err; tp2++) {
1612 16500 : mel_func_arg ret = { .type = *tp1, .isbat =1 };
1613 16500 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1614 16500 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1615 16500 : mel_func_arg varg1 = { .type = *tp1 };
1616 16500 : mel_func_arg varg2 = { .type = *tp2 };
1617 :
1618 16500 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment, 1, 3, ret, arg1, arg2);
1619 16500 : 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 16500 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment_v, 1, 3, ret, arg1, varg2);
1621 16500 : 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 16500 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment_v_, 1, 3, ret, varg1, arg2);
1623 16500 : 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 330 : struct {
1629 : char *op;
1630 : char *fname;
1631 : MALfcn fcn;
1632 : char *comment;
1633 : char *comment_v;
1634 : char *comment_v_;
1635 330 : } 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 330 : int newtypes[6] = { ATOMindex("json"), ATOMindex("inet"), ATOMindex("uuid"), TYPE_date, TYPE_daytime, TYPE_timestamp };
1681 2310 : for (int f=0; f<6; f++) {
1682 1980 : mel_func_arg ret = { .type = TYPE_bit, .isbat =1 };
1683 1980 : mel_func_arg arg = { .type = TYPE_any, .isbat =1, .nr=1 };
1684 1980 : mel_func_arg varg = { .type = TYPE_any, .nr=1 };
1685 :
1686 1980 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 3, ret, arg, arg);
1687 1980 : 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 1980 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 3, ret, arg, varg);
1689 1980 : 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 1980 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 3, ret, varg, arg);
1691 1980 : 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 1980 : if (strcmp(cmps[f].op,"==")==0 || strcmp(cmps[f].op,"!=")==0) {
1694 660 : mel_func_arg nil_matches = { .type = TYPE_bit };
1695 :
1696 660 : 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 660 : 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 660 : 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 660 : 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 660 : 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 660 : 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 13860 : for (int nt = 0; nt < 6; nt++) {
1706 11880 : mel_func_arg ret = { .type = TYPE_bit, .isbat =1 };
1707 11880 : mel_func_arg arg = { .type = newtypes[nt], .isbat =1, .nr=1 };
1708 11880 : mel_func_arg varg = { .type = newtypes[nt], .nr=1 };
1709 :
1710 11880 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 3, ret, arg, arg);
1711 11880 : 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 11880 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 3, ret, arg, varg);
1713 11880 : 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 11880 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 3, ret, varg, arg);
1715 11880 : 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 11880 : if (strcmp(cmps[f].op,"==")==0 || strcmp(cmps[f].op,"!=")==0) {
1718 3960 : mel_func_arg nil_matches = { .type = TYPE_bit };
1719 :
1720 3960 : 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 3960 : 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 3960 : 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 3960 : 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 3960 : 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 3960 : 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 11880 : for(tp1 = integer; tp1 < floats && !err; tp1++) {
1731 59400 : for(tp2 = integer; tp2 < floats && !err; tp2++) {
1732 49500 : if (*tp1 == *tp2)
1733 9900 : continue;
1734 39600 : mel_func_arg ret = { .type = TYPE_bit, .isbat =1 };
1735 39600 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1736 39600 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1737 39600 : mel_func_arg varg1 = { .type = *tp1 };
1738 39600 : mel_func_arg varg2 = { .type = *tp2 };
1739 :
1740 39600 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 3, ret, arg1, arg2);
1741 39600 : 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 39600 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 3, ret, arg1, varg2);
1743 39600 : 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 39600 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 3, ret, varg1, arg2);
1745 39600 : 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 39600 : if (strcmp(cmps[f].op,"==")==0 || strcmp(cmps[f].op,"!=")==0) {
1748 13200 : mel_func_arg nil_matches = { .type = TYPE_bit };
1749 :
1750 13200 : 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 13200 : 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 13200 : 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 13200 : 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 13200 : 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 13200 : 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 1320 : for(int i = 0; i < 3 && !err; i++) {
1777 990 : int tp = specials[i];
1778 990 : mel_func_arg ret = { .type = TYPE_bte, .isbat =1 };
1779 990 : mel_func_arg arg = { .type = tp, .isbat =1 };
1780 990 : mel_func_arg varg = { .type = tp };
1781 :
1782 990 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 3, ret, arg, arg);
1783 990 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 5, ret, arg, arg, cand, cand);
1784 990 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 3, ret, arg, varg);
1785 990 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 4, ret, arg, varg, cand);
1786 990 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 3, ret, varg, arg);
1787 990 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 4, ret, varg, arg, cand);
1788 : }
1789 2640 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1790 18480 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1791 16170 : mel_func_arg ret = { .type = TYPE_bte, .isbat =1 };
1792 16170 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1793 16170 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1794 16170 : mel_func_arg varg1 = { .type = *tp1 };
1795 16170 : mel_func_arg varg2 = { .type = *tp2 };
1796 :
1797 16170 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 3, ret, arg1, arg2);
1798 16170 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 5, ret, arg1, arg2, cand, cand);
1799 16170 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 3, ret, arg1, varg2);
1800 16170 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 4, ret, arg1, varg2, cand);
1801 16170 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 3, ret, varg1, arg2);
1802 16170 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 4, ret, varg1, arg2, cand);
1803 : }
1804 : }
1805 2640 : for(tp = integer; tp < extra && !err; tp++) {
1806 2310 : mel_func_arg ret = { .type = TYPE_dbl };
1807 2310 : mel_func_arg nr = { .type = TYPE_lng };
1808 2310 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1809 2310 : mel_func_arg scale = { .type = TYPE_int };
1810 :
1811 2310 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average of non-nil values of B", 1, 2, ret, arg);
1812 2310 : 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 2310 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average and number of non-nil values of B", 2, 3, ret, nr, arg);
1814 2310 : 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 2310 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average of non-nil values of B", 1, 3, ret, arg, scale);
1816 2310 : 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 2310 : 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 2310 : 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 330 : struct {
1822 : int type;
1823 : char *name;
1824 : char *fname;
1825 : MALfcn fcn;
1826 330 : } 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 330 : int typeopslen = 10;
1883 : #else
1884 : int typeopslen = 9;
1885 : #endif
1886 3630 : for(int t = 0; t<typeopslen; t++) {
1887 : /* from any 2 string */
1888 3300 : mel_func_arg ret = { .type = typeops[t].type, .isbat =1 };
1889 3300 : if (strcmp(typeops[t].name, "str")==0) {
1890 330 : mel_func_arg arg = { .type = TYPE_any, .isbat =1 };
1891 :
1892 330 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 2, ret, arg);
1893 330 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 3, ret, arg, cand);
1894 : } else {
1895 32670 : for(int p = 0; p<typeopslen; p++) {
1896 29700 : mel_func_arg arg = { .type = typeops[p].type, .isbat =1 };
1897 :
1898 29700 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 2, ret, arg);
1899 29700 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 3, ret, arg, cand);
1900 : }
1901 : }
1902 : }
1903 330 : 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 323 : LIB_STARTUP_FUNC(init_batcalc_mal)
1975 323 : { mal_module2("batcalc", NULL, batcalc_init_funcs, &batcalc_init, NULL); }
|
