BadVPN – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /**
2 * @file NCDModule.c
3 * @author Ambroz Bizjak <ambrop7@gmail.com>
4 *
5 * @section LICENSE
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the name of the author nor the
15 * names of its contributors may be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
22 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29  
30 #include <stdarg.h>
31 #include <string.h>
32 #include <stddef.h>
33 #include <inttypes.h>
34 #include <limits.h>
35  
36 #include <misc/offset.h>
37 #include <ncd/NCDModule.h>
38 #include <ncd/static_strings.h>
39  
40 #define STATE_DEAD 0
41 #define STATE_DOWN_CLEAN 1
42 #define STATE_UP 2
43 #define STATE_DOWN_UNCLEAN 3
44 #define STATE_DYING 4
45  
46 #define PROCESS_STATE_INIT 0
47 #define PROCESS_STATE_DOWN 1
48 #define PROCESS_STATE_UP 2
49 #define PROCESS_STATE_DOWN_WAITING 3
50 #define PROCESS_STATE_TERMINATING 4
51 #define PROCESS_STATE_TERMINATED 5
52  
53 static int object_func_getvar (const NCDObject *obj, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out_value);
54 static int object_func_getobj (const NCDObject *obj, NCD_string_id_t name, NCDObject *out_object);
55 static int process_args_object_func_getvar (const NCDObject *obj, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out_value);
56 static int process_arg_object_func_getvar (const NCDObject *obj, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out_value);
57  
58 static void frontend_event (NCDModuleInst *n, int event)
59 {
60 n->params->func_event(n, event);
61 }
62  
63 static void inst_assert_backend (NCDModuleInst *n)
64 {
65 ASSERT(n->state == STATE_DOWN_UNCLEAN || n->state == STATE_DOWN_CLEAN ||
66 n->state == STATE_UP ||
67 n->state == STATE_DYING)
68 }
69  
70 static void set_process_state (NCDModuleProcess *p, int state)
71 {
72 #ifndef NDEBUG
73 p->state = state;
74 #endif
75 }
76  
77 static NCDObject persistent_obj_retobj (NCDPersistentObj const *pobj)
78 {
79 NCDModuleInst *n = UPPER_OBJECT(pobj, NCDModuleInst, pobj);
80  
81 return NCDModuleInst_Object(n);
82 }
83  
84 void NCDModuleInst_Init (NCDModuleInst *n, const struct NCDInterpModule *m, void *method_context, NCDValRef args, const struct NCDModuleInst_params *params)
85 {
86 ASSERT(m)
87 ASSERT(m->module.func_new2)
88 ASSERT(m->module.alloc_size >= 0)
89 ASSERT(m->base_type_id >= 0)
90 ASSERT(m->group)
91 ASSERT(n->mem)
92 ASSERT(NCDVal_IsList(args))
93 ASSERT(params)
94 ASSERT(params->func_event)
95 ASSERT(params->func_getobj)
96 ASSERT(params->logfunc)
97 ASSERT(params->iparams)
98 ASSERT(params->iparams->func_initprocess)
99 ASSERT(params->iparams->func_interp_exit)
100 ASSERT(params->iparams->func_interp_getargs)
101 ASSERT(params->iparams->func_interp_getretrytime)
102  
103 // init arguments
104 n->m = m;
105 n->params = params;
106  
107 // set initial state
108 n->state = STATE_DOWN_CLEAN;
109  
110 // give NCDModuleInst to methods, not mem
111 n->pass_mem_to_methods = 0;
112  
113 // init persistent object interface
114 NCDPersistentObj_Init(&n->pobj, persistent_obj_retobj);
115  
116 DebugObject_Init(&n->d_obj);
117  
118 struct NCDModuleInst_new_params new_params;
119 new_params.method_user = method_context;
120 new_params.args = args;
121  
122 n->m->module.func_new2(n->mem, n, &new_params);
123 }
124  
125 void NCDModuleInst_Free (NCDModuleInst *n)
126 {
127 DebugObject_Free(&n->d_obj);
128 ASSERT(n->state == STATE_DEAD)
129  
130 // free persistent object interface
131 NCDPersistentObj_Free(&n->pobj);
132 }
133  
134 void NCDModuleInst_Die (NCDModuleInst *n)
135 {
136 DebugObject_Access(&n->d_obj);
137 ASSERT(n->state == STATE_UP || n->state == STATE_DOWN_CLEAN || n->state == STATE_DOWN_UNCLEAN)
138  
139 n->state = STATE_DYING;
140  
141 if (!n->m->module.func_die) {
142 NCDModuleInst_Backend_Dead(n);
143 return;
144 }
145  
146 n->m->module.func_die(n->mem);
147 return;
148 }
149  
150 int NCDModuleInst_TryFree (NCDModuleInst *n)
151 {
152 DebugObject_Access(&n->d_obj);
153 ASSERT(n->state == STATE_UP || n->state == STATE_DOWN_CLEAN || n->state == STATE_DOWN_UNCLEAN)
154  
155 if (n->m->module.func_die) {
156 return 0;
157 }
158  
159 DebugObject_Free(&n->d_obj);
160  
161 // free persistent object interface
162 NCDPersistentObj_Free(&n->pobj);
163  
164 return 1;
165 }
166  
167 void NCDModuleInst_Clean (NCDModuleInst *n)
168 {
169 DebugObject_Access(&n->d_obj);
170 ASSERT(n->state == STATE_DOWN_CLEAN || n->state == STATE_DOWN_UNCLEAN)
171  
172 if (n->state == STATE_DOWN_UNCLEAN) {
173 n->state = STATE_DOWN_CLEAN;
174  
175 if (n->m->module.func_clean) {
176 n->m->module.func_clean(n->mem);
177 return;
178 }
179 }
180 }
181  
182 NCDObject NCDModuleInst_Object (NCDModuleInst *n)
183 {
184 DebugObject_Access(&n->d_obj);
185 ASSERT(n->m->base_type_id >= 0)
186  
187 void *method_user = (n->pass_mem_to_methods ? n->mem : n);
188  
189 return NCDObject_BuildFull(n->m->base_type_id, n, 0, method_user, object_func_getvar, object_func_getobj, &n->pobj);
190 }
191  
192 void NCDModuleInst_Backend_PassMemToMethods (NCDModuleInst *n)
193 {
194 DebugObject_Access(&n->d_obj);
195 ASSERT(n->state == STATE_DOWN_UNCLEAN || n->state == STATE_DOWN_CLEAN ||
196 n->state == STATE_UP ||
197 n->state == STATE_DYING)
198  
199 n->pass_mem_to_methods = 1;
200 }
201  
202 static int can_resolve (NCDModuleInst *n)
203 {
204 switch (n->state) {
205 case STATE_UP:
206 return 1;
207 case STATE_DOWN_CLEAN:
208 case STATE_DOWN_UNCLEAN:
209 return !!(n->m->module.flags & NCDMODULE_FLAG_CAN_RESOLVE_WHEN_DOWN);
210 default:
211 return 0;
212 }
213 }
214  
215 static int object_func_getvar (const NCDObject *obj, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out_value)
216 {
217 NCDModuleInst *n = NCDObject_DataPtr(obj);
218 DebugObject_Access(&n->d_obj);
219  
220 if ((!n->m->module.func_getvar && !n->m->module.func_getvar2) || !can_resolve(n)) {
221 return 0;
222 }
223  
224 int res;
225 if (n->m->module.func_getvar2) {
226 res = n->m->module.func_getvar2(n->mem, name, mem, out_value);
227 } else {
228 if (NCDStringIndex_HasNulls(n->params->iparams->string_index, name)) {
229 return 0;
230 }
231 const char *name_str = NCDStringIndex_Value(n->params->iparams->string_index, name).ptr;
232 res = n->m->module.func_getvar(n->mem, name_str, mem, out_value);
233 }
234 ASSERT(res == 0 || res == 1)
235 ASSERT(res == 0 || (NCDVal_Assert(*out_value), 1))
236  
237 return res;
238 }
239  
240 static int object_func_getobj (const NCDObject *obj, NCD_string_id_t name, NCDObject *out_object)
241 {
242 NCDModuleInst *n = NCDObject_DataPtr(obj);
243 DebugObject_Access(&n->d_obj);
244  
245 if (!n->m->module.func_getobj || !can_resolve(n)) {
246 return 0;
247 }
248  
249 int res = n->m->module.func_getobj(n->mem, name, out_object);
250 ASSERT(res == 0 || res == 1)
251  
252 return res;
253 }
254  
255 void * NCDModuleInst_Backend_GetUser (NCDModuleInst *n)
256 {
257 DebugObject_Access(&n->d_obj);
258 ASSERT(n->state == STATE_DOWN_UNCLEAN || n->state == STATE_DOWN_CLEAN ||
259 n->state == STATE_UP ||
260 n->state == STATE_DYING)
261  
262 return n->mem;
263 }
264  
265 void NCDModuleInst_Backend_Up (NCDModuleInst *n)
266 {
267 DebugObject_Access(&n->d_obj);
268 ASSERT(n->state == STATE_DOWN_CLEAN || n->state == STATE_DOWN_UNCLEAN)
269  
270 n->state = STATE_UP;
271 frontend_event(n, NCDMODULE_EVENT_UP);
272 }
273  
274 void NCDModuleInst_Backend_Down (NCDModuleInst *n)
275 {
276 DebugObject_Access(&n->d_obj);
277 ASSERT(n->state == STATE_UP)
278  
279 n->state = STATE_DOWN_UNCLEAN;
280 frontend_event(n, NCDMODULE_EVENT_DOWN);
281 }
282  
283 void NCDModuleInst_Backend_DownUp (NCDModuleInst *n)
284 {
285 DebugObject_Access(&n->d_obj);
286 ASSERT(n->state == STATE_UP)
287  
288 frontend_event(n, NCDMODULE_EVENT_DOWNUP);
289 }
290  
291 void NCDModuleInst_Backend_Dead (NCDModuleInst *n)
292 {
293 DebugObject_Access(&n->d_obj);
294 ASSERT(n->state == STATE_DOWN_CLEAN || n->state == STATE_DOWN_UNCLEAN ||
295 n->state == STATE_UP || n->state == STATE_DYING)
296  
297 n->state = STATE_DEAD;
298  
299 frontend_event(n, NCDMODULE_EVENT_DEAD);
300 return;
301 }
302  
303 void NCDModuleInst_Backend_DeadError (NCDModuleInst *n)
304 {
305 DebugObject_Access(&n->d_obj);
306 ASSERT(n->state == STATE_DOWN_CLEAN || n->state == STATE_DOWN_UNCLEAN ||
307 n->state == STATE_UP || n->state == STATE_DYING)
308  
309 n->state = STATE_DEAD;
310  
311 frontend_event(n, NCDMODULE_EVENT_DEADERROR);
312 return;
313 }
314  
315 int NCDModuleInst_Backend_GetObj (NCDModuleInst *n, NCD_string_id_t name, NCDObject *out_object)
316 {
317 DebugObject_Access(&n->d_obj);
318 ASSERT(n->state == STATE_DOWN_UNCLEAN || n->state == STATE_DOWN_CLEAN ||
319 n->state == STATE_UP ||
320 n->state == STATE_DYING)
321 ASSERT(out_object)
322  
323 int res = n->params->func_getobj(n, name, out_object);
324 ASSERT(res == 0 || res == 1)
325  
326 return res;
327 }
328  
329 void NCDModuleInst_Backend_Log (NCDModuleInst *n, int channel, int level, const char *fmt, ...)
330 {
331 DebugObject_Access(&n->d_obj);
332  
333 va_list vl;
334 va_start(vl, fmt);
335 BLog_LogViaFuncVarArg(n->params->logfunc, n, channel, level, fmt, vl);
336 va_end(vl);
337 }
338  
339 void NCDModuleInst_Backend_LogVarArg (NCDModuleInst *n, int channel, int level, const char *fmt, va_list vl)
340 {
341 DebugObject_Access(&n->d_obj);
342  
343 BLog_LogViaFuncVarArg(n->params->logfunc, n, channel, level, fmt, vl);
344 }
345  
346 BLogContext NCDModuleInst_Backend_LogContext (NCDModuleInst *n)
347 {
348 DebugObject_Access(&n->d_obj);
349  
350 return BLog_MakeContext(n->params->logfunc, n);
351 }
352  
353 void NCDModuleInst_Backend_InterpExit (NCDModuleInst *n, int exit_code)
354 {
355 DebugObject_Access(&n->d_obj);
356 inst_assert_backend(n);
357  
358 n->params->iparams->func_interp_exit(n->params->iparams->user, exit_code);
359 }
360  
361 int NCDModuleInst_Backend_InterpGetArgs (NCDModuleInst *n, NCDValMem *mem, NCDValRef *out_value)
362 {
363 DebugObject_Access(&n->d_obj);
364 inst_assert_backend(n);
365 ASSERT(mem)
366 ASSERT(out_value)
367  
368 int res = n->params->iparams->func_interp_getargs(n->params->iparams->user, mem, out_value);
369 ASSERT(res == 0 || res == 1)
370 ASSERT(res == 0 || (NCDVal_Assert(*out_value), 1))
371  
372 return res;
373 }
374  
375 btime_t NCDModuleInst_Backend_InterpGetRetryTime (NCDModuleInst *n)
376 {
377 DebugObject_Access(&n->d_obj);
378 inst_assert_backend(n);
379  
380 return n->params->iparams->func_interp_getretrytime(n->params->iparams->user);
381 }
382  
383 int NCDModuleInst_Backend_InterpLoadGroup (NCDModuleInst *n, const struct NCDModuleGroup *group)
384 {
385 DebugObject_Access(&n->d_obj);
386 inst_assert_backend(n);
387 ASSERT(group)
388  
389 return n->params->iparams->func_loadgroup(n->params->iparams->user, group);
390 }
391  
392 void NCDModuleRef_Init (NCDModuleRef *o, NCDModuleInst *inst)
393 {
394 ASSERT(!inst->pass_mem_to_methods)
395  
396 NCDObject obj = NCDModuleInst_Object(inst);
397 NCDObjRef_Init(&o->objref, NCDObject_Pobj(&obj));
398  
399 DebugObject_Init(&o->d_obj);
400 }
401  
402 void NCDModuleRef_Free (NCDModuleRef *o)
403 {
404 DebugObject_Free(&o->d_obj);
405  
406 NCDObjRef_Free(&o->objref);
407 }
408  
409 NCDModuleInst * NCDModuleRef_Deref (NCDModuleRef *o)
410 {
411 DebugObject_Access(&o->d_obj);
412  
413 NCDModuleInst *res = NULL;
414 NCDObject obj;
415 if (NCDObjRef_Deref(&o->objref, &obj)) {
416 res = NCDObject_MethodUser(&obj);
417 }
418 return res;
419 }
420  
421 int NCDModuleProcess_InitId (NCDModuleProcess *o, NCDModuleInst *n, NCD_string_id_t template_name, NCDValRef args, NCDModuleProcess_handler_event handler_event)
422 {
423 DebugObject_Access(&n->d_obj);
424 ASSERT(n->state == STATE_DOWN_UNCLEAN || n->state == STATE_DOWN_CLEAN ||
425 n->state == STATE_UP ||
426 n->state == STATE_DYING)
427 ASSERT(template_name >= 0)
428 ASSERT(NCDVal_IsInvalid(args) || NCDVal_IsList(args))
429 ASSERT(handler_event)
430  
431 // init arguments
432 o->args = args;
433 o->handler_event = handler_event;
434  
435 // set no special functions
436 o->func_getspecialobj = NULL;
437  
438 // set state
439 set_process_state(o, PROCESS_STATE_INIT);
440  
441 #ifndef NDEBUG
442 // clear interp functions so we can assert they were set
443 o->interp_func_event = NULL;
444 o->interp_func_getobj = NULL;
445 #endif
446  
447 // init interpreter part
448 if (!(n->params->iparams->func_initprocess(n->params->iparams->user, o, template_name))) {
449 goto fail1;
450 }
451  
452 ASSERT(o->interp_func_event)
453 ASSERT(o->interp_func_getobj)
454  
455 // set state
456 set_process_state(o, PROCESS_STATE_DOWN);
457  
458 DebugObject_Init(&o->d_obj);
459 return 1;
460  
461 fail1:
462 return 0;
463 }
464  
465 int NCDModuleProcess_InitValue (NCDModuleProcess *o, NCDModuleInst *n, NCDValRef template_name, NCDValRef args, NCDModuleProcess_handler_event handler_event)
466 {
467 DebugObject_Access(&n->d_obj);
468 ASSERT(n->state == STATE_DOWN_UNCLEAN || n->state == STATE_DOWN_CLEAN ||
469 n->state == STATE_UP ||
470 n->state == STATE_DYING)
471 ASSERT(NCDVal_IsString(template_name))
472 ASSERT(NCDVal_IsInvalid(args) || NCDVal_IsList(args))
473 ASSERT(handler_event)
474  
475 NCD_string_id_t template_name_id;
476  
477 if (NCDVal_IsIdString(template_name)) {
478 template_name_id = NCDVal_IdStringId(template_name);
479 } else {
480 template_name_id = NCDStringIndex_GetBinMr(n->params->iparams->string_index, NCDVal_StringMemRef(template_name));
481 if (template_name_id < 0) {
482 BLog(BLOG_ERROR, "NCDStringIndex_GetBin failed");
483 return 0;
484 }
485 }
486  
487 return NCDModuleProcess_InitId(o, n, template_name_id, args, handler_event);
488 }
489  
490 void NCDModuleProcess_Free (NCDModuleProcess *o)
491 {
492 DebugObject_Free(&o->d_obj);
493 ASSERT(o->state == PROCESS_STATE_TERMINATED)
494 }
495  
496 void NCDModuleProcess_AssertFree (NCDModuleProcess *o)
497 {
498 DebugObject_Access(&o->d_obj);
499 ASSERT(o->state == PROCESS_STATE_TERMINATED)
500 }
501  
502 void NCDModuleProcess_SetSpecialFuncs (NCDModuleProcess *o, NCDModuleProcess_func_getspecialobj func_getspecialobj)
503 {
504 DebugObject_Access(&o->d_obj);
505  
506 o->func_getspecialobj = func_getspecialobj;
507 }
508  
509 void NCDModuleProcess_Continue (NCDModuleProcess *o)
510 {
511 DebugObject_Access(&o->d_obj);
512 ASSERT(o->state == PROCESS_STATE_DOWN_WAITING)
513  
514 set_process_state(o, PROCESS_STATE_DOWN);
515  
516 o->interp_func_event(o->interp_user, NCDMODULEPROCESS_INTERP_EVENT_CONTINUE);
517 }
518  
519 void NCDModuleProcess_Terminate (NCDModuleProcess *o)
520 {
521 DebugObject_Access(&o->d_obj);
522 ASSERT(o->state == PROCESS_STATE_DOWN || o->state == PROCESS_STATE_UP ||
523 o->state == PROCESS_STATE_DOWN_WAITING)
524  
525 set_process_state(o, PROCESS_STATE_TERMINATING);
526  
527 o->interp_func_event(o->interp_user, NCDMODULEPROCESS_INTERP_EVENT_TERMINATE);
528 }
529  
530 int NCDModuleProcess_GetObj (NCDModuleProcess *o, NCD_string_id_t name, NCDObject *out_object)
531 {
532 DebugObject_Access(&o->d_obj);
533 ASSERT(o->state != PROCESS_STATE_INIT)
534 ASSERT(o->state != PROCESS_STATE_TERMINATED)
535 ASSERT(out_object)
536  
537 int res = o->interp_func_getobj(o->interp_user, name, out_object);
538 ASSERT(res == 0 || res == 1)
539  
540 return res;
541 }
542  
543 static void process_assert_interp (NCDModuleProcess *o)
544 {
545 // assert that the interpreter knows about the object, and we're not in init
546 ASSERT(o->state == PROCESS_STATE_DOWN || o->state == PROCESS_STATE_UP ||
547 o->state == PROCESS_STATE_DOWN_WAITING || o->state == PROCESS_STATE_TERMINATING)
548 }
549  
550 void NCDModuleProcess_Interp_SetHandlers (NCDModuleProcess *o, void *interp_user,
551 NCDModuleProcess_interp_func_event interp_func_event,
552 NCDModuleProcess_interp_func_getobj interp_func_getobj)
553 {
554 ASSERT(o->state == PROCESS_STATE_INIT)
555 ASSERT(interp_func_event)
556 ASSERT(interp_func_getobj)
557  
558 o->interp_user = interp_user;
559 o->interp_func_event = interp_func_event;
560 o->interp_func_getobj = interp_func_getobj;
561 }
562  
563 void NCDModuleProcess_Interp_Up (NCDModuleProcess *o)
564 {
565 DebugObject_Access(&o->d_obj);
566 process_assert_interp(o);
567 ASSERT(o->state == PROCESS_STATE_DOWN)
568  
569 set_process_state(o, PROCESS_STATE_UP);
570  
571 o->handler_event(o, NCDMODULEPROCESS_EVENT_UP);
572 return;
573 }
574  
575 void NCDModuleProcess_Interp_Down (NCDModuleProcess *o)
576 {
577 DebugObject_Access(&o->d_obj);
578 process_assert_interp(o);
579 ASSERT(o->state == PROCESS_STATE_UP)
580  
581 set_process_state(o, PROCESS_STATE_DOWN_WAITING);
582  
583 o->handler_event(o, NCDMODULEPROCESS_EVENT_DOWN);
584 return;
585 }
586  
587 void NCDModuleProcess_Interp_Terminated (NCDModuleProcess *o)
588 {
589 DebugObject_Access(&o->d_obj);
590 process_assert_interp(o);
591 ASSERT(o->state == PROCESS_STATE_TERMINATING)
592  
593 set_process_state(o, PROCESS_STATE_TERMINATED);
594  
595 o->handler_event(o, NCDMODULEPROCESS_EVENT_TERMINATED);
596 return;
597 }
598  
599 int NCDModuleProcess_Interp_GetSpecialObj (NCDModuleProcess *o, NCD_string_id_t name, NCDObject *out_object)
600 {
601 DebugObject_Access(&o->d_obj);
602 process_assert_interp(o);
603 ASSERT(out_object)
604  
605 if (!NCDVal_IsInvalid(o->args)) {
606 if (name == NCD_STRING_ARGS) {
607 *out_object = NCDObject_Build(-1, o, process_args_object_func_getvar, NCDObject_no_getobj);
608 return 1;
609 }
610  
611 if (name >= NCD_STRING_ARG0 && name <= NCD_STRING_ARG19) {
612 int num = name - NCD_STRING_ARG0;
613 if (num < NCDVal_ListCount(o->args)) {
614 *out_object = NCDObject_BuildFull(-1, o, num, NULL, process_arg_object_func_getvar, NCDObject_no_getobj, NULL);
615 return 1;
616 }
617 }
618 }
619  
620 if (!o->func_getspecialobj) {
621 return 0;
622 }
623  
624 int res = o->func_getspecialobj(o, name, out_object);
625 ASSERT(res == 0 || res == 1)
626  
627 return res;
628 }
629  
630 int NCDCall_DoIt (
631 struct NCDCall_interp_shared const *interp_shared, void *interp_user,
632 struct NCDInterpFunction const *interp_function,
633 size_t arg_count, NCDValMem *res_mem, NCDValRef *res_out
634 )
635 {
636 NCDValRef res = NCDVal_NewInvalid();
637  
638 NCDCall call;
639 call.interp_shared = interp_shared;
640 call.interp_user = interp_user;
641 call.interp_function = interp_function;
642 call.arg_count = arg_count;
643 call.res_mem = res_mem;
644 call.out_ref = &res;
645  
646 interp_function->function.func_eval(call);
647  
648 if (NCDVal_IsInvalid(res)) {
649 return 0;
650 }
651  
652 *res_out = res;
653 return 1;
654 }
655  
656 struct NCDInterpFunction const * NCDCall_InterpFunction (NCDCall const *o)
657 {
658 return o->interp_function;
659 }
660  
661 struct NCDModuleInst_iparams const * NCDCall_Iparams (NCDCall const *o)
662 {
663 return o->interp_shared->iparams;
664 }
665  
666 size_t NCDCall_ArgCount (NCDCall const *o)
667 {
668 return o->arg_count;
669 }
670  
671 NCDValRef NCDCall_EvalArg (NCDCall const *o, size_t index, NCDValMem *mem)
672 {
673 ASSERT(index < o->arg_count)
674 ASSERT(mem)
675  
676 NCDValRef res;
677  
678 int eval_res = o->interp_shared->func_eval_arg(o->interp_user, index, mem, &res);
679  
680 ASSERT(eval_res == 0 || eval_res == 1)
681 ASSERT(eval_res == 0 || (NCDVal_Assert(res), 1))
682  
683 if (!eval_res) {
684 res = NCDVal_NewInvalid();
685 }
686  
687 return res;
688 }
689  
690 NCDValMem * NCDCall_ResMem (NCDCall const *o)
691 {
692 return o->res_mem;
693 }
694  
695 void NCDCall_SetResult (NCDCall const *o, NCDValRef ref)
696 {
697 *o->out_ref = ref;
698 }
699  
700 BLogContext NCDCall_LogContext (NCDCall const *o)
701 {
702 return BLog_MakeContext(o->interp_shared->logfunc, o->interp_user);
703 }
704  
705 static int process_args_object_func_getvar (const NCDObject *obj, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out_value)
706 {
707 NCDModuleProcess *o = NCDObject_DataPtr(obj);
708 DebugObject_Access(&o->d_obj);
709 process_assert_interp(o);
710 ASSERT(!NCDVal_IsInvalid(o->args))
711  
712 if (name != NCD_STRING_EMPTY) {
713 return 0;
714 }
715  
716 *out_value = NCDVal_NewCopy(mem, o->args);
717 if (NCDVal_IsInvalid(*out_value)) {
718 BLog_LogToChannel(BLOG_CHANNEL_NCDModuleProcess, BLOG_ERROR, "NCDVal_NewCopy failed");
719 }
720 return 1;
721 }
722  
723 static int process_arg_object_func_getvar (const NCDObject *obj, NCD_string_id_t name, NCDValMem *mem, NCDValRef *out_value)
724 {
725 NCDModuleProcess *o = NCDObject_DataPtr(obj);
726 DebugObject_Access(&o->d_obj);
727 process_assert_interp(o);
728 ASSERT(!NCDVal_IsInvalid(o->args))
729  
730 if (name != NCD_STRING_EMPTY) {
731 return 0;
732 }
733  
734 *out_value = NCDVal_NewCopy(mem, NCDVal_ListGet(o->args, NCDObject_DataInt(obj)));
735 if (NCDVal_IsInvalid(*out_value)) {
736 BLog_LogToChannel(BLOG_CHANNEL_NCDModuleProcess, BLOG_ERROR, "NCDVal_NewCopy failed");
737 }
738 return 1;
739 }