*** /dev/null Tue Nov 4 09:35:49 2025
--- - Tue Nov 4 09:36:31 2025
***************
*** 0 ****
--- 1,607 ----
+ /*
+ ** OSSP cfg - Configuration Parsing
+ ** Copyright (c) 2002-2004 Ralf S. Engelschall <rse@engelschall.com>
+ ** Copyright (c) 2002-2004 The OSSP Project <http://www.ossp.org/>
+ ** Copyright (c) 2002-2004 Cable & Wireless <http://www.cw.com/>
+ **
+ ** This file is part of OSSP cfg, a configuration parsing library which
+ ** can be found at http://www.ossp.org/pkg/lib/cfg/.
+ **
+ ** Permission to use, copy, modify, and distribute this software for
+ ** any purpose with or without fee is hereby granted, provided that
+ ** the above copyright notice and this permission notice appear in all
+ ** copies.
+ **
+ ** THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ ** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ ** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ ** IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
+ ** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ ** USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ ** OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ ** SUCH DAMAGE.
+ **
+ ** cfg.xs: Perl Binding (Perl/XS part)
+ */
+
+ #include "EXTERN.h"
+ #include "perl.h"
+ #include "XSUB.h"
+
+ #include "cfg.h"
+
+ /* find/apply callback context */
+ typedef struct {
+ SV *fct;
+ SV *ctx;
+ } cb_ctx_t;
+
+ /* find/apply callback wrapper */
+ static cfg_rc_t cb_fct(cfg_t *cfg, cfg_node_t *node, void *_ctx)
+ {
+ cb_ctx_t *ctx = (cb_ctx_t *)ctx;
+ cfg_rc_t rc;
+ dSP;
+
+ ENTER; SAVETMPS;
+ PUSHMARK(SP);
+ XPUSHs(sv_2mortal(newSViv(PTR2IV(cfg))));
+ XPUSHs(sv_2mortal(newSViv(PTR2IV(node))));
+ XPUSHs(ctx->ctx);
+ PUTBACK;
+ if (call_sv(ctx->fct, G_SCALAR) != 1)
+ croak("cfg_node_find: expected single scalar as return value from callback");
+ SPAGAIN;
+ rc = (cfg_rc_t)SvIV(POPs);
+ FREETMPS; LEAVE;
+ return rc;
+ }
+
+ MODULE = OSSP::cfg PACKAGE = OSSP::cfg
+
+ void
+ constant(sv)
+ PREINIT:
+ dXSTARG;
+ STRLEN len;
+ int i;
+ static struct {
+ const char *name;
+ int value;
+ } constant_table[] = {
+ { "CFG_OK", CFG_OK },
+ { "CFG_ERR_ARG", CFG_ERR_ARG },
+ { "CFG_ERR_USE", CFG_ERR_USE },
+ { "CFG_ERR_MEM", CFG_ERR_MEM },
+ { "CFG_ERR_SYS", CFG_ERR_SYS },
+ { "CFG_ERR_FMT", CFG_ERR_FMT },
+ { "CFG_ERR_INT", CFG_ERR_INT },
+ { "CFG_ERR_SYN", CFG_ERR_SYN },
+ { "CFG_ERR_NDE", CFG_ERR_NDE },
+ { "CFG_FMT_CFG", CFG_FMT_CFG },
+ { "CFG_FMT_XML", CFG_FMT_XML },
+ { "CFG_NODE_TYPE_SEQ", CFG_NODE_TYPE_SEQ },
+ { "CFG_NODE_TYPE_DIR", CFG_NODE_TYPE_DIR },
+ { "CFG_NODE_TYPE_OPT", CFG_NODE_TYPE_OPT },
+ { "CFG_NODE_TYPE_ARG", CFG_NODE_TYPE_ARG },
+ { "CFG_NODE_ATTR_PARENT", CFG_NODE_ATTR_PARENT },
+ { "CFG_NODE_ATTR_LBROTH", CFG_NODE_ATTR_LBROTH },
+ { "CFG_NODE_ATTR_RBROTH", CFG_NODE_ATTR_RBROTH },
+ { "CFG_NODE_ATTR_CHILD1", CFG_NODE_ATTR_CHILD1 },
+ { "CFG_NODE_ATTR_CHILDL", CFG_NODE_ATTR_CHILDL },
+ { "CFG_NODE_ATTR_CHILDS", CFG_NODE_ATTR_CHILDS },
+ { "CFG_NODE_ATTR_NODES", CFG_NODE_ATTR_NODES },
+ { "CFG_NODE_ATTR_DEPTH", CFG_NODE_ATTR_DEPTH },
+ { "CFG_NODE_ATTR_SRCNAME", CFG_NODE_ATTR_SRCNAME },
+ { "CFG_NODE_ATTR_SRCPOS", CFG_NODE_ATTR_SRCPOS },
+ { "CFG_NODE_ATTR_TYPE", CFG_NODE_ATTR_TYPE },
+ { "CFG_NODE_ATTR_TOKEN", CFG_NODE_ATTR_TOKEN },
+ { "CFG_NODE_ATTR_DATA", CFG_NODE_ATTR_DATA },
+ { "CFG_DATA_TYPE_PTR", CFG_DATA_TYPE_PTR },
+ { "CFG_DATA_TYPE_STR", CFG_DATA_TYPE_STR },
+ { "CFG_DATA_TYPE_INT", CFG_DATA_TYPE_INT },
+ { "CFG_DATA_TYPE_FLT", CFG_DATA_TYPE_FLT },
+ { "CFG_DATA_CTRL_CLONE", CFG_DATA_CTRL_CLONE },
+ { "CFG_DATA_CTRL_DESTROY", CFG_DATA_CTRL_DESTROY },
+ { "CFG_DATA_ATTR_TYPE", CFG_DATA_ATTR_TYPE },
+ { "CFG_DATA_ATTR_VALUE", CFG_DATA_ATTR_VALUE },
+ { "CFG_DATA_ATTR_CTRL", CFG_DATA_ATTR_CTRL }
+ };
+ INPUT:
+ SV *sv;
+ const char *s = SvPV(sv, len);
+ PPCODE:
+ for (i = 0; i < sizeof(constant_table)/sizeof(constant_table[0]); i++) {
+ if (strcmp(s, constant_table[i].name) == 0) {
+ EXTEND(SP, 1);
+ PUSHs(&PL_sv_undef);
+ PUSHi(constant_table[i].value);
+ break;
+ }
+ }
+ if (i == sizeof(constant_table)/sizeof(constant_table[0])) {
+ sv = sv_2mortal(newSVpvf("unknown contant OSSP::cfg::%s", s));
+ PUSHs(sv);
+ }
+
+ cfg_rc_t
+ cfg_create(cfg)
+ PROTOTYPE:
+ $
+ INPUT:
+ cfg_t *&cfg = NO_INIT
+ CODE:
+ RETVAL = cfg_create(&cfg);
+ OUTPUT:
+ cfg
+ RETVAL
+
+ cfg_rc_t
+ cfg_destroy(cfg)
+ PROTOTYPE:
+ $
+ INPUT:
+ cfg_t *cfg
+ CODE:
+ RETVAL = cfg_destroy(cfg);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_error(cfg,rc,error)
+ PROTOTYPE:
+ $$$
+ INPUT:
+ cfg_t *cfg
+ cfg_rc_t rc
+ char *&error = NO_INIT
+ CODE:
+ RETVAL = cfg_error(cfg, rc, &error);
+ OUTPUT:
+ error
+ RETVAL
+
+ long
+ cfg_version()
+ PROTOTYPE:
+ INPUT:
+ CODE:
+ RETVAL = cfg_version();
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_import(cfg,node,fmt,in_ptr,in_len)
+ PROTOTYPE:
+ $$$$$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_fmt_t fmt
+ const char *in_ptr
+ size_t in_len
+ CODE:
+ if (ST(4) == &PL_sv_undef)
+ in_len = sv_len(ST(3));
+ RETVAL = cfg_import(cfg, node, fmt, in_ptr, in_len);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_export(cfg,node,fmt,ex_ptr,ex_len)
+ PROTOTYPE:
+ $$$$$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_fmt_t fmt
+ char *&ex_ptr = NO_INIT
+ size_t ex_len
+ CODE:
+ RETVAL = cfg_export(cfg, node, fmt, &ex_ptr, ex_len);
+ OUTPUT:
+ ex_ptr
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_create(cfg,node)
+ PROTOTYPE:
+ $$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *&node = NO_INIT
+ CODE:
+ RETVAL = cfg_node_create(cfg, &node);
+ OUTPUT:
+ node
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_destroy(cfg,node)
+ PROTOTYPE:
+ $$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ CODE:
+ RETVAL = cfg_node_destroy(cfg, node);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_clone(cfg,node,node2)
+ PROTOTYPE:
+ $$$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_t *&node2 = NO_INIT
+ CODE:
+ RETVAL = cfg_node_clone(cfg, node, &node2);
+ OUTPUT:
+ node2
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_set(cfg,node,attr,va_arg1)
+ CASE: ( (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_PARENT \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_LBROTH \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_RBROTH \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_CHILD1 \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_CHILDL )
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ cfg_node_t *va_arg1
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, va_arg1);
+ OUTPUT:
+ RETVAL
+ CASE: ( (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_CHILDS \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_NODES \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_DEPTH \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_SRCPOS )
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ int va_arg1
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, va_arg1);
+ OUTPUT:
+ RETVAL
+ CASE: ( (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_SRCNAME \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_TOKEN )
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ char *va_arg1
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, va_arg1);
+ OUTPUT:
+ RETVAL
+ CASE: ((cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_TYPE)
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ cfg_node_type_t va_arg1
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, va_arg1);
+ OUTPUT:
+ RETVAL
+ CASE: ((cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_DATA)
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ cfg_data_t *va_arg1
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, va_arg1);
+ OUTPUT:
+ RETVAL
+ CASE:
+ PROTOTYPE:
+ $$$;$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_get(cfg,node,attr,va_arg1)
+ CASE: ( (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_PARENT \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_LBROTH \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_RBROTH \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_CHILD1 \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_CHILDL )
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ cfg_node_t *&va_arg1 = NO_INIT
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, &va_arg1);
+ OUTPUT:
+ va_arg1
+ RETVAL
+ CASE: ( (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_CHILDS \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_NODES \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_DEPTH \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_SRCPOS )
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ int &va_arg1 = NO_INIT
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, &va_arg1);
+ OUTPUT:
+ va_arg1
+ RETVAL
+ CASE: ( (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_SRCNAME \
+ || (cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_TOKEN )
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ char *&va_arg1 = NO_INIT
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, &va_arg1);
+ OUTPUT:
+ va_arg1
+ RETVAL
+ CASE: ((cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_TYPE)
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ cfg_node_type_t &va_arg1 = NO_INIT
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, &va_arg1);
+ OUTPUT:
+ va_arg1
+ RETVAL
+ CASE: ((cfg_node_attr_t)SvIV(ST(2)) == CFG_NODE_ATTR_DATA)
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ cfg_data_t *&va_arg1 = NO_INIT
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr, &va_arg1);
+ OUTPUT:
+ va_arg1
+ RETVAL
+ CASE:
+ PROTOTYPE:
+ $$$;$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t attr
+ CODE:
+ RETVAL = cfg_node_set(cfg, node, attr);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_root(cfg,node)
+ PROTOTYPE:
+ $$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *&node = NO_INIT
+ CODE:
+ RETVAL = cfg_node_root(cfg, &node);
+ OUTPUT:
+ node
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_select(cfg,node,result,spec)
+ PROTOTYPE:
+ $$$$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ SV *&result = NO_INIT
+ const char *spec
+ PREINIT:
+ cfg_node_t **r;
+ CODE:
+ RETVAL = cfg_node_select(cfg, node, &r, "%s", spec);
+ if (RETVAL == CFG_OK) {
+ /* translate C array into Perl array */
+ int i;
+ AV *av = newAV();
+ for (i = 0; r[i] != NULL; i++)
+ av_push(av, newSV(PTR2IV(r[i])));
+ free(r);
+ result = newRV_noinc((SV *)av);
+ }
+ else
+ result = &PL_sv_undef;
+ OUTPUT:
+ result
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_find(cfg,node,cb_fct_cmp,cb_ctx_cmp,cont)
+ PROTOTYPE:
+ $$$$$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ SV *cb_fct_cmp
+ SV *cb_ctx_cmp
+ cfg_node_t *&cont = NO_INIT
+ PREINIT:
+ cb_ctx_t ctx_cmp;
+ CODE:
+ ctx_cmp.fct = cb_fct_cmp;
+ ctx_cmp.ctx = cb_ctx_cmp;
+ RETVAL = cfg_node_find(cfg, node, cb_fct, &ctx_cmp, &cont);
+ OUTPUT:
+ cont
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_apply(cfg,node,cb_fct_cmp,cb_ctx_cmp,cb_fct_cb,cb_ctx_cb)
+ PROTOTYPE:
+ $$$$$$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ SV *cb_fct_cmp
+ SV *cb_ctx_cmp
+ SV *cb_fct_cb
+ SV *cb_ctx_cb
+ PREINIT:
+ cb_ctx_t ctx_cmp;
+ cb_ctx_t ctx_cb;
+ CODE:
+ ctx_cmp.fct = cb_fct_cmp;
+ ctx_cmp.ctx = cb_ctx_cmp;
+ ctx_cb.fct = cb_fct_cb;
+ ctx_cb.ctx = cb_ctx_cb;
+ RETVAL = cfg_node_apply(cfg, node, cb_fct, &ctx_cmp, cb_fct, &ctx_cb);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_cmp(cfg,node,token)
+ PROTOTYPE:
+ $$$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ char *token
+ CODE:
+ RETVAL = cfg_node_cmp(cfg, node, (void *)token);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_link(cfg,node,id,node2)
+ PROTOTYPE:
+ $$$$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ cfg_node_attr_t id
+ cfg_node_t *node2
+ CODE:
+ RETVAL = cfg_node_link(cfg, node, id, node2);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_node_unlink(cfg,node)
+ PROTOTYPE:
+ $$
+ INPUT:
+ cfg_t *cfg
+ cfg_node_t *node
+ CODE:
+ RETVAL = cfg_node_unlink(cfg, node);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_data_set(data,attr,va_arg1)
+ CASE: (cfg_data_attr_t)SvIV(ST(1)) == CFG_DATA_ATTR_TYPE
+ PROTOTYPE:
+ $$$
+ INPUT:
+ cfg_data_t *data
+ cfg_data_attr_t attr
+ cfg_data_type_t va_arg1
+ CODE:
+ RETVAL = cfg_data_set(data, attr, va_arg1);
+ OUTPUT:
+ RETVAL
+ CASE: (cfg_data_attr_t)SvIV(ST(1)) == CFG_DATA_ATTR_VALUE
+ INPUT:
+ cfg_data_t *data
+ cfg_data_attr_t attr
+ PREINIT:
+ cfg_data_type_t type;
+ CODE:
+ if ((RETVAL = cfg_data_get(data, CFG_DATA_ATTR_TYPE, &type)) == CFG_OK) {
+ switch (type) {
+ case CFG_DATA_TYPE_PTR: {
+ void *va_arg1 = INT2PTR(cfg_node_t *, SvIV((SV*)SvRV(ST(2))));
+ RETVAL = cfg_data_set(data, attr, va_arg1);
+ break;
+ }
+ case CFG_DATA_TYPE_STR: {
+ char *va_arg1 = SvPV_nolen(ST(2));
+ RETVAL = cfg_data_set(data, attr, va_arg1);
+ break;
+ }
+ case CFG_DATA_TYPE_INT: {
+ int va_arg1 = SvIV(ST(2));
+ RETVAL = cfg_data_set(data, attr, va_arg1);
+ break;
+ }
+ case CFG_DATA_TYPE_FLT: {
+ double va_arg1 = SvNV(ST(2));
+ RETVAL = cfg_data_set(data, attr, va_arg1);
+ break;
+ }
+ }
+ }
+ OUTPUT:
+ RETVAL
+ CASE: (cfg_data_attr_t)SvIV(ST(1)) == CFG_DATA_ATTR_CTRL
+ INPUT:
+ cfg_data_t *data
+ cfg_data_attr_t attr
+ cfg_data_cb_t va_arg1
+ CODE:
+ RETVAL = cfg_data_set(data, attr, va_arg1);
+ OUTPUT:
+ RETVAL
+
+ cfg_rc_t
+ cfg_data_ctrl(data,ctrl,va_arg1)
+ CASE: (cfg_data_ctrl_t)SvIV(ST(1)) == CFG_DATA_CTRL_CLONE
+ PROTOTYPE:
+ $$;$
+ INPUT:
+ cfg_data_t *data
+ cfg_data_ctrl_t ctrl
+ cfg_data_t *&va_arg1 = NO_INIT
+ CODE:
+ RETVAL = cfg_data_ctrl(data, ctrl, &va_arg1);
+ OUTPUT:
+ va_arg1
+ RETVAL
+ CASE: (cfg_data_attr_t)SvIV(ST(1)) == CFG_DATA_CTRL_DESTROY
+ INPUT:
+ cfg_data_t *data
+ cfg_data_ctrl_t ctrl
+ CODE:
+ RETVAL = cfg_data_ctrl(data, ctrl);
+ OUTPUT:
+ RETVAL
+ CASE:
+ INPUT:
+ cfg_data_t *data
+ cfg_data_ctrl_t ctrl
+ CODE:
+ RETVAL = cfg_data_set(data, ctrl);
+ OUTPUT:
+ RETVAL
+
|
