static void arpprobe_handler (struct instance *o, int event)
{
switch (event) {
case BARPPROBE_EVENT_EXIST: {
ASSERT(o->state == STATE_UNKNOWN || o->state == STATE_NOEXIST)
ModuleLog(o->i, BLOG_INFO, "exist");
if (o->state == STATE_NOEXIST) {
// signal down
NCDModuleInst_Backend_Down(o->i);
}
// signal up
NCDModuleInst_Backend_Up(o->i);
// set state exist
o->state = STATE_EXIST;
} break;
case BARPPROBE_EVENT_NOEXIST: {
ASSERT(o->state == STATE_UNKNOWN || o->state == STATE_EXIST)
ModuleLog(o->i, BLOG_INFO, "noexist");
if (o->state == STATE_EXIST) {
// signal down
NCDModuleInst_Backend_Down(o->i);
}
// signal up
NCDModuleInst_Backend_Up(o->i);
// set state noexist
o->state = STATE_NOEXIST;
} break;
case BARPPROBE_EVENT_ERROR: {
ModuleLog(o->i, BLOG_ERROR, "error");
// die
instance_free(o, 1);
return;
} break;
default: ASSERT(0);
}
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// check arguments
NCDValRef str1_arg;
NCDValRef str2_arg;
if (!NCDVal_ListRead(params->args, 2, &str1_arg, &str2_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(str1_arg) || !NCDVal_IsString(str2_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
// compare
o->result = (NCDVal_Compare(str1_arg, str2_arg) == 0);
// signal up
NCDModuleInst_Backend_Up(i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void new_templ (NCDModuleInst *i, const struct NCDModuleInst_new_params *params, int is_not)
{
// check arguments
NCDValRef arg;
if (!NCDVal_ListRead(params->args, 1, &arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
int arg_val;
if (!ncd_read_boolean(arg, &arg_val)) {
ModuleLog(i, BLOG_ERROR, "bad argument");
goto fail0;
}
// compute logical value of argument
int c = arg_val;
// signal up if needed
if ((is_not && !c) || (!is_not && c)) {
NCDModuleInst_Backend_Up(i);
}
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// check arguments
if (!NCDVal_ListRead(params->args, 0)) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail0;
}
// init users list
LinkedList1_Init(&o->users);
// init rdownups list
LinkedList0_Init(&o->rdownups_list);
// set not up
o->up = 0;
// set not dying
o->dying = 0;
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef target_arg;
if (!NCDVal_ListRead(params->args, 1, &target_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(target_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
// parse name string
if (!AliasNames_InitNames(o, i->params->iparams->string_index, NCDVal_StringData(target_arg), NCDVal_StringLength(target_arg))) {
ModuleLog(i, BLOG_ERROR, "make_names failed");
goto fail0;
}
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void process_handler_event (struct instance *o, int event)
{
switch (event) {
case NCDMODULEPROCESS_EVENT_UP: {
ASSERT(o->state == STATE_WORKING)
// signal up
NCDModuleInst_Backend_Up(o->i);
// set state up
o->state = STATE_UP;
} break;
case NCDMODULEPROCESS_EVENT_DOWN: {
ASSERT(o->state == STATE_UP)
// signal down
NCDModuleInst_Backend_Down(o->i);
// set state waiting
o->state = STATE_WAITING;
} break;
case NCDMODULEPROCESS_EVENT_TERMINATED: {
ASSERT(o->state == STATE_TERMINATING)
// die finally
instance_free(o);
return;
} break;
default: ASSERT(0);
}
}
static void func_new (void *unused, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
// check arguments
NCDValRef exit_code_arg;
if (!NCDVal_ListRead(params->args, 1, &exit_code_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(exit_code_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
// parse exit code
uintmax_t exit_code;
if (!ncd_read_uintmax(exit_code_arg, &exit_code) || exit_code >= INT_MAX) {
ModuleLog(i, BLOG_ERROR, "wrong exit code value");
goto fail0;
}
// signal up
NCDModuleInst_Backend_Up(i);
// initiate exit (before up!)
NCDModuleInst_Backend_InterpExit(i, exit_code);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef ifname_arg;
NCDValRef addr_arg;
NCDValRef prefix_arg = NCDVal_NewInvalid();
if (!NCDVal_ListRead(params->args, 2, &ifname_arg, &addr_arg) &&
!NCDVal_ListRead(params->args, 3, &ifname_arg, &addr_arg, &prefix_arg)
) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsStringNoNulls(ifname_arg) || !NCDVal_IsString(addr_arg) ||
(!NCDVal_IsInvalid(prefix_arg) && !NCDVal_IsString(prefix_arg))
) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail0;
}
// null terminate ifname
if (!NCDVal_StringNullTerminate(ifname_arg, &o->ifname_nts)) {
ModuleLog(i, BLOG_ERROR, "NCDVal_StringNullTerminate failed");
goto fail0;
}
if (NCDVal_IsInvalid(prefix_arg)) {
if (!ipaddr_parse_ipv4_ifaddr(NCDVal_StringMemRef(addr_arg), &o->ifaddr)) {
ModuleLog(o->i, BLOG_ERROR, "wrong CIDR notation address");
goto fail1;
}
} else {
if (!ipaddr_parse_ipv4_addr(NCDVal_StringMemRef(addr_arg), &o->ifaddr.addr)) {
ModuleLog(o->i, BLOG_ERROR, "wrong address");
goto fail1;
}
if (!ipaddr_parse_ipv4_prefix(NCDVal_StringMemRef(prefix_arg), &o->ifaddr.prefix)) {
ModuleLog(o->i, BLOG_ERROR, "wrong prefix");
goto fail1;
}
}
// add address
if (!NCDIfConfig_add_ipv4_addr(o->ifname_nts.data, o->ifaddr)) {
ModuleLog(o->i, BLOG_ERROR, "failed to add IP address");
goto fail1;
}
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail1:
NCDValNullTermString_Free(&o->ifname_nts);
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void new_templ (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params, parse_func pfunc)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef str_arg;
if (!NCDVal_ListRead(params->args, 1, &str_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(str_arg)) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail0;
}
// init mem
NCDValMem_Init(&o->mem);
// parse
o->succeeded = pfunc(i, NCDVal_StringMemRef(str_arg), &o->mem, &o->value);
// signal up
NCDModuleInst_Backend_Up(i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void new_number_templ (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params, number_compute_func cfunc)
{
struct number_instance *o = vo;
o->i = i;
NCDValRef n1_arg;
NCDValRef n2_arg;
if (!NCDVal_ListRead(params->args, 2, &n1_arg, &n2_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
uintmax_t n1;
if (!ncd_read_uintmax(n1_arg, &n1)) {
ModuleLog(o->i, BLOG_ERROR, "wrong first argument");
goto fail0;
}
uintmax_t n2;
if (!ncd_read_uintmax(n2_arg, &n2)) {
ModuleLog(o->i, BLOG_ERROR, "wrong second argument");
goto fail0;
}
o->error = cfunc(i, n1, n2, &o->value);
NCDModuleInst_Backend_Up(i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef arg_choices;
NCDValRef arg_default_result;
if (!NCDVal_ListRead(params->args, 2, &arg_choices, &arg_default_result)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsList(arg_choices)) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
// iterate choices
int have_result = 0;
size_t count = NCDVal_ListCount(arg_choices);
for (size_t j = 0; j < count; j++) {
NCDValRef c = NCDVal_ListGet(arg_choices, j);
// check choice type
if (!NCDVal_IsList(c)) {
ModuleLog(i, BLOG_ERROR, "wrong choice type");
goto fail0;
}
// read choice
NCDValRef c_cond;
NCDValRef c_result;
if (!NCDVal_ListRead(c, 2, &c_cond, &c_result)) {
ModuleLog(i, BLOG_ERROR, "wrong choice contents arity");
goto fail0;
}
if (!NCDVal_IsString(c_cond)) {
ModuleLog(i, BLOG_ERROR, "wrong choice condition type");
goto fail0;
}
// update result
if (!have_result && ncd_read_boolean(c_cond)) {
o->result = c_result;
have_result = 1;
}
}
// default?
if (!have_result) {
o->result = arg_default_result;
}
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void client_handler (struct instance *o, char *devpath, int have_map, BStringMap map)
{
if (o->devpath && !strcmp(devpath, o->devpath) && !NCDUdevManager_Query(o->i->params->iparams->umanager, o->devpath)) {
// free devpath
free(o->devpath);
// set no devpath
o->devpath = NULL;
// signal down
NCDModuleInst_Backend_Down(o->i);
} else {
const BStringMap *cache_map = NCDUdevManager_Query(o->i->params->iparams->umanager, devpath);
if (!cache_map) {
goto out;
}
int match_res = regexec(&o->reg, devpath, 0, NULL, 0);
const char *interface = BStringMap_Get(cache_map, "INTERFACE");
const char *ifindex_str = BStringMap_Get(cache_map, "IFINDEX");
uintmax_t ifindex;
if (!(!match_res && interface && MemRef_Equal(MemRef_MakeCstr(interface), o->ifname) && ifindex_str && parse_unsigned_integer(MemRef_MakeCstr(ifindex_str), &ifindex))) {
goto out;
}
if (o->devpath && (strcmp(o->devpath, devpath) || o->ifindex != ifindex)) {
// free devpath
free(o->devpath);
// set no devpath
o->devpath = NULL;
// signal down
NCDModuleInst_Backend_Down(o->i);
}
if (!o->devpath) {
// grab devpath
o->devpath = devpath;
devpath = NULL;
// remember ifindex
o->ifindex = ifindex;
// signal up
NCDModuleInst_Backend_Up(o->i);
}
}
out:
free(devpath);
if (have_map) {
BStringMap_Free(&map);
}
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// check arguments
NCDValRef ms_start_arg;
NCDValRef ms_stop_arg = NCDVal_NewInvalid();
if (!NCDVal_ListRead(params->args, 1, &ms_start_arg) &&
!NCDVal_ListRead(params->args, 2, &ms_start_arg, &ms_stop_arg)) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail0;
}
uintmax_t ms;
btime_t ms_start;
if (NCDVal_IsString(ms_start_arg) && NCDVal_StringEqualsId(ms_start_arg, NCD_STRING_EMPTY)) {
ms_start = -1;
} else {
if (!ncd_read_uintmax(ms_start_arg, &ms) || ms > INT64_MAX) {
ModuleLog(o->i, BLOG_ERROR, "wrong start time");
goto fail0;
}
ms_start = ms;
}
if (NCDVal_IsInvalid(ms_stop_arg) || (NCDVal_IsString(ms_stop_arg) && NCDVal_StringEqualsId(ms_stop_arg, NCD_STRING_EMPTY))) {
o->ms_stop = -1;
} else {
if (!ncd_read_uintmax(ms_stop_arg, &ms) || ms > INT64_MAX) {
ModuleLog(o->i, BLOG_ERROR, "wrong stop time");
goto fail0;
}
o->ms_stop = ms;
}
// init timer
BTimer_Init(&o->timer, 0, timer_handler, o);
// set not dying
o->dying = 0;
if (ms_start < 0) {
// go up
NCDModuleInst_Backend_Up(i);
} else {
// set timer
BReactor_SetTimerAfter(o->i->params->iparams->reactor, &o->timer, ms_start);
}
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef input_arg;
NCDValRef regex_arg;
if (!NCDVal_ListRead(params->args, 2, &input_arg, ®ex_arg)) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(input_arg) || !NCDVal_IsStringNoNulls(regex_arg)) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail0;
}
o->input = NCDVal_StringMemRef(input_arg);
// make sure we don't overflow regoff_t
if (o->input.len > INT_MAX) {
ModuleLog(o->i, BLOG_ERROR, "input string too long");
goto fail0;
}
// null terminate regex
NCDValNullTermString regex_nts;
if (!NCDVal_StringNullTerminate(regex_arg, ®ex_nts)) {
ModuleLog(i, BLOG_ERROR, "NCDVal_StringNullTerminate failed");
goto fail0;
}
// compile regex
regex_t preg;
int ret = regcomp(&preg, regex_nts.data, REG_EXTENDED);
NCDValNullTermString_Free(®ex_nts);
if (ret != 0) {
ModuleLog(o->i, BLOG_ERROR, "regcomp failed (error=%d)", ret);
goto fail0;
}
// execute match
o->matches[0].rm_so = 0;
o->matches[0].rm_eo = o->input.len;
o->succeeded = (regexec(&preg, o->input.ptr, MAX_MATCHES, o->matches, REG_STARTEND) == 0);
// free regex
regfree(&preg);
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new_templ (void *vo, NCDModuleInst *i, size_t value)
{
struct instance *o = vo;
o->i = i;
// set value
o->value = value;
// signal up
NCDModuleInst_Backend_Up(o->i);
}
static void addr_func_init_templ (void *vo, NCDModuleInst *i, uint32_t addr)
{
struct addr_instance *o = vo;
o->i = i;
// remember address
o->addr = addr;
// signal up
NCDModuleInst_Backend_Up(i);
}
static void func_new (NCDModuleInst *i)
{
// allocate instance
struct instance *o = malloc(sizeof(*o));
if (!o) {
ModuleLog(i, BLOG_ERROR, "failed to allocate instance");
goto fail0;
}
NCDModuleInst_Backend_SetUser(i, o);
// init arguments
o->i = i;
// check arguments
NCDValue *template_name_arg;
NCDValue *args_arg;
if (!NCDValue_ListRead(o->i->args, 2, &template_name_arg, &args_arg)) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail1;
}
if (NCDValue_Type(template_name_arg) != NCDVALUE_STRING || NCDValue_Type(args_arg) != NCDVALUE_LIST) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail1;
}
// signal up.
// Do it before creating the process so that the process starts initializing before our own process continues.
NCDModuleInst_Backend_Up(o->i);
// copy arguments
NCDValue args;
if (!NCDValue_InitCopy(&args, args_arg)) {
ModuleLog(o->i, BLOG_ERROR, "NCDValue_InitCopy failed");
goto fail1;
}
// create process
if (!NCDModuleProcess_Init(&o->process, o->i, NCDValue_StringValue(template_name_arg), args, o, (NCDModuleProcess_handler_event)process_handler_event)) {
ModuleLog(o->i, BLOG_ERROR, "NCDModuleProcess_Init failed");
NCDValue_Free(&args);
goto fail1;
}
// set state working
o->state = STATE_WORKING;
return;
fail1:
free(o);
fail0:
NCDModuleInst_Backend_SetError(i);
NCDModuleInst_Backend_Dead(i);
}
static void timer_handler (void *vo)
{
struct instance *o = vo;
if (!o->dying) {
// signal up
NCDModuleInst_Backend_Up(o->i);
} else {
// die
instance_free(o);
}
}
static void substr_func_new_common (void *vo, NCDModuleInst *i, const char *data, size_t length, int is_external, BRefTarget *external_ref_target)
{
struct substr_instance *o = vo;
o->i = i;
o->data = data;
o->length = length;
o->is_external = is_external;
o->external_ref_target = external_ref_target;
NCDModuleInst_Backend_Up(i);
}
static void func_new (NCDModuleInst *i)
{
// allocate instance
struct instance *o = malloc(sizeof(*o));
if (!o) {
ModuleLog(i, BLOG_ERROR, "failed to allocate instance");
goto fail0;
}
NCDModuleInst_Backend_SetUser(i, o);
// init arguments
o->i = i;
// init string
ExpString s;
if (!ExpString_Init(&s)) {
ModuleLog(i, BLOG_ERROR, "ExpString_Init failed");
goto fail1;
}
// append arguments
NCDValue *arg = NCDValue_ListFirst(o->i->args);
while (arg) {
if (NCDValue_Type(arg) != NCDVALUE_STRING) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail2;
}
if (!ExpString_Append(&s, NCDValue_StringValue(arg))) {
ModuleLog(i, BLOG_ERROR, "ExpString_Append failed");
goto fail2;
}
arg = NCDValue_ListNext(o->i->args, arg);
}
// set string
o->string = ExpString_Get(&s);
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail2:
ExpString_Free(&s);
fail1:
free(o);
fail0:
NCDModuleInst_Backend_SetError(i);
NCDModuleInst_Backend_Dead(i);
}
static void println_func_new (void *unused, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
if (!check_args(i, params)) {
goto fail0;
}
do_print(i, params->args, 1);
NCDModuleInst_Backend_Up(i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void stat_func_new_common (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params, int is_lstat)
{
struct stat_instance *o = vo;
o->i = i;
NCDValRef filename_arg;
if (!NCDVal_ListRead(params->args, 1, &filename_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(filename_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
o->succeeded = 0;
if (!NCDVal_IsStringNoNulls(filename_arg)) {
goto out;
}
// null terminate filename
NCDValNullTermString filename_nts;
if (!NCDVal_StringNullTerminate(filename_arg, &filename_nts)) {
ModuleLog(i, BLOG_ERROR, "NCDVal_StringNullTerminate failed");
goto fail0;
}
int res;
if (is_lstat) {
res = lstat(filename_nts.data, &o->result);
} else {
res = stat(filename_nts.data, &o->result);
}
NCDValNullTermString_Free(&filename_nts);
if (res < 0) {
goto out;
}
o->succeeded = 1;
out:
NCDModuleInst_Backend_Up(i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *unused, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
// check arguments
if (!NCDVal_ListRead(params->args, 0)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
// go up
NCDModuleInst_Backend_Up(i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params, int is_not, int is_or)
{
struct instance *o = vo;
o->i = i;
// compute value from arguments
if (is_not) {
NCDValRef arg;
if (!NCDVal_ListRead(params->args, 1, &arg)) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail0;
}
int arg_val;
if (!ncd_read_boolean(arg, &arg_val)) {
ModuleLog(o->i, BLOG_ERROR, "bad argument");
goto fail0;
}
o->value = !arg_val;
} else {
o->value = (is_or ? 0 : 1);
size_t count = NCDVal_ListCount(params->args);
for (size_t j = 0; j < count; j++) {
NCDValRef arg = NCDVal_ListGet(params->args, j);
int this_value;
if (!ncd_read_boolean(arg, &this_value)) {
ModuleLog(o->i, BLOG_ERROR, "bad argument");
goto fail0;
}
if (is_or) {
o->value = o->value || this_value;
} else {
o->value = o->value && this_value;
}
}
}
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void monitor_handler (struct instance *o, struct rfkill_event event)
{
if (event.idx != o->index) {
return;
}
int was_up = o->up;
o->up = (event.op != RFKILL_OP_DEL && !event.soft && !event.hard);
if (o->up && !was_up) {
NCDModuleInst_Backend_Up(o->i);
}
else if (!o->up && was_up) {
NCDModuleInst_Backend_Down(o->i);
}
}
static void rprint_func_new_common (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params, int ln)
{
struct rprint_instance *o = vo;
o->i = i;
o->args = params->args;
o->ln = ln;
if (!check_args(i, params)) {
goto fail0;
}
NCDModuleInst_Backend_Up(i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// check arguments
if (!NCDVal_ListRead(params->args, 0)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
// signal up
NCDModuleInst_Backend_Up(i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void new_templ (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params, compute_func cfunc)
{
struct instance *o = vo;
o->i = i;
NCDValRef v1_arg;
NCDValRef v2_arg;
if (!NCDVal_ListRead(params->args, 2, &v1_arg, &v2_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
o->result = cfunc(v1_arg, v2_arg);
NCDModuleInst_Backend_Up(i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void go_func_new (void *unused, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
// check arguments
if (!NCDVal_ListRead(params->args, 0)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
// get backtrack point
NCDModuleInst *backtrack_point_inst = params->method_user;
// go up (after toggling)
NCDModuleInst_Backend_Up(i);
// toggle backtrack point
NCDModuleInst_Backend_DownUp(backtrack_point_inst);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new_templ (NCDModuleInst *i, size_t value)
{
// allocate instance
struct instance *o = malloc(sizeof(*o));
if (!o) {
ModuleLog(i, BLOG_ERROR, "failed to allocate instance");
goto fail0;
}
NCDModuleInst_Backend_SetUser(i, o);
// init arguments
o->i = i;
o->value = value;
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail0:
NCDModuleInst_Backend_SetError(i);
NCDModuleInst_Backend_Dead(i);
}