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 25 : mythrow(enum malexception type, const char *fcn, const char *msg)
20 : {
21 25 : char *errbuf = GDKerrbuf;
22 25 : char *s;
23 :
24 25 : if (errbuf && *errbuf) {
25 25 : if (strncmp(errbuf, "!ERROR: ", 8) == 0)
26 25 : errbuf += 8;
27 25 : if (strchr(errbuf, '!') == errbuf + 5) {
28 0 : s = createException(type, fcn, "%s", errbuf);
29 25 : } else if ((s = strchr(errbuf, ':')) != NULL && s[1] == ' ') {
30 25 : s = createException(type, fcn, "%s", s + 2);
31 : } else {
32 0 : s = createException(type, fcn, "%s", errbuf);
33 : }
34 25 : GDKclrerr();
35 25 : return s;
36 : }
37 0 : return createException(type, fcn, "%s", msg);
38 : }
39 :
40 : static str
41 17486 : CMDbatUNARY(MalStkPtr stk, InstrPtr pci,
42 : BAT *(*batfunc)(BAT *, BAT *), const char *malfunc)
43 : {
44 17486 : bat bid;
45 17486 : BAT *bn, *b, *s = NULL;
46 :
47 17486 : bid = *getArgReference_bat(stk, pci, 1);
48 17486 : if ((b = BATdescriptor(bid)) == NULL)
49 0 : throw(MAL, malfunc, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
50 17511 : 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 17511 : bn = (*batfunc) (b, s);
61 17466 : BBPunfix(b->batCacheid);
62 17502 : BBPreclaim(s);
63 17505 : if (bn == NULL) {
64 0 : return mythrow(MAL, malfunc, OPERATION_FAILED);
65 : }
66 17505 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
67 17505 : BBPkeepref(bn);
68 17505 : 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 3763 : CMDbatISNIL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
113 : {
114 3763 : (void) cntxt;
115 3763 : (void) mb;
116 :
117 3763 : return CMDbatUNARY(stk, pci, BATcalcisnil, "batcalc.isnil");
118 : }
119 :
120 : static str
121 4629 : CMDbatISNOTNIL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
122 : {
123 4629 : (void) cntxt;
124 4629 : (void) mb;
125 :
126 4629 : return CMDbatUNARY(stk, pci, BATcalcisnotnil, "batcalc.isnotnil");
127 : }
128 :
129 : static str
130 1017 : CMDbatNOT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
131 : {
132 1017 : (void) cntxt;
133 1017 : (void) mb;
134 :
135 1017 : return CMDbatUNARY(stk, pci, BATcalcnot, "batcalc.not");
136 : }
137 :
138 : static str
139 7840 : CMDbatABS(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
140 : {
141 7840 : (void) cntxt;
142 7840 : (void) mb;
143 :
144 7840 : 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 226 : CMDbatNEG(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
167 : {
168 226 : (void) cntxt;
169 226 : (void) mb;
170 :
171 226 : 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 255294 : 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 255294 : bat bid;
296 255294 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
297 255294 : int tp1, tp2, tp3;
298 :
299 255294 : tp1 = getArgType(mb, pci, 1); /*stk->stk[getArg(pci, 1)].vtype;*/ /* first argument */
300 255294 : tp2 = getArgType(mb, pci, 2); /*stk->stk[getArg(pci, 2)].vtype;*/ /* second argument */
301 255294 : tp3 = getArgType(mb, pci, 0); /* return argument */
302 255294 : assert(isaBatType(tp3));
303 255294 : tp3 = getBatType(tp3);
304 :
305 255294 : if (isaBatType(tp1)) {
306 254573 : bid = *getArgReference_bat(stk, pci, 1);
307 254573 : b1 = BATdescriptor(bid);
308 255555 : if (b1 == NULL)
309 0 : goto bailout;
310 : }
311 :
312 256276 : if (isaBatType(tp2)) {
313 96252 : bid = *getArgReference_bat(stk, pci, 2);
314 96252 : b2 = BATdescriptor(bid);
315 96266 : if (b2 == NULL)
316 0 : goto bailout;
317 : }
318 :
319 256290 : if (pci->argc > 4) {
320 95471 : assert(pci->argc == 5);
321 95471 : bid = *getArgReference_bat(stk, pci, 4);
322 95471 : if (!is_bat_nil(bid)) {
323 7081 : s2 = BATdescriptor(bid);
324 7081 : if (s2 == NULL)
325 0 : goto bailout;
326 : }
327 : }
328 256290 : if (pci->argc > 3) {
329 256291 : bid = *getArgReference_bat(stk, pci, 3);
330 256291 : if (!is_bat_nil(bid)) {
331 79038 : s1 = BATdescriptor(bid);
332 79073 : if (s1 == NULL)
333 0 : goto bailout;
334 79073 : if (b1 == NULL) {
335 24 : s2 = s1;
336 24 : s1 = NULL;
337 : }
338 : }
339 : }
340 :
341 256325 : if (b1 && b2) {
342 95453 : if (tp3 == TYPE_any)
343 0 : tp3 = (*typefunc) (b1->ttype, b2->ttype);
344 95453 : bn = (*batfunc) (b1, b2, s1, s2, tp3);
345 160872 : } else if (b1) {
346 160077 : if (tp3 == TYPE_any)
347 0 : tp3 = (*typefunc) (b1->ttype, tp2);
348 160077 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1, tp3);
349 795 : } else if (b2) {
350 795 : if (tp3 == TYPE_any)
351 0 : tp3 = (*typefunc) (tp1, b2->ttype);
352 795 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2, tp3);
353 : } else
354 0 : goto bailout; /* cannot happen */
355 255475 : BBPreclaim(b1);
356 256080 : BBPreclaim(b2);
357 256076 : BBPreclaim(s1);
358 256135 : BBPreclaim(s2);
359 256145 : if (bn == NULL)
360 8 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
361 256137 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
362 256137 : BBPkeepref(bn);
363 256137 : 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 546 : 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 546 : bat bid;
394 546 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
395 :
396 546 : if (stk->stk[getArg(pci, 1)].bat) {
397 546 : bid = *getArgReference_bat(stk, pci, 1);
398 546 : b1 = BATdescriptor(bid);
399 547 : if (b1 == NULL)
400 0 : goto bailout;
401 : }
402 :
403 547 : 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 547 : 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 547 : 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 547 : if (b1 && b2)
433 5 : bn = (*batfunc) (b1, b2, s1, s2);
434 542 : else if (b1)
435 541 : 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 547 : BBPreclaim(b1);
441 548 : BBPreclaim(b2);
442 547 : BBPreclaim(s1);
443 547 : BBPreclaim(s2);
444 547 : if (bn == NULL)
445 0 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
446 547 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
447 547 : BBPkeepref(bn);
448 547 : 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 108863 : 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 108863 : bat bid;
479 108863 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
480 :
481 108863 : if (stk->stk[getArg(pci, 1)].bat) {
482 108676 : bid = *getArgReference_bat(stk, pci, 1);
483 108676 : b1 = BATdescriptor(bid);
484 109072 : if (b1 == NULL)
485 0 : goto bailout;
486 : }
487 :
488 109259 : if (stk->stk[getArg(pci, 2)].bat) {
489 77117 : bid = *getArgReference_bat(stk, pci, 2);
490 77117 : b2 = BATdescriptor(bid);
491 77129 : if (b2 == NULL)
492 0 : goto bailout;
493 : }
494 :
495 109271 : if (pci->argc > 5) {
496 6 : assert(pci->argc == 6);
497 6 : nil_matches = *getArgReference_bit(stk, pci, 5);
498 : }
499 109271 : if (pci->argc > 4) {
500 1261 : if (stk->stk[getArg(pci, 4)].bat) {
501 1261 : bid = *getArgReference_bat(stk, pci, 4);
502 1261 : if (!is_bat_nil(bid)) {
503 168 : 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 109273 : if (pci->argc > 3) {
513 36304 : if (stk->stk[getArg(pci, 3)].bat) {
514 22980 : bid = *getArgReference_bat(stk, pci, 3);
515 22980 : if (!is_bat_nil(bid)) {
516 22508 : s1 = BATdescriptor(bid);
517 22534 : if (s1 == NULL)
518 0 : goto bailout;
519 22534 : if (b1 == NULL) {
520 79 : s2 = s1;
521 79 : s1 = NULL;
522 : }
523 : }
524 : } else {
525 13324 : assert(pci->argc == 4);
526 13324 : nil_matches = *getArgReference_bit(stk, pci, 3);
527 : }
528 : }
529 :
530 109299 : if (b1 && b2)
531 76777 : bn = (*batfunc) (b1, b2, s1, s2, nil_matches);
532 32522 : else if (b1)
533 32230 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1, nil_matches);
534 292 : else if (b2)
535 292 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2, nil_matches);
536 : else
537 0 : goto bailout; /* cannot happen */
538 109258 : BBPreclaim(b1);
539 109202 : BBPreclaim(b2);
540 109269 : BBPreclaim(s1);
541 109285 : BBPreclaim(s2);
542 109263 : if (bn == NULL)
543 0 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
544 109263 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
545 109263 : BBPkeepref(bn);
546 109263 : 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 85336 : 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 85336 : bat bid;
568 85336 : BAT *bn, *b1 = NULL, *b2 = NULL, *s1 = NULL, *s2 = NULL;
569 :
570 85336 : if (stk->stk[getArg(pci, 1)].bat) {
571 85206 : bid = *getArgReference_bat(stk, pci, 1);
572 85206 : b1 = BATdescriptor(bid);
573 85687 : if (b1 == NULL)
574 0 : goto bailout;
575 : }
576 :
577 85817 : if (stk->stk[getArg(pci, 2)].bat) {
578 82756 : bid = *getArgReference_bat(stk, pci, 2);
579 82756 : b2 = BATdescriptor(bid);
580 82728 : if (b2 == NULL)
581 0 : goto bailout;
582 : }
583 :
584 85789 : if (pci->argc > 4) {
585 19548 : assert(pci->argc == 5);
586 19548 : bid = *getArgReference_bat(stk, pci, 4);
587 19548 : if (!is_bat_nil(bid)) {
588 4328 : s2 = BATdescriptor(bid);
589 4327 : if (s2 == NULL)
590 0 : goto bailout;
591 : }
592 : }
593 85788 : if (pci->argc > 3) {
594 19930 : bid = *getArgReference_bat(stk, pci, 3);
595 19930 : if (!is_bat_nil(bid)) {
596 15206 : s1 = BATdescriptor(bid);
597 15208 : if (s1 == NULL)
598 0 : goto bailout;
599 15208 : if (b1 == NULL) {
600 1 : s2 = s1;
601 1 : s1 = NULL;
602 : }
603 : }
604 : }
605 :
606 85790 : if (b1 && b2)
607 82599 : bn = (*batfunc) (b1, b2, s1, s2);
608 3191 : else if (b1)
609 3063 : bn = (*batfunc1) (b1, &stk->stk[getArg(pci, 2)], s1);
610 128 : else if (b2)
611 128 : bn = (*batfunc2) (&stk->stk[getArg(pci, 1)], b2, s2);
612 : else
613 0 : goto bailout; /* cannot happen */
614 85386 : BBPreclaim(b1);
615 85726 : BBPreclaim(b2);
616 85681 : BBPreclaim(s1);
617 85704 : BBPreclaim(s2);
618 85754 : if (bn == NULL)
619 2 : return mythrow(MAL, malfunc, GDK_EXCEPTION);
620 85752 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
621 85752 : BBPkeepref(bn);
622 85752 : 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 126472 : CMDbatADDsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
676 : {
677 126472 : (void) cntxt;
678 :
679 126472 : return CMDbatBINARY2(mb, stk, pci, BATcalcadd, BATcalcaddcst, BATcalccstadd,
680 : calctype, "batcalc.+");
681 : }
682 :
683 : static str
684 29905 : CMDbatADDenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
685 : {
686 29905 : (void) cntxt;
687 :
688 29905 : return CMDbatBINARY2(mb, stk, pci, BATcalcadd, BATcalcaddcst, BATcalccstadd,
689 : calctypeenlarge, "batcalc.add_enlarge");
690 : }
691 :
692 : static str
693 23142 : CMDbatSUBsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
694 : {
695 23142 : (void) cntxt;
696 :
697 23142 : return CMDbatBINARY2(mb, stk, pci, BATcalcsub, BATcalcsubcst, BATcalccstsub,
698 : calctype, "batcalc.-");
699 : }
700 :
701 : static str
702 25599 : CMDbatSUBenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
703 : {
704 25599 : (void) cntxt;
705 :
706 25599 : return CMDbatBINARY2(mb, stk, pci, BATcalcsub, BATcalcsubcst, BATcalccstsub,
707 : calctypeenlarge, "batcalc.sub_enlarge");
708 : }
709 :
710 : static str
711 31154 : CMDbatMULsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
712 : {
713 31154 : (void) cntxt;
714 :
715 31154 : return CMDbatBINARY2(mb, stk, pci, BATcalcmul, BATcalcmulcst, BATcalccstmul,
716 : calctype, "batcalc.*");
717 : }
718 :
719 : static str
720 13933 : CMDbatMULenlarge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
721 : {
722 13933 : (void) cntxt;
723 :
724 13933 : return CMDbatBINARY2(mb, stk, pci, BATcalcmul, BATcalcmulcst, BATcalccstmul,
725 : calctypeenlarge, "batcalc.mul_enlarge");
726 : }
727 :
728 : static str
729 5056 : CMDbatDIVsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
730 : {
731 5056 : (void) cntxt;
732 :
733 5056 : return CMDbatBINARY2(mb, stk, pci, BATcalcdiv, BATcalcdivcst, BATcalccstdiv,
734 : calcdivtype, "batcalc./");
735 : }
736 :
737 : static str
738 621 : CMDbatMODsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
739 : {
740 621 : (void) cntxt;
741 :
742 621 : return CMDbatBINARY2(mb, stk, pci, BATcalcmod, BATcalcmodcst, BATcalccstmod,
743 : calcmodtype, "batcalc.%");
744 : }
745 :
746 : static str
747 16 : CMDbatXOR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
748 : {
749 16 : (void) cntxt;
750 16 : (void) mb;
751 :
752 16 : return CMDbatBINARY0(stk, pci, BATcalcxor, BATcalcxorcst, BATcalccstxor,
753 : "batcalc.xor");
754 : }
755 :
756 : static str
757 5424 : CMDbatOR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
758 : {
759 5424 : (void) cntxt;
760 5424 : (void) mb;
761 :
762 5424 : return CMDbatBINARY0(stk, pci, BATcalcor, BATcalcorcst, BATcalccstor,
763 : "batcalc.or");
764 : }
765 :
766 : static str
767 10228 : CMDbatAND(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
768 : {
769 10228 : (void) cntxt;
770 10228 : (void) mb;
771 :
772 10228 : 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 545 : CMDbatRSHsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
788 : {
789 545 : (void) cntxt;
790 545 : (void) mb;
791 :
792 545 : return CMDbatBINARY1(stk, pci, BATcalcrsh, BATcalcrshcst, BATcalccstrsh,
793 : "batcalc.>>");
794 : }
795 :
796 : static str
797 15202 : CMDbatLT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
798 : {
799 15202 : (void) cntxt;
800 15202 : (void) mb;
801 :
802 15202 : return CMDbatBINARY0(stk, pci, BATcalclt, BATcalcltcst, BATcalccstlt,
803 : "batcalc.<");
804 : }
805 :
806 : static str
807 10168 : CMDbatLE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
808 : {
809 10168 : (void) cntxt;
810 10168 : (void) mb;
811 :
812 10168 : return CMDbatBINARY0(stk, pci, BATcalcle, BATcalclecst, BATcalccstle,
813 : "batcalc.<=");
814 : }
815 :
816 : static str
817 37944 : CMDbatGT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
818 : {
819 37944 : (void) cntxt;
820 37944 : (void) mb;
821 :
822 37944 : return CMDbatBINARY0(stk, pci, BATcalcgt, BATcalcgtcst, BATcalccstgt,
823 : "batcalc.>");
824 : }
825 :
826 : static str
827 5994 : CMDbatGE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
828 : {
829 5994 : (void) cntxt;
830 5994 : (void) mb;
831 :
832 5994 : return CMDbatBINARY0(stk, pci, BATcalcge, BATcalcgecst, BATcalccstge,
833 : "batcalc.>=");
834 : }
835 :
836 : static str
837 107330 : CMDbatEQ(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
838 : {
839 107330 : (void) cntxt;
840 107330 : (void) mb;
841 :
842 107330 : return CMDbatBINARY1a(stk, pci, BATcalceq, BATcalceqcst, BATcalccsteq,
843 : false, "batcalc.==");
844 : }
845 :
846 : static str
847 1712 : CMDbatNE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
848 : {
849 1712 : (void) cntxt;
850 1712 : (void) mb;
851 :
852 1712 : 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 25352 : CMDbatBETWEEN(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
868 : {
869 25352 : bat bid;
870 25352 : BAT *bn, *b = NULL, *lo = NULL, *hi = NULL, *s = NULL, *slo = NULL,
871 25352 : *shi = NULL;
872 25352 : int tp1, tp2, tp3, tp;
873 25352 : int bc = 0; /* number of extra BAT arguments */
874 25352 : bool symmetric, linc, hinc, nils_false, anti, has_cand = false;
875 :
876 25352 : (void) cntxt;
877 25352 : (void) mb;
878 :
879 25352 : tp1 = getArgType(mb, pci, 1);
880 25352 : tp2 = getArgType(mb, pci, 2);
881 25352 : tp3 = getArgType(mb, pci, 3);
882 25352 : if (!isaBatType(tp1))
883 0 : goto bailout;
884 25352 : bid = *getArgReference_bat(stk, pci, 1);
885 25352 : b = BATdescriptor(bid);
886 25380 : if (b == NULL)
887 0 : goto bailout;
888 25380 : if (isaBatType(tp2)) {
889 25216 : bid = *getArgReference_bat(stk, pci, 2);
890 25216 : lo = BATdescriptor(bid);
891 25232 : if (lo == NULL)
892 0 : goto bailout;
893 : }
894 25396 : if (isaBatType(tp3)) {
895 25209 : bid = *getArgReference_bat(stk, pci, 3);
896 25209 : hi = BATdescriptor(bid);
897 25208 : if (hi == NULL)
898 0 : goto bailout;
899 : }
900 25395 : tp = getArgType(mb, pci, 4);
901 25395 : if (isaBatType(tp)) {
902 11575 : bid = *getArgReference_bat(stk, pci, 4);
903 11575 : has_cand = true;
904 11575 : if (!is_bat_nil(bid)) {
905 1397 : s = BATdescriptor(bid);
906 1397 : if (s == NULL)
907 0 : goto bailout;
908 : }
909 : bc++;
910 : }
911 25395 : if (has_cand && lo) {
912 11455 : tp = getArgType(mb, pci, 4 + bc);
913 11455 : if (isaBatType(tp)) {
914 11455 : bid = *getArgReference_bat(stk, pci, 4 + bc);
915 11455 : if (!is_bat_nil(bid)) {
916 1826 : slo = BATdescriptor(bid);
917 1827 : if (slo == NULL)
918 0 : goto bailout;
919 : }
920 11456 : 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 25396 : if (has_cand && hi) {
931 11421 : tp = getArgType(mb, pci, 4 + bc);
932 11421 : if (!isaBatType(tp))
933 0 : goto bailout;
934 11421 : bid = *getArgReference_bat(stk, pci, 4 + bc);
935 11421 : if (!is_bat_nil(bid)) {
936 859 : shi = BATdescriptor(bid);
937 860 : if (shi == NULL)
938 0 : goto bailout;
939 : }
940 11422 : bc++;
941 : }
942 :
943 25397 : symmetric = *getArgReference_bit(stk, pci, bc + 4);
944 25397 : linc = *getArgReference_bit(stk, pci, bc + 5);
945 25397 : hinc = *getArgReference_bit(stk, pci, bc + 6);
946 25397 : nils_false = *getArgReference_bit(stk, pci, bc + 7);
947 25397 : anti = *getArgReference_bit(stk, pci, bc + 8);
948 :
949 25397 : if (b && lo && hi)
950 25124 : bn = BATcalcbetween(b, lo, hi, s, slo, shi,
951 : symmetric, linc, hinc, nils_false, anti);
952 273 : else if (b && lo)
953 69 : bn = BATcalcbetweenbatcst(b, lo, &stk->stk[getArg(pci, 3)], s, slo,
954 : symmetric, linc, hinc, nils_false, anti);
955 204 : 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 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 25304 : BBPunfix(b->batCacheid);
963 25404 : BBPreclaim(lo);
964 25422 : BBPreclaim(hi);
965 25408 : BBPreclaim(s);
966 25411 : BBPreclaim(slo);
967 25422 : 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 7983 : CMDcalcavg(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
988 : {
989 7983 : dbl avg;
990 7983 : BUN vals;
991 7983 : bat bid;
992 7983 : BAT *b, *s = NULL;
993 7983 : gdk_return ret;
994 7983 : int scale = 0;
995 :
996 7983 : (void) cntxt;
997 7983 : (void) mb;
998 :
999 7983 : bid = *getArgReference_bat(stk, pci, pci->retc + 0);
1000 7983 : if ((b = BATdescriptor(bid)) == NULL)
1001 0 : throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1002 7987 : if ((pci->argc == pci->retc + 2 &&
1003 0 : stk->stk[pci->argv[pci->retc + 1]].bat) ||
1004 7987 : 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 7987 : 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 7987 : ret = BATcalcavg(b, s, &avg, &vals, scale);
1016 7987 : BBPunfix(b->batCacheid);
1017 7985 : BBPreclaim(s);
1018 7986 : if (ret != GDK_SUCCEED)
1019 0 : return mythrow(MAL, "aggr.avg", OPERATION_FAILED);
1020 7986 : *getArgReference_dbl(stk, pci, 0) = avg;
1021 7986 : if (pci->retc == 2)
1022 7940 : *getArgReference_lng(stk, pci, 1) = vals;
1023 : return MAL_SUCCEED;
1024 : }
1025 :
1026 : static str
1027 81311 : CMDconvertbat(MalStkPtr stk, InstrPtr pci, int tp)
1028 : {
1029 81311 : bat bid;
1030 81311 : BAT *b, *bn, *s = NULL;
1031 :
1032 81311 : bid = *getArgReference_bat(stk, pci, 1);
1033 81311 : if ((b = BATdescriptor(bid)) == NULL)
1034 0 : throw(MAL, "batcalc.convert", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1035 81486 : if (pci->argc == 3) {
1036 80420 : bid = *getArgReference_bat(stk, pci, 2);
1037 80420 : 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 17105 : 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 81489 : bn = BATconvert(b, s, tp, 0, 0, 0);
1050 81225 : BBPunfix(b->batCacheid);
1051 81451 : BBPreclaim(s);
1052 81416 : 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 81401 : *getArgReference_bat(stk, pci, 0) = bn->batCacheid;
1058 81401 : BBPkeepref(bn);
1059 81401 : return MAL_SUCCEED;
1060 : }
1061 :
1062 : static str
1063 297 : CMDconvertsignal_bit(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1064 : {
1065 297 : (void) cntxt;
1066 297 : (void) mb;
1067 :
1068 297 : return CMDconvertbat(stk, pci, TYPE_bit);
1069 : }
1070 :
1071 : static str
1072 149 : CMDconvertsignal_bte(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1073 : {
1074 149 : (void) cntxt;
1075 149 : (void) mb;
1076 :
1077 149 : return CMDconvertbat(stk, pci, TYPE_bte);
1078 : }
1079 :
1080 : static str
1081 8171 : CMDconvertsignal_sht(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1082 : {
1083 8171 : (void) cntxt;
1084 8171 : (void) mb;
1085 :
1086 8171 : return CMDconvertbat(stk, pci, TYPE_sht);
1087 : }
1088 :
1089 : static str
1090 10243 : CMDconvertsignal_int(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1091 : {
1092 10243 : (void) cntxt;
1093 10243 : (void) mb;
1094 :
1095 10243 : return CMDconvertbat(stk, pci, TYPE_int);
1096 : }
1097 :
1098 : static str
1099 59225 : CMDconvertsignal_lng(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1100 : {
1101 59225 : (void) cntxt;
1102 59225 : (void) mb;
1103 :
1104 59225 : return CMDconvertbat(stk, pci, TYPE_lng);
1105 : }
1106 :
1107 : #ifdef HAVE_HGE
1108 :
1109 : static str
1110 165 : CMDconvertsignal_hge(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1111 : {
1112 165 : (void) cntxt;
1113 165 : (void) mb;
1114 :
1115 165 : return CMDconvertbat(stk, pci, TYPE_hge);
1116 : }
1117 : #endif
1118 :
1119 : static str
1120 268 : CMDconvertsignal_flt(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1121 : {
1122 268 : (void) cntxt;
1123 268 : (void) mb;
1124 :
1125 268 : return CMDconvertbat(stk, pci, TYPE_flt);
1126 : }
1127 :
1128 : static str
1129 2629 : CMDconvertsignal_dbl(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1130 : {
1131 2629 : (void) cntxt;
1132 2629 : (void) mb;
1133 :
1134 2629 : 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 184 : CMDconvertsignal_str(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1148 : {
1149 184 : (void) cntxt;
1150 184 : (void) mb;
1151 :
1152 184 : return CMDconvertbat(stk, pci, TYPE_str);
1153 : }
1154 :
1155 : static str
1156 4284 : CMDifthen(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1157 : {
1158 4284 : BAT *b = NULL, *b1 = NULL, *b2 = NULL, *bn;
1159 4284 : int tp0, tp1, tp2;
1160 4284 : bat *ret;
1161 4284 : BUN cnt = BUN_NONE;
1162 :
1163 4284 : (void) cntxt;
1164 :
1165 4284 : if (pci->argc != 4)
1166 0 : throw(MAL, "batcalc.ifthen", "Operation not supported.");
1167 :
1168 4284 : ret = getArgReference_bat(stk, pci, 0);
1169 4284 : tp0 = stk->stk[getArg(pci, 1)].vtype;
1170 4284 : tp1 = getArgType(mb, pci, 2);
1171 4284 : tp2 = getArgType(mb, pci, 3);
1172 4284 : if (stk->stk[getArg(pci, 1)].bat) {
1173 4285 : b = BATdescriptor(*getArgReference_bat(stk, pci, 1));
1174 4289 : if (b == NULL)
1175 0 : throw(MAL, "batcalc.ifthenelse",
1176 : SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
1177 4289 : cnt = BATcount(b);
1178 : }
1179 4288 : if (isaBatType(tp1)) {
1180 267 : 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 4290 : if (isaBatType(tp2)) {
1194 2846 : b2 = BATdescriptor(*getArgReference_bat(stk, pci, 3));
1195 2846 : 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 2846 : if (cnt == BUN_NONE)
1202 4290 : cnt = BATcount(b2);
1203 2846 : else if (BATcount(b2) != cnt) {
1204 0 : BBPreclaim(b);
1205 0 : BBPreclaim(b1);
1206 0 : throw(MAL, "batcalc.ifthenelse", ILLEGAL_ARGUMENT);
1207 : }
1208 : }
1209 4290 : if (b == NULL && b1 == NULL && b2 == NULL) {
1210 : /* at least one BAT required */
1211 0 : throw(MAL, "batcalc.ifthenelse", ILLEGAL_ARGUMENT);
1212 : }
1213 4290 : if (b != NULL) {
1214 4290 : 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 4021 : if (b2 != NULL) {
1222 2773 : bn = BATcalcifthencstelse(b, &stk->stk[getArg(pci, 2)], b2);
1223 : } else {
1224 1248 : bn = BATcalcifthencstelsecst(b, &stk->stk[getArg(pci, 2)],
1225 1248 : &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 4288 : BBPreclaim(b);
1258 4292 : BBPreclaim(b1);
1259 4291 : BBPreclaim(b2);
1260 4292 : if (bn == NULL) {
1261 0 : return mythrow(MAL, "batcalc.ifthenelse", OPERATION_FAILED);
1262 : }
1263 4292 : *ret = bn->batCacheid;
1264 4292 : BBPkeepref(bn);
1265 4292 : return MAL_SUCCEED;
1266 : }
1267 :
1268 : #include "mel.h"
1269 :
1270 : static str
1271 315 : batcalc_init(void)
1272 : {
1273 315 : int types[16], cur = 0, *tp;
1274 315 : int specials[4];
1275 315 : int *integer, *floats, *extra;
1276 :
1277 315 : types[cur++] = TYPE_bit;
1278 315 : integer = types+cur;
1279 315 : types[cur++] = TYPE_bte;
1280 315 : types[cur++] = TYPE_sht;
1281 315 : types[cur++] = TYPE_int;
1282 315 : types[cur++] = TYPE_lng;
1283 : #ifdef HAVE_HGE
1284 315 : types[cur++] = TYPE_hge;
1285 : #endif
1286 315 : floats = types+cur;
1287 315 : types[cur++] = TYPE_flt;
1288 315 : types[cur++] = TYPE_dbl;
1289 315 : extra = types+cur;
1290 315 : types[cur++] = TYPE_oid;
1291 315 : types[cur++] = TYPE_str;
1292 :
1293 315 : cur = 0;
1294 315 : specials[cur++] = TYPE_bit;
1295 315 : specials[cur++] = TYPE_oid;
1296 315 : specials[cur++] = TYPE_str;
1297 :
1298 315 : mel_func_arg cand = { .type = TYPE_oid, .isbat=1 };
1299 :
1300 315 : int err=0;
1301 : /* for all numeric types, use reverse order */
1302 2520 : for(tp = integer; tp < extra && !err; tp++) {
1303 2205 : mel_func_arg ret = { .type = TYPE_bit, .isbat=1 };
1304 2205 : mel_func_arg arg = { .type = *tp, .isbat=1 };
1305 :
1306 2205 : err += melFunction(false, "batcalc", "iszero", (MALfcn)&CMDbatISZERO, "CMDbatISZERO", false, "Unary check for zero over the tail of the bat", 1, 2, ret, arg);
1307 2205 : 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 2835 : for(tp = types; tp < extra && !err; tp++) { /* bit + numeric */
1310 2520 : mel_func_arg ret = { .type = *tp, .isbat =1 };
1311 2520 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1312 :
1313 2520 : err += melFunction(false, "batcalc", "not", (MALfcn)&CMDbatNOT, "CMDbatNOT", false, "Unary bitwise not over the tail of the bat", 1, 2, ret, arg);
1314 2520 : 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 2520 : for(tp = integer; tp < extra && !err; tp++) {
1317 2205 : mel_func_arg ret = { .type = TYPE_bte, .isbat =1 };
1318 2205 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1319 :
1320 2205 : 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 2205 : 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 2520 : for(tp = integer; tp < extra && !err; tp++) {
1324 2205 : mel_func_arg ret = { .type = *tp, .isbat =1 };
1325 2205 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1326 :
1327 2205 : err += melFunction(false, "batcalc", "abs", (MALfcn)&CMDbatABS, "CMDbatABS", false, "Unary abs over the tail of the bat", 1, 2, ret, arg);
1328 2205 : 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 2205 : err += melFunction(false, "batcalc", "-", (MALfcn)&CMDbatNEG, "CMDbatNEG", false, "Unary neg over the tail of the bat", 1, 2, ret, arg);
1331 2205 : 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 2205 : err += melFunction(false, "batcalc", "++", (MALfcn)&CMDbatINCR, "CMDbatINCR", false, "Unary increment over the tail of the bat", 1, 2, ret, arg);
1334 2205 : 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 2205 : err += melFunction(false, "batcalc", "--", (MALfcn)&CMDbatDECR, "CMDbatDECR", false, "Unary decrement over the tail of the bat", 1, 2, ret, arg);
1337 2205 : 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 315 : 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 315 : } 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 1260 : for (int f=0; f<3; f++) {
1393 : int *tp1, *tp2, *rt;
1394 7560 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1395 52920 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1396 370440 : for(rt = extra-1; rt >= integer && !err; rt--) {
1397 324135 : if (f!=3 && (*rt < *tp1 || *rt < *tp2))
1398 191835 : continue;
1399 132300 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1400 132300 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1401 132300 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1402 132300 : mel_func_arg varg1 = { .type = *tp1 };
1403 132300 : mel_func_arg varg2 = { .type = *tp2 };
1404 :
1405 132300 : if (*rt == *tp1 || *rt == *tp2 || f==3) {
1406 46305 : 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 46305 : 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 46305 : 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 85995 : 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 85995 : 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 85995 : 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 1890 : for(tp1 = integer; tp1 < floats && !err; tp1++) {
1421 4725 : for(tp2 = floats; tp2 < extra && !err; tp2++) {
1422 18900 : for(tp3 = integer; tp3 < floats && !err; tp3++) {
1423 15750 : int in1 = *tp3, in2 = *tp2;
1424 :
1425 47250 : for (int i = 0 ; i < 2 ; i++) {
1426 31500 : mel_func_arg ret = { .type = *tp1, .isbat =1 };
1427 31500 : mel_func_arg arg1 = { .type = in1, .isbat =1 };
1428 31500 : mel_func_arg arg2 = { .type = in2, .isbat =1 };
1429 31500 : mel_func_arg varg1 = { .type = in1 };
1430 31500 : mel_func_arg varg2 = { .type = in2 };
1431 :
1432 31500 : 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 31500 : 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 31500 : 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 31500 : in1 ^= in2;
1438 31500 : in2 ^= in1;
1439 31500 : in1 ^= in2;
1440 : }
1441 : }
1442 : }
1443 : }
1444 : }
1445 315 : 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 315 : } 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 315 : int *tp1, *tp2, *rt;
1466 2520 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1467 17640 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1468 77175 : for(rt = extra-1; rt >= tp1 && !err; rt--) {
1469 61740 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1470 61740 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1471 61740 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1472 61740 : mel_func_arg varg1 = { .type = *tp1 };
1473 61740 : mel_func_arg varg2 = { .type = *tp2 };
1474 :
1475 61740 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment, 1, 5, ret, arg1, arg2, cand, cand);
1476 61740 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment_v, 1, 4, ret, arg1, varg2, cand);
1477 61740 : 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 945 : for(tp1 = floats; tp1 < extra && !err; tp1++) {
1483 3780 : for(tp2 = integer; tp2 < floats && !err; tp2++) {
1484 18900 : for(rt = integer; rt < floats && !err; rt++) {
1485 15750 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1486 15750 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1487 15750 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1488 15750 : mel_func_arg varg1 = { .type = *tp1 };
1489 15750 : mel_func_arg varg2 = { .type = *tp2 };
1490 :
1491 15750 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment, 1, 5, ret, arg1, arg2, cand, cand);
1492 15750 : err += melFunction(false, "batcalc", div.op, div.fcn, div.fname, false, div.comment_v, 1, 4, ret, arg1, varg2, cand);
1493 15750 : 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 2520 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1513 17640 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1514 123480 : for(rt = extra-1; rt >= integer && !err; rt--) {
1515 108045 : if (rt < tp1 && rt < tp2)
1516 77490 : continue;
1517 79380 : if (*rt == TYPE_dbl) {
1518 15435 : if (*tp1 != TYPE_dbl || *tp2 != TYPE_dbl)
1519 15120 : continue;
1520 63945 : } else if (*rt == TYPE_flt) {
1521 15120 : if (*tp1 != TYPE_flt || *tp2 != TYPE_flt)
1522 14805 : continue;
1523 : } else {
1524 48825 : if (*tp1 == TYPE_flt || *tp2 == TYPE_flt || *tp1 == TYPE_dbl || *tp2 == TYPE_dbl)
1525 18900 : continue;
1526 : }
1527 30555 : mel_func_arg ret = { .type = *rt, .isbat =1 };
1528 30555 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1529 30555 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1530 30555 : mel_func_arg varg1 = { .type = *tp1 };
1531 30555 : mel_func_arg varg2 = { .type = *tp2 };
1532 :
1533 30555 : err += melFunction(false, "batcalc", mods.op, mods.fcn, mods.fname, false, mods.comment, 1, 5, ret, arg1, arg2, cand, cand);
1534 30555 : err += melFunction(false, "batcalc", mods.op, mods.fcn, mods.fname, false, mods.comment_v, 1, 4, ret, arg1, varg2, cand);
1535 30555 : err += melFunction(false, "batcalc", mods.op, mods.fcn, mods.fname, false, mods.comment_v_, 1, 4, ret, varg1, arg2, cand);
1536 : }
1537 : }
1538 : }
1539 315 : struct {
1540 : char *op;
1541 : char *fname;
1542 : MALfcn fcn;
1543 : char *comment;
1544 : char *comment_v;
1545 : char *comment_v_;
1546 315 : } 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 1260 : for (int f=0; f<3; f++) {
1571 8505 : for(tp = types+0; tp < extra && !err; tp++) {
1572 7560 : mel_func_arg ret = { .type = *tp, .isbat =1 };
1573 7560 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1574 7560 : mel_func_arg varg = { .type = *tp };
1575 :
1576 7560 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment, 1, 3, ret, arg, arg);
1577 7560 : 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 7560 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment_v, 1, 3, ret, arg, varg);
1579 7560 : 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 7560 : err += melFunction(false, "batcalc", logops[f].op, logops[f].fcn, logops[f].fname, false, logops[f].comment_v_, 1, 3, ret, varg, arg);
1581 7560 : 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 315 : struct {
1585 : char *op;
1586 : char *fname;
1587 : MALfcn fcn;
1588 : char *comment;
1589 : char *comment_v;
1590 : char *comment_v_;
1591 315 : } 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 945 : for (int f=0; f<2; f++) {
1609 : int *tp1, *tp2;
1610 3780 : for(tp1 = integer; tp1 < floats && !err; tp1++) {
1611 18900 : for(tp2 = integer; tp2 < floats && !err; tp2++) {
1612 15750 : mel_func_arg ret = { .type = *tp1, .isbat =1 };
1613 15750 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1614 15750 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1615 15750 : mel_func_arg varg1 = { .type = *tp1 };
1616 15750 : mel_func_arg varg2 = { .type = *tp2 };
1617 :
1618 15750 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment, 1, 3, ret, arg1, arg2);
1619 15750 : 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 15750 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment_v, 1, 3, ret, arg1, varg2);
1621 15750 : 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 15750 : err += melFunction(false, "batcalc", shifts[f].op, shifts[f].fcn, shifts[f].fname, false, shifts[f].comment_v_, 1, 3, ret, varg1, arg2);
1623 15750 : 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 315 : struct {
1629 : char *op;
1630 : char *fname;
1631 : MALfcn fcn;
1632 : char *comment;
1633 : char *comment_v;
1634 : char *comment_v_;
1635 315 : } 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 315 : int newtypes[6] = { ATOMindex("json"), ATOMindex("inet"), ATOMindex("uuid"), TYPE_date, TYPE_daytime, TYPE_timestamp };
1681 2205 : for (int f=0; f<6; f++) {
1682 1890 : mel_func_arg ret = { .type = TYPE_bit, .isbat =1 };
1683 1890 : mel_func_arg arg = { .type = TYPE_any, .isbat =1, .nr=1 };
1684 1890 : mel_func_arg varg = { .type = TYPE_any, .nr=1 };
1685 :
1686 1890 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 3, ret, arg, arg);
1687 1890 : 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 1890 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 3, ret, arg, varg);
1689 1890 : 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 1890 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 3, ret, varg, arg);
1691 1890 : 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 1890 : if (strcmp(cmps[f].op,"==")==0 || strcmp(cmps[f].op,"!=")==0) {
1694 630 : mel_func_arg nil_matches = { .type = TYPE_bit };
1695 :
1696 630 : 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 630 : 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 630 : 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 630 : 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 630 : 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 630 : 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 13230 : for (int nt = 0; nt < 6; nt++) {
1706 11340 : mel_func_arg ret = { .type = TYPE_bit, .isbat =1 };
1707 11340 : mel_func_arg arg = { .type = newtypes[nt], .isbat =1, .nr=1 };
1708 11340 : mel_func_arg varg = { .type = newtypes[nt], .nr=1 };
1709 :
1710 11340 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 3, ret, arg, arg);
1711 11340 : 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 11340 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 3, ret, arg, varg);
1713 11340 : 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 11340 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 3, ret, varg, arg);
1715 11340 : 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 11340 : if (strcmp(cmps[f].op,"==")==0 || strcmp(cmps[f].op,"!=")==0) {
1718 3780 : mel_func_arg nil_matches = { .type = TYPE_bit };
1719 :
1720 3780 : 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 3780 : 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 3780 : 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 3780 : 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 3780 : 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 3780 : 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 11340 : for(tp1 = integer; tp1 < floats && !err; tp1++) {
1731 56700 : for(tp2 = integer; tp2 < floats && !err; tp2++) {
1732 47250 : if (*tp1 == *tp2)
1733 9450 : continue;
1734 37800 : mel_func_arg ret = { .type = TYPE_bit, .isbat =1 };
1735 37800 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1736 37800 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1737 37800 : mel_func_arg varg1 = { .type = *tp1 };
1738 37800 : mel_func_arg varg2 = { .type = *tp2 };
1739 :
1740 37800 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment, 1, 3, ret, arg1, arg2);
1741 37800 : 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 37800 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v, 1, 3, ret, arg1, varg2);
1743 37800 : 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 37800 : err += melFunction(false, "batcalc", cmps[f].op, cmps[f].fcn, cmps[f].fname, false, cmps[f].comment_v_, 1, 3, ret, varg1, arg2);
1745 37800 : 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 37800 : if (strcmp(cmps[f].op,"==")==0 || strcmp(cmps[f].op,"!=")==0) {
1748 12600 : mel_func_arg nil_matches = { .type = TYPE_bit };
1749 :
1750 12600 : 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 12600 : 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 12600 : 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 12600 : 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 12600 : 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 12600 : 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 1260 : for(int i = 0; i < 3 && !err; i++) {
1777 945 : int tp = specials[i];
1778 945 : mel_func_arg ret = { .type = TYPE_bte, .isbat =1 };
1779 945 : mel_func_arg arg = { .type = tp, .isbat =1 };
1780 945 : mel_func_arg varg = { .type = tp };
1781 :
1782 945 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 3, ret, arg, arg);
1783 945 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 5, ret, arg, arg, cand, cand);
1784 945 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 3, ret, arg, varg);
1785 945 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 4, ret, arg, varg, cand);
1786 945 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 3, ret, varg, arg);
1787 945 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 4, ret, varg, arg, cand);
1788 : }
1789 2520 : for(tp1 = integer; tp1 < extra && !err; tp1++) {
1790 17640 : for(tp2 = integer; tp2 < extra && !err; tp2++) {
1791 15435 : mel_func_arg ret = { .type = TYPE_bte, .isbat =1 };
1792 15435 : mel_func_arg arg1 = { .type = *tp1, .isbat =1 };
1793 15435 : mel_func_arg arg2 = { .type = *tp2, .isbat =1 };
1794 15435 : mel_func_arg varg1 = { .type = *tp1 };
1795 15435 : mel_func_arg varg2 = { .type = *tp2 };
1796 :
1797 15435 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 3, ret, arg1, arg2);
1798 15435 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment, 1, 5, ret, arg1, arg2, cand, cand);
1799 15435 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 3, ret, arg1, varg2);
1800 15435 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v, 1, 4, ret, arg1, varg2, cand);
1801 15435 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 3, ret, varg1, arg2);
1802 15435 : err += melFunction(false, "batcalc", cmp.op, cmp.fcn, cmp.fname, false, cmp.comment_v_, 1, 4, ret, varg1, arg2, cand);
1803 : }
1804 : }
1805 2520 : for(tp = integer; tp < extra && !err; tp++) {
1806 2205 : mel_func_arg ret = { .type = TYPE_dbl };
1807 2205 : mel_func_arg nr = { .type = TYPE_lng };
1808 2205 : mel_func_arg arg = { .type = *tp, .isbat =1 };
1809 2205 : mel_func_arg scale = { .type = TYPE_int };
1810 :
1811 2205 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average of non-nil values of B", 1, 2, ret, arg);
1812 2205 : 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 2205 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average and number of non-nil values of B", 2, 3, ret, nr, arg);
1814 2205 : 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 2205 : err += melFunction(false, "batcalc", "avg", (MALfcn)&CMDcalcavg, "CMDcalcavg", false, "average of non-nil values of B", 1, 3, ret, arg, scale);
1816 2205 : 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 2205 : 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 2205 : 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 315 : struct {
1822 : int type;
1823 : char *name;
1824 : char *fname;
1825 : MALfcn fcn;
1826 315 : } 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 315 : int typeopslen = 10;
1883 : #else
1884 : int typeopslen = 9;
1885 : #endif
1886 3465 : for(int t = 0; t<typeopslen; t++) {
1887 : /* from any 2 string */
1888 3150 : mel_func_arg ret = { .type = typeops[t].type, .isbat =1 };
1889 3150 : if (strcmp(typeops[t].name, "str")==0) {
1890 315 : mel_func_arg arg = { .type = TYPE_any, .isbat =1 };
1891 :
1892 315 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 2, ret, arg);
1893 315 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 3, ret, arg, cand);
1894 : } else {
1895 31185 : for(int p = 0; p<typeopslen; p++) {
1896 28350 : mel_func_arg arg = { .type = typeops[p].type, .isbat =1 };
1897 :
1898 28350 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 2, ret, arg);
1899 28350 : err += melFunction(false, "batcalc", typeops[t].name, typeops[t].fcn, typeops[t].fname, false, "", 1, 3, ret, arg, cand);
1900 : }
1901 : }
1902 : }
1903 315 : 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 308 : LIB_STARTUP_FUNC(init_batcalc_mal)
1975 308 : { mal_module2("batcalc", NULL, batcalc_init_funcs, &batcalc_init, NULL); }
|
