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 : /* Author(s) M.L. Kersten, N. Nes
14 : * This module takes the statically defined modules, atoms, commands and patterns
15 : * and populate the internal structures.
16 : *
17 : */
18 :
19 : #include "monetdb_config.h"
20 : #include "mal_import.h"
21 : #include "mal_interpreter.h" /* for showErrors() */
22 : #include "mal_linker.h" /* for loadModuleLibrary() */
23 : #include "mal_scenario.h"
24 : #include "mal_parser.h"
25 : #include "mal_authorize.h"
26 : #include "mal_private.h"
27 : #include "mutils.h"
28 :
29 : #include "mal_prelude.h"
30 :
31 : #define MAX_MAL_MODULES 128
32 : static int mel_modules = 0, mel_modules_loaded = 0;
33 : static struct mel_module {
34 : const char *name;
35 : mel_atom *atoms;
36 : mel_func *funcs;
37 : mel_init inits;
38 : const char *code;
39 : } mel_module[MAX_MAL_MODULES];
40 :
41 : int
42 332 : mal_startup(void)
43 : {
44 : /* clean up the MAL internal structures before restart */
45 332 : mel_modules_loaded = 0;
46 332 : return 0;
47 : }
48 :
49 : /* all MAL related functions register themselves
50 : * the order in which these registrations happen is significant
51 : * because there may be dependencies among the definitions.
52 : * For example, you better know the atoms before you use them
53 : */
54 :
55 : void
56 3257 : mal_module2(const char *name, mel_atom *atoms, mel_func *funcs,
57 : mel_init initfunc, const char *code)
58 : {
59 3257 : assert(mel_modules < MAX_MAL_MODULES);
60 3257 : mel_module[mel_modules].name = name;
61 3257 : mel_module[mel_modules].atoms = atoms;
62 3257 : mel_module[mel_modules].funcs = funcs;
63 3257 : mel_module[mel_modules].inits = initfunc;
64 3257 : mel_module[mel_modules].code = code;
65 3257 : mel_modules++;
66 3257 : }
67 :
68 : void
69 14937 : mal_module(const char *name, mel_atom *atoms, mel_func *funcs)
70 : {
71 14937 : assert(mel_modules < MAX_MAL_MODULES);
72 14937 : mel_module[mel_modules].name = name;
73 14937 : mel_module[mel_modules].atoms = atoms;
74 14937 : mel_module[mel_modules].funcs = funcs;
75 14937 : mel_module[mel_modules].inits = NULL;
76 14937 : mel_module[mel_modules].code = NULL;
77 14937 : mel_modules++;
78 14937 : }
79 :
80 : static char *
81 15559 : initModule(Client c, const char *name, const char *initpasswd)
82 : {
83 15559 : char *msg = MAL_SUCCEED;
84 :
85 15559 : if (!getName(name))
86 : return msg;
87 15559 : if ((name = putName(name)) == NULL)
88 0 : throw(LOADER, __func__, SQLSTATE(HY013) MAL_MALLOC_FAIL);
89 15559 : Module m = getModule(name);
90 15559 : if (m) { /* run prelude */
91 12571 : const char *prelude = putName("prelude");
92 12571 : if (prelude == NULL)
93 0 : throw(LOADER, __func__, SQLSTATE(HY013) MAL_MALLOC_FAIL);
94 12571 : Symbol s = findSymbolInModule(m, prelude);
95 :
96 12571 : if (s) {
97 662 : if (s && s->kind == COMMANDsymbol && s->func && s->func->argc == 1) {
98 0 : int ret = 0;
99 :
100 0 : assert(s->func != NULL);
101 0 : msg = (*(str (*)(int *)) s->func->imp) (&ret);
102 0 : (void) ret;
103 662 : } else if (s && s->kind == PATTERNsymbol) {
104 662 : void *mb = NULL;
105 662 : assert(s->func->fcn != NULL);
106 662 : if (strcmp(name, "sql") == 0) {
107 : /* HACK ALERT: temporarily use sqlcontext to pass
108 : * the initial password to the prelude function */
109 332 : assert(c->sqlcontext == NULL);
110 332 : c->sqlcontext = (void *) initpasswd;
111 : /* HACK ALERT: use mb (MalBlkPtr) to pass revision
112 : * string in order to check that in the callee */
113 332 : mb = (void *) mercurial_revision();
114 : }
115 662 : msg = (*(str (*)(Client, MalBlkPtr, MalStkPtr, InstrPtr)) s->func->pimp) (c, mb, NULL, NULL);
116 : }
117 : }
118 : }
119 : return msg;
120 : }
121 :
122 : /*
123 : * The statically description of the MAL structures call for a translation into
124 : * their underlying structure.
125 : */
126 : static str
127 2976 : addAtom(mel_atom *atoms)
128 : {
129 6924 : for (; atoms && atoms->name[0]; atoms++) {
130 3948 : int i = ATOMallocate(atoms->name);
131 3948 : if (is_int_nil(i))
132 0 : throw(TYPE, __func__, GDK_EXCEPTION);
133 3948 : if (atoms->basetype[0]) {
134 2976 : int tpe = ATOMindex(atoms->basetype);
135 2976 : if (tpe < 0)
136 0 : throw(TYPE, __func__, TYPE_NOT_SUPPORTED);
137 2976 : BATatoms[i] = BATatoms[tpe];
138 2976 : strcpy_len(BATatoms[i].name, atoms->name, sizeof(BATatoms[i].name));
139 2976 : BATatoms[i].storage = ATOMstorage(tpe);
140 : } else { /* cannot overload void atoms */
141 972 : BATatoms[i].storage = i;
142 972 : BATatoms[i].linear = false;
143 : }
144 3948 : if (atoms->del)
145 640 : BATatoms[i].atomDel = atoms->del;
146 3948 : if (atoms->cmp) {
147 1292 : BATatoms[i].atomCmp = atoms->cmp;
148 1292 : BATatoms[i].linear = true;
149 : }
150 3948 : if (atoms->fromstr)
151 2952 : BATatoms[i].atomFromStr = atoms->fromstr;
152 3948 : if (atoms->tostr)
153 2952 : BATatoms[i].atomToStr = atoms->tostr;
154 3948 : if (atoms->heap) {
155 640 : BATatoms[i].size = sizeof(var_t);
156 640 : assert_shift_width(ATOMelmshift(ATOMsize(i)), ATOMsize(i));
157 640 : BATatoms[i].atomHeap = atoms->heap;
158 : }
159 3948 : if (atoms->hash)
160 960 : BATatoms[i].atomHash = atoms->hash;
161 3948 : if (atoms->length)
162 640 : BATatoms[i].atomLen = atoms->length;
163 3948 : if (atoms->null) {
164 1292 : const void *atmnull = (*atoms->null) ();
165 :
166 1292 : BATatoms[i].atomNull = atmnull;
167 : }
168 3948 : if (atoms->nequal)
169 0 : BATatoms[i].atomCmp = atoms->nequal;
170 3948 : if (atoms->put)
171 640 : BATatoms[i].atomPut = atoms->put;
172 3948 : if (atoms->storage)
173 0 : BATatoms[i].storage = (*atoms->storage) ();
174 3948 : if (atoms->read)
175 960 : BATatoms[i].atomRead = atoms->read;
176 3948 : if (atoms->write)
177 960 : BATatoms[i].atomWrite = atoms->write;
178 : }
179 : return MAL_SUCCEED;
180 : }
181 :
182 : static malType
183 12933638 : makeMalType(mel_arg *a)
184 : {
185 12933638 : malType tpe = TYPE_any;
186 :
187 12933638 : if (!a->type[0]) {
188 420958 : a->typeid = tpe;
189 420958 : if (a->isbat)
190 332660 : tpe = newBatType(tpe);
191 420958 : if (a->nr > 0)
192 387772 : setTypeIndex(tpe, a->nr);
193 : } else {
194 12512680 : tpe = getAtomIndex(a->type, strlen(a->type), -1);
195 12512680 : a->typeid = tpe;
196 12512680 : if (a->isbat)
197 7483315 : tpe = newBatType(tpe);
198 : }
199 12933638 : if (a->opt == 1)
200 156704 : setOptBat(tpe);
201 12933638 : return tpe;
202 : }
203 :
204 : void
205 747982 : setPoly(mel_func *f, malType tpe)
206 : {
207 733068 : int any = isAnyExpression(tpe) || tpe == TYPE_any || getOptBat(tpe);
208 1289818 : unsigned int index = 0;
209 : if (!any)
210 : return;
211 556750 : if (getTypeIndex(tpe) > 0)
212 : index = getTypeIndex(tpe);
213 541836 : if (any && (index + 1) > f->poly)
214 308826 : f->poly = index + 1;
215 : }
216 :
217 : static str
218 18547 : addFunctions(mel_func *fcn)
219 : {
220 18547 : str msg = MAL_SUCCEED;
221 18547 : Module c;
222 18547 : Symbol s;
223 :
224 1744947 : for (; fcn && fcn->mod; fcn++) {
225 1726400 : const char *mod = fcn->mod = putName(fcn->mod);
226 1726400 : fcn->fcn = putName(fcn->fcn);
227 1726400 : if (mod == NULL)
228 0 : throw(LOADER, __func__, SQLSTATE(HY013) MAL_MALLOC_FAIL);
229 1726400 : c = getModule(mod);
230 1726400 : if (c == NULL && (c = globalModule(mod)) == NULL)
231 0 : throw(LOADER, __func__, "Module %s can not be created", fcn->mod);
232 :
233 2914384 : s = newSymbol(fcn->fcn, (fcn->command) ? COMMANDsymbol : PATTERNsymbol);
234 1726400 : if (s == NULL)
235 0 : throw(LOADER, __func__, "Can not create symbol for %s.%s missing", fcn->mod,
236 : fcn->fcn);
237 1726400 : s->def = NULL;
238 1726400 : s->func = fcn;
239 1726400 : s->allocated = false;
240 :
241 : /* add the return variables */
242 1726400 : unsigned int i;
243 3559124 : for (i = 0; i < fcn->retc; i++) {
244 1832724 : mel_arg *a = fcn->args + i;
245 1832724 : malType tpe = makeMalType(a);
246 1832724 : if (a->nr > 0 || a->opt)
247 57456 : setPoly(fcn, tpe);
248 1832724 : if (a->vargs) {
249 3154 : fcn->vrets = true;
250 3154 : setPoly(fcn, TYPE_any);
251 : }
252 1832724 : if (a->opt && fcn->command)
253 0 : throw(LOADER, __func__, "Can not have command symbol with dynamic types, ie bat vs scalar in %s.%s", fcn->mod, fcn->fcn);
254 : /*
255 : if (a->nr >= 2)
256 : printf("%s.%s\n", fcn->mod, fcn->fcn);
257 : */
258 : }
259 : /* add the arguments */
260 6197938 : for (i = fcn->retc; i < fcn->argc; i++) {
261 4471538 : mel_arg *a = fcn->args + i;
262 4471538 : malType tpe = makeMalType(a);
263 :
264 4471538 : if (a->nr > 0 || a->opt)
265 452492 : setPoly(fcn, tpe);
266 4471538 : if (a->vargs) {
267 11760 : fcn->vargs = true;
268 11760 : setPoly(fcn, TYPE_any);
269 : }
270 4471538 : if (a->opt && fcn->command)
271 0 : throw(LOADER, __func__, "Can not have command symbol with dynamic types, ie bat vs scalar in %s.%s", fcn->mod, fcn->fcn);
272 : /*
273 : if (a->nr >= 2)
274 : printf("%s.%s\n", fcn->mod, fcn->fcn);
275 : */
276 : }
277 1726400 : insertSymbol(c, s);
278 : }
279 : return msg;
280 : }
281 :
282 : static void
283 6629376 : argCopy( mel_arg *ap, mel_func_arg *a)
284 : {
285 6629376 : ap->typeid = a->type;
286 6629376 : ap->nr = a->nr;
287 6629376 : ap->isbat = a->isbat;
288 6629376 : ap->vargs = a->vargs;
289 6629376 : ap->opt = a->opt;
290 6629376 : if (a->type != TYPE_any)
291 6596840 : strcpy(ap->type, BATatoms[a->type].name);
292 : else
293 32536 : ap->type[0] = 0;
294 6629376 : }
295 :
296 : int
297 1653028 : melFunction(bool command, const char *mod, const char *fcn, MALfcn imp,
298 : const char *fname, bool unsafe, const char *comment, int retc,
299 : int argc, ...)
300 : {
301 1653028 : int i;
302 1653028 : Module c;
303 1653028 : Symbol s;
304 1653028 : mel_func *f = NULL;
305 1653028 : va_list va;
306 :
307 1653028 : assert(mod && fcn);
308 1653028 : mod = putName(mod);
309 1653028 : fcn = putName(fcn);
310 1653028 : c = getModule(mod);
311 1653028 : if (c == NULL && (c = globalModule(mod)) == NULL)
312 : return MEL_ERR;
313 :
314 3306056 : s = newSymbol(fcn, command ? COMMANDsymbol : PATTERNsymbol);
315 1653028 : if (s == NULL)
316 : return MEL_ERR;
317 1653028 : fcn = s->name;
318 1653028 : s->allocated = true;
319 :
320 1653028 : f = (mel_func*)GDKmalloc(sizeof(mel_func));
321 1653028 : mel_arg *args = (mel_arg*)GDKmalloc(sizeof(mel_arg)*argc);
322 1653028 : if (!f || !args) {
323 0 : if(!f) GDKfree(f);
324 0 : freeSymbol(s);
325 0 : return MEL_ERR;
326 : }
327 1653028 : f->mod = mod;
328 1653028 : f->fcn = fcn;
329 1653028 : f->command = command;
330 1653028 : f->unsafe = unsafe;
331 1653028 : f->vargs = 0;
332 1653028 : f->vrets = 0;
333 1653028 : f->poly = 0;
334 1653028 : f->retc = retc;
335 1653028 : f->argc = argc;
336 1653028 : f->args = args;
337 1653028 : f->imp = imp;
338 1653028 : f->comment = comment?GDKstrdup(comment):NULL;
339 1653028 : f->cname = fname?GDKstrdup(fname):NULL;
340 1653028 : s->def = NULL;
341 1653028 : s->func = f;
342 :
343 1653028 : va_start(va, argc);
344 3315352 : for (i = 0; i < retc; i++) {
345 1662324 : mel_func_arg a = va_arg(va, mel_func_arg);
346 1662324 : mel_arg *ap = f->args+i;
347 1662324 : argCopy(ap, &a);
348 1662324 : malType tpe = makeMalType(ap);
349 1662324 : if (a.nr > 0 || a.opt)
350 0 : setPoly(f, tpe);
351 1662324 : if (a.vargs) {
352 0 : f->vrets = true;
353 0 : setPoly(f, TYPE_any);
354 : }
355 1662324 : if (a.opt && f->command)
356 0 : return MEL_ERR;
357 : /*
358 : if (a.nr >= 2)
359 : printf("%s.%s\n", f->mod, f->fcn);
360 : */
361 : }
362 : /* add the arguments */
363 6620080 : for (i = retc; i < argc; i++) {
364 4967052 : mel_func_arg a = va_arg(va, mel_func_arg);
365 4967052 : mel_arg *ap = f->args+i;
366 4967052 : argCopy(ap, &a);
367 4967052 : malType tpe = makeMalType(ap);
368 4967052 : if (a.nr > 0 || a.opt)
369 223104 : setPoly(f, tpe);
370 4967052 : if (a.vargs) {
371 0 : f->vargs = true;
372 0 : setPoly(f, TYPE_any);
373 : }
374 4967052 : if (a.opt && f->command)
375 0 : return MEL_ERR;
376 : /*
377 : if (a.nr >= 2)
378 : printf("%s.%s\n", f->mod, f->fcn);
379 : */
380 : }
381 1653028 : insertSymbol(c, s);
382 1653028 : va_end(va);
383 1653028 : return MEL_OK;
384 : }
385 :
386 : static str
387 332 : malPrelude(Client c, int listing, int *sql, int *mapi)
388 : {
389 332 : int i;
390 332 : str msg = MAL_SUCCEED;
391 :
392 332 : (void) listing;
393 : /* Add all atom definitions */
394 18879 : for (i = mel_modules_loaded; i < mel_modules; i++) {
395 18547 : if (mel_module[i].atoms) {
396 2976 : msg = addAtom(mel_module[i].atoms);
397 2976 : if (msg)
398 0 : return msg;
399 : }
400 : }
401 :
402 : /* Add the signatures, where we now have access to all atoms */
403 18879 : for (i = mel_modules_loaded; i < mel_modules; i++) {
404 18547 : const char *name = putName(mel_module[i].name);
405 18547 : if (!malLibraryEnabled(name))
406 0 : continue;
407 18547 : if (mel_module[i].funcs) {
408 18547 : msg = addFunctions(mel_module[i].funcs);
409 18547 : if (!msg && mel_module[i].code) /* some modules may also have some function definitions */
410 0 : msg = malIncludeString(c, name, (str) mel_module[i].code, listing, NULL);
411 18547 : if (msg)
412 0 : return msg;
413 :
414 : /* mapi should be last, and sql last before mapi */
415 18547 : if (strcmp(name, "sql") == 0) {
416 332 : *sql = i;
417 332 : continue;
418 : }
419 18215 : if (strcmp(name, "mapi") == 0) {
420 332 : *mapi = i;
421 332 : continue;
422 : }
423 17883 : if (!mel_module[i].inits) {
424 15227 : msg = initModule(c, name, NULL);
425 15227 : if (msg)
426 0 : return msg;
427 : }
428 : }
429 17883 : if (mel_module[i].inits) {
430 : /* mapi should be last, and sql last before mapi */
431 2656 : if (strcmp(name, "sql") == 0 || strcmp(name, "mapi") == 0)
432 0 : continue;
433 2656 : msg = mel_module[i].inits();
434 2656 : if (msg)
435 0 : return msg;
436 : }
437 : }
438 332 : mel_modules_loaded = mel_modules;
439 332 : return MAL_SUCCEED;
440 : }
441 :
442 : str
443 332 : malIncludeModules(Client c, char *modules[], int listing, bool no_mapi_server,
444 : const char *initpasswd)
445 : {
446 332 : str msg;
447 332 : int sql = -1, mapi = -1;
448 :
449 3553 : for (int i = 0; modules[i]; i++) {
450 : /* load library */
451 3221 : if (!malLibraryEnabled(modules[i]))
452 938 : continue;
453 2283 : if ((msg = loadLibrary(modules[i], listing)) != NULL)
454 0 : return msg;
455 : }
456 : /* load the mal code for these modules and execute preludes */
457 332 : if ((msg = malPrelude(c, listing, &sql, &mapi)) != NULL)
458 : return msg;
459 : /* mapi should be last, and sql last before mapi */
460 332 : if (sql >= 0) {
461 332 : if (mel_module[sql].inits)
462 0 : msg = mel_module[sql].inits();
463 : else
464 332 : msg = initModule(c, "sql", initpasswd);
465 331 : if (msg)
466 : return msg;
467 : }
468 331 : if (!no_mapi_server && mapi >= 0 && initpasswd == NULL) {
469 319 : if (mel_module[mapi].inits)
470 319 : msg = mel_module[mapi].inits();
471 : else
472 0 : msg = initModule(c, "mapi", NULL);
473 319 : if (msg)
474 : return msg;
475 : }
476 : return MAL_SUCCEED;
477 : }
|
