int
get_prefixed_iri(rdf_db *db, term_t t, atom_t *ap)
{ if ( PL_is_functor(t, FUNCTOR_colon2) )
{ term_t a = PL_new_term_ref();
atom_t alias, local, uri;
_PL_get_arg(1, t, a);
if ( !PL_get_atom(a, &alias) )
return FALSE;
_PL_get_arg(2, t, a);
if ( !PL_get_atom(a, &local) )
return FALSE;
if ( (uri = cached_expansion(alias, local)) )
{ *ap = uri;
return TRUE;
}
if ( (uri = expand_prefix(db, alias, local)) )
{ cache_expansion(alias, local, uri);
*ap = uri;
return TRUE;
}
}
return FALSE;
}
static foreign_t
uri_query_components(term_t string, term_t list)
{ pl_wchar_t *s;
size_t len;
if ( PL_get_wchars(string, &len, &s, CVT_ATOM|CVT_STRING|CVT_LIST) )
{ return unify_query_string_components(list, len, s);
} else if ( PL_is_list(list) )
{ term_t tail = PL_copy_term_ref(list);
term_t head = PL_new_term_ref();
term_t nv = PL_new_term_refs(2);
charbuf out;
int rc;
fill_flags();
init_charbuf(&out);
while( PL_get_list(tail, head, tail) )
{ atom_t fname;
int arity;
if ( PL_is_functor(head, FUNCTOR_equal2) ||
PL_is_functor(head, FUNCTOR_pair2) )
{ _PL_get_arg(1, head, nv+0);
_PL_get_arg(2, head, nv+1);
} else if ( PL_get_name_arity(head, &fname, &arity) && arity == 1 )
{ PL_put_atom(nv+0, fname);
_PL_get_arg(1, head, nv+1);
} else
{ free_charbuf(&out);
return type_error("name_value", head);
}
if ( out.here != out.base )
add_charbuf(&out, '&');
if ( !add_encoded_term_charbuf(&out, nv+0, ESC_QNAME) )
{ free_charbuf(&out);
return FALSE;
}
add_charbuf(&out, '=');
if ( !add_encoded_term_charbuf(&out, nv+1, ESC_QVALUE) )
{ free_charbuf(&out);
return FALSE;
}
}
rc = PL_unify_wchars(string, PL_ATOM, out.here-out.base, out.base);
free_charbuf(&out);
return rc;
} else
{ return PL_get_wchars(string, &len, &s,
CVT_ATOM|CVT_STRING|CVT_LIST|CVT_EXCEPTION);
}
return FALSE;
}
static int get_params(term_t t, clingo_part_t *pv) {
int rc;
atom_t name;
term_t arg;
clingo_symbol_t *values = NULL;
if (!(rc = get_name_arity(t, &name, &pv->size))) {
rc = PL_type_error("callable", t);
goto out;
}
arg = PL_new_term_ref();
if (!(values = malloc(sizeof(*pv->params) * pv->size))) {
rc = PL_resource_error("memory");
goto out;
}
for (size_t i = 0; i < pv->size; i++) {
_PL_get_arg(i + 1, t, arg);
if (!(rc = clingo_status(get_value(arg, &values[i], FALSE)))) {
goto out;
}
}
pv->params = values;
pv->name = PL_atom_chars(name);
values = NULL;
out:
if (values) {
free(values);
}
return rc;
}
static int
get_short_arg_ex(int a, term_t state, short *p)
{ term_t arg = PL_new_term_ref();
_PL_get_arg(a, state, arg);
return get_short_ex(arg, p);
}
static int
get_int_arg(int i, term_t t, term_t a, int *val)
{ GET_LD
_PL_get_arg(i, t, a);
return PL_get_integer_ex(a, val);
}
static int
get_float_arg(int i, term_t t, term_t a, double *val)
{ GET_LD
_PL_get_arg(i, t, a);
return PL_get_float_ex(a, val);
}
static foreign_t
pl_setopt(term_t Socket, term_t opt)
{ int socket;
atom_t a;
int arity;
if ( !tcp_get_socket(Socket, &socket) )
return FALSE;
if ( PL_get_name_arity(opt, &a, &arity) )
{ if ( a == ATOM_reuseaddr && arity == 0 )
{ if ( nbio_setopt(socket, TCP_REUSEADDR, TRUE) == 0 )
return TRUE;
return FALSE;
} else if ( a == ATOM_nodelay && arity <= 1 )
{ int enable, rc;
if ( arity == 0 )
{ enable = TRUE;
} else /*if ( arity == 1 )*/
{ term_t a = PL_new_term_ref();
_PL_get_arg(1, opt, a);
if ( !PL_get_bool(a, &enable) )
return pl_error(NULL, 0, NULL, ERR_DOMAIN, a, "boolean");
}
if ( (rc=nbio_setopt(socket, TCP_NO_DELAY, enable) == 0) )
return TRUE;
if ( rc == -2 )
goto not_implemented;
return FALSE;
} else if ( a == ATOM_broadcast && arity == 0 )
{ if ( nbio_setopt(socket, UDP_BROADCAST, TRUE) == 0 )
return TRUE;
return FALSE;
} else if ( a == ATOM_dispatch && arity == 1 )
{ int val;
term_t a1 = PL_new_term_ref();
if ( PL_get_arg(1, opt, a1) && PL_get_bool(a1, &val) )
{ if ( nbio_setopt(socket, TCP_DISPATCH, val) == 0 )
return TRUE;
return FALSE;
}
} else if ( a == ATOM_nonblock && arity == 0 )
{ if ( nbio_setopt(socket, TCP_NONBLOCK) == 0 )
return TRUE;
return FALSE;
}
}
not_implemented:
return pl_error(NULL, 0, NULL, ERR_DOMAIN, opt, "socket_option");
}
static int
parse_options(term_t options, p_options *info)
{ term_t tail = PL_copy_term_ref(options);
term_t head = PL_new_term_ref();
term_t arg = PL_new_term_ref();
info->window = MAYBE;
while(PL_get_list(tail, head, tail))
{ atom_t name;
int arity;
if ( !PL_get_name_arity(head, &name, &arity) || arity != 1 )
return type_error(head, "option");
_PL_get_arg(1, head, arg);
if ( name == ATOM_stdin )
{ if ( !get_stream(arg, info, &info->streams[0]) )
return FALSE;
} else if ( name == ATOM_stdout )
{ if ( !get_stream(arg, info, &info->streams[1]) )
return FALSE;
} else if ( name == ATOM_stderr )
{ if ( !get_stream(arg, info, &info->streams[2]) )
return FALSE;
} else if ( name == ATOM_process )
{ info->pid = PL_copy_term_ref(arg);
} else if ( name == ATOM_detached )
{ if ( !PL_get_bool(arg, &info->detached) )
return type_error(arg, "boolean");
} else if ( name == ATOM_cwd )
{
#ifdef __WINDOWS__
if ( !PL_get_wchars(arg, NULL, &info->cwd,
CVT_ATOM|CVT_STRING|CVT_EXCEPTION|BUF_MALLOC) )
return FALSE;
#else
if ( !PL_get_chars(arg, &info->cwd,
CVT_ATOM|CVT_STRING|CVT_EXCEPTION|BUF_MALLOC|REP_FN) )
return FALSE;
#endif
} else if ( name == ATOM_window )
{ if ( !PL_get_bool(arg, &info->window) )
return type_error(arg, "boolean");
} else if ( name == ATOM_env )
{ if ( !parse_environment(arg, info) )
return FALSE;
} else
return domain_error(head, "process_option");
}
if ( !PL_get_nil(tail) )
return type_error(tail, "list");
return TRUE;
}
static int get_assumption(term_t t, clingo_symbolic_literal_t *assump) {
if (PL_is_functor(t, FUNCTOR_tilde1)) {
_PL_get_arg(1, t, t);
assump->positive = FALSE;
} else {
assump->positive = TRUE;
}
return get_value(t, &assump->symbol, FALSE);
}
static int
get_text_arg(term_t term, int pos, size_t *len, pl_wchar_t **s, int flags)
{ term_t tmp = PL_new_term_ref();
_PL_get_arg(pos, term, tmp);
if ( PL_is_variable(tmp) )
return FALSE;
if ( !PL_get_wchars(tmp, len, s, flags) )
return -1;
return TRUE;
}
static int
sha_options(term_t options, optval *result)
{ term_t opts = PL_copy_term_ref(options);
term_t opt = PL_new_term_ref();
/* defaults */
memset(result, 0, sizeof(*result));
result->algorithm = ALGORITHM_SHA1;
result->digest_size = SHA1_DIGEST_SIZE;
while(PL_get_list(opts, opt, opts))
{ atom_t aname;
int arity;
if ( PL_get_name_arity(opt, &aname, &arity) && arity == 1 )
{ term_t a = PL_new_term_ref();
_PL_get_arg(1, opt, a);
if ( aname == ATOM_algorithm )
{ atom_t a_algorithm;
result->algorithm_term = a;
if ( !PL_get_atom(a, &a_algorithm) )
return pl_error(NULL, 0, NULL, ERR_TYPE, a, "algorithm");
if ( a_algorithm == ATOM_sha1 )
{ result->algorithm = ALGORITHM_SHA1;
result->digest_size = SHA1_DIGEST_SIZE;
} else if ( a_algorithm == ATOM_sha224 )
{ result->algorithm = ALGORITHM_SHA224;
result->digest_size = SHA224_DIGEST_SIZE;
} else if ( a_algorithm == ATOM_sha256 )
{ result->algorithm = ALGORITHM_SHA256;
result->digest_size = SHA256_DIGEST_SIZE;
} else if ( a_algorithm == ATOM_sha384 )
{ result->algorithm = ALGORITHM_SHA384;
result->digest_size = SHA384_DIGEST_SIZE;
} else if ( a_algorithm == ATOM_sha512 )
{ result->algorithm = ALGORITHM_SHA512;
result->digest_size = SHA512_DIGEST_SIZE;
} else
return pl_error(NULL, 0, NULL, ERR_DOMAIN, a, "algorithm");
}
} else
{ return pl_error(NULL, 0, NULL, ERR_TYPE, opt, "option");
}
}
if ( !PL_get_nil(opts) )
return pl_error("sha_hash", 1, NULL, ERR_TYPE, opts, "list");
return TRUE;
}
static int
get_voff_arg(int i, term_t t, term_t a, int *val)
{ GET_LD
_PL_get_arg(i, t, a);
if ( PL_is_variable(a) )
{ *val = NO_UTC_OFFSET;
return TRUE;
} else
{ return PL_get_integer_ex(a, val);
}
}
static foreign_t pl_clingo_add(term_t ccontrol, term_t params, term_t program) {
char *prog;
clingo_env *ctl;
atom_t name;
size_t arity;
char *param_buf[FAST_PARAMS];
char **prog_params = param_buf;
term_t arg = PL_new_term_ref();
int rc;
if (!(rc = get_clingo(ccontrol, &ctl))) {
goto out;
}
if (!get_name_arity(params, &name, &arity)) {
rc = PL_type_error("callable", params);
goto out;
}
if (arity + 1 > FAST_PARAMS &&
!(prog_params = malloc(sizeof(char *) * arity))) {
rc = PL_resource_error("memory");
goto out;
}
for (size_t i = 0; i < arity; i++) {
_PL_get_arg(i + 1, params, arg);
if (!(rc =
get_null_terminated_string(arg, &prog_params[i], CVT_ATOM))) {
goto out;
}
}
if (!(rc = get_null_terminated_string(program, &prog,
CVT_ATOM | CVT_STRING | CVT_LIST |
BUF_DISCARDABLE))) {
goto out;
}
if (!(rc = clingo_status(
clingo_control_add(ctl->control, PL_atom_chars(name),
(const char **)prog_params, arity, prog)))) {
goto out;
}
out:
if (prog_params != param_buf) {
free(prog_params);
}
return rc;
}
static int
get_tz_arg(int i, term_t t, term_t a, atom_t *tz)
{ GET_LD
atom_t name;
_PL_get_arg(i, t, a);
if ( !PL_is_variable(a) )
{ if ( !PL_get_atom_ex(a, &name) )
fail;
if ( name != ATOM_minus )
*tz = name;
}
succeed;
}
static void
rewrite_callable(atom_t *expected, term_t actual)
{ GET_LD
term_t a = 0;
int loops = 0;
while ( PL_is_functor(actual, FUNCTOR_colon2) )
{ if ( !a )
a = PL_new_term_ref();
_PL_get_arg(1, actual, a);
if ( !PL_is_atom(a) )
{ *expected = ATOM_atom;
PL_put_term(actual, a);
return;
} else
{ _PL_get_arg(2, actual, a);
PL_put_term(actual, a);
}
if ( ++loops > 100 && !PL_is_acyclic(actual) )
break;
}
}
static int
get_exe(term_t exe, p_options *info)
{ int arity;
term_t arg = PL_new_term_ref();
if ( !PL_get_name_arity(exe, &info->exe_name, &arity) )
return type_error(exe, "callable");
PL_put_atom(arg, info->exe_name);
#ifdef __WINDOWS__
if ( !PL_get_wchars(arg, NULL, &info->exe, CVT_ATOM|CVT_EXCEPTION|BUF_MALLOC) )
return FALSE;
if ( !win_command_line(exe, arity, info->exe, &info->cmdline) )
return FALSE;
#else /*__WINDOWS__*/
if ( !PL_get_chars(arg, &info->exe, CVT_ATOM|CVT_EXCEPTION|BUF_MALLOC|REP_FN) )
return FALSE;
if ( !(info->argv = PL_malloc((arity+2)*sizeof(char*))) )
return PL_resource_error("memory");
memset(info->argv, 0, (arity+2)*sizeof(char*));
if ( !(info->argv[0] = PL_malloc(strlen(info->exe)+1)) )
return PL_resource_error("memory");
strcpy(info->argv[0], info->exe);
{ int i;
for(i=1; i<=arity; i++)
{ _PL_get_arg(i, exe, arg);
if ( !PL_get_chars(arg, &info->argv[i],
CVT_ATOMIC|CVT_EXCEPTION|BUF_MALLOC|REP_FN) )
return FALSE;
}
info->argv[i] = NULL;
}
#endif /*__WINDOWS__*/
return TRUE;
}
tcp_get_socket(term_t Socket, int *id)
{ IOSTREAM *s;
int socket;
if ( PL_is_functor(Socket, FUNCTOR_socket1) )
{ term_t a = PL_new_term_ref();
_PL_get_arg(1, Socket, a);
if ( PL_get_integer(a, id) )
return TRUE;
}
if ( PL_get_stream_handle(Socket, &s) )
{ socket = (int)(intptr_t)s->handle;
*id = socket;
return TRUE;
}
return pl_error(NULL, 0, NULL, ERR_ARGTYPE, -1, Socket, "socket");
}
static foreign_t
process_wait(term_t pid, term_t code, term_t options)
{ pid_t p;
wait_options opts;
term_t tail = PL_copy_term_ref(options);
term_t head = PL_new_term_ref();
term_t arg = PL_new_term_ref();
if ( !get_pid(pid, &p) )
return FALSE;
memset(&opts, 0, sizeof(opts));
while(PL_get_list(tail, head, tail))
{ atom_t name;
int arity;
if ( !PL_get_name_arity(head, &name, &arity) || arity != 1 )
return type_error(head, "option");
_PL_get_arg(1, head, arg);
if ( name == ATOM_timeout )
{ atom_t a;
if ( !(PL_get_atom(arg, &a) && a == ATOM_infinite) )
{ if ( !PL_get_float(arg, &opts.timeout) )
return type_error(arg, "timeout");
opts.has_timeout = TRUE;
}
} else if ( name == ATOM_release )
{ if ( !PL_get_bool(arg, &opts.release) )
return type_error(arg, "boolean");
if ( opts.release == FALSE )
return domain_error(arg, "true");
} else
return domain_error(head, "process_wait_option");
}
if ( !PL_get_nil(tail) )
return type_error(tail, "list");
return wait_for_pid(p, code, &opts);
}
static int
md5_options(term_t options, optval *result)
{ term_t opts = PL_copy_term_ref(options);
term_t opt = PL_new_term_ref();
/* defaults */
memset(result, 0, sizeof(*result));
result->encoding = REP_UTF8;
while(PL_get_list(opts, opt, opts))
{ atom_t aname;
size_t arity;
if ( PL_get_name_arity(opt, &aname, &arity) && arity == 1 )
{ term_t a = PL_new_term_ref();
_PL_get_arg(1, opt, a);
if ( aname == ATOM_encoding )
{ atom_t a_enc;
if ( !PL_get_atom_ex(a, &a_enc) )
return FALSE;
if ( a_enc == ATOM_utf8 )
result->encoding = REP_UTF8;
else if ( a_enc == ATOM_octet )
result->encoding = REP_ISO_LATIN_1;
else
return PL_domain_error("encoding", a);
}
} else
{ return PL_type_error("option", opt);
}
}
if ( !PL_get_nil(opts) )
return PL_type_error("list", opts);
return TRUE;
}
static int
get_stream(term_t t, p_options *info, p_stream *stream)
{ atom_t a;
if ( PL_get_atom(t, &a) )
{ if ( a == ATOM_null )
{ stream->type = std_null;
return TRUE;
} else if ( a == ATOM_std )
{ stream->type = std_std;
return TRUE;
} else
{ return domain_error(t, "process_stream");
}
} else if ( PL_is_functor(t, FUNCTOR_pipe1) )
{ stream->term = PL_new_term_ref();
_PL_get_arg(1, t, stream->term);
stream->type = std_pipe;
info->pipes++;
return TRUE;
} else
return type_error(t, "process_stream");
}
static int
get_timer(term_t t, Event *ev)
{ if ( PL_is_functor(t, FUNCTOR_alarm1) )
{ term_t a = PL_new_term_ref();
void *p;
_PL_get_arg(1, t, a);
if ( PL_get_pointer(a, &p) )
{ Event e = p;
if ( e->magic == EV_MAGIC )
{ *ev = e;
return TRUE;
} else
{ return pl_error("get_timer", 1, NULL,
ERR_DOMAIN, t, "alarm");
}
}
}
return pl_error("get_timer", 1, NULL,
ERR_ARGTYPE, 1, t, "alarm");
}
static int
get_dst_arg(int i, term_t t, term_t a, int *val)
{ GET_LD
atom_t name;
_PL_get_arg(i, t, a);
if ( PL_get_atom(a, &name) )
{ if ( name == ATOM_true )
{ *val = TRUE;
return TRUE;
} else if ( name == ATOM_false )
{ *val = FALSE;
return TRUE;
} else if ( name == ATOM_minus )
{ *val = -1;
return TRUE;
}
} else if ( PL_is_variable(a) )
{ *val = -2;
return TRUE;
}
return PL_get_bool_ex(a, val); /* generate an error */
}
static int
win_command_line(term_t t, int arity, const wchar_t *exe, wchar_t **cline)
{ if ( arity > 0 )
{ arg_string *av = PL_malloc((arity+1)*sizeof(*av));
term_t arg = PL_new_term_ref();
size_t cmdlen;
wchar_t *cmdline, *o;
const wchar_t *b;
int i;
if ( (b=wcsrchr(exe, '\\')) )
b++;
else
b = exe;
av[0].text = (wchar_t*)b;
av[0].len = wcslen(av[0].text);
set_quote(&av[0]);
cmdlen = av[0].len+(av[0].quote?2:0)+1;
for( i=1; i<=arity; i++)
{ _PL_get_arg(i, t, arg);
if ( !PL_get_wchars(arg, &av[i].len, &av[i].text,
CVT_ATOMIC|CVT_EXCEPTION|BUF_MALLOC) )
return FALSE;
if ( wcslen(av[i].text) != av[i].len )
return domain_error(arg, "no_zero_code_atom");
if ( !set_quote(&av[i]) )
return domain_error(arg, "dos_quotable_atom");
cmdlen += av[i].len+(av[i].quote?2:0)+1;
}
cmdline = PL_malloc(cmdlen*sizeof(wchar_t));
for( o=cmdline,i=0; i<=arity; )
{ wchar_t *s = av[i].text;
if ( av[i].quote )
*o++ = av[i].quote;
wcsncpy(o, s, av[i].len);
o += av[i].len;
if ( i > 0 )
PL_free(s); /* do not free shared exename */
if ( av[i].quote )
*o++ = av[i].quote;
if (++i <= arity)
*o++ = ' ';
}
*o = 0;
PL_free(av);
*cline = cmdline;
} else
{ *cline = NULL;
}
return TRUE;
}
static foreign_t
udp_receive(term_t Socket, term_t Data, term_t From, term_t options)
{ struct sockaddr_in sockaddr;
#ifdef __WINDOWS__
int alen = sizeof(sockaddr);
#else
socklen_t alen = sizeof(sockaddr);
#endif
int socket;
int flags = 0;
char buf[UDP_MAXDATA];
ssize_t n;
int as = PL_STRING;
if ( !PL_get_nil(options) )
{ term_t tail = PL_copy_term_ref(options);
term_t head = PL_new_term_ref();
term_t arg = PL_new_term_ref();
while(PL_get_list(tail, head, tail))
{ atom_t name;
int arity;
if ( PL_get_name_arity(head, &name, &arity) && arity == 1 )
{ _PL_get_arg(1, head, arg);
if ( name == ATOM_as )
{ atom_t a;
if ( !PL_get_atom(arg, &a) )
return pl_error(NULL, 0, NULL, ERR_TYPE, head, "atom");
if ( a == ATOM_atom )
as = PL_ATOM;
else if ( a == ATOM_codes )
as = PL_CODE_LIST;
else if ( a == ATOM_string )
as = PL_STRING;
else
return pl_error(NULL, 0, NULL, ERR_DOMAIN, arg, "as_option");
}
} else
return pl_error(NULL, 0, NULL, ERR_TYPE, head, "option");
}
if ( !PL_get_nil(tail) )
return pl_error(NULL, 0, NULL, ERR_TYPE, tail, "list");
}
if ( !tcp_get_socket(Socket, &socket) ||
!nbio_get_sockaddr(From, &sockaddr) )
return FALSE;
if ( (n=nbio_recvfrom(socket, buf, sizeof(buf), flags,
(struct sockaddr*)&sockaddr, &alen)) == -1 )
return nbio_error(errno, TCP_ERRNO);
if ( !PL_unify_chars(Data, as, n, buf) )
return FALSE;
return unify_address(From, &sockaddr);
}
static foreign_t
pl_new_order_table(term_t name, term_t options)
{ OrdTable t = malloc(sizeof(ordtable));
term_t tail = PL_copy_term_ref(options);
term_t head = PL_new_term_ref();
exact_table(t);
if ( !PL_get_atom(name, &t->name) )
{ free(t);
return error(ERR_INSTANTIATION, "new_order_table/2", 1, name);
}
while(PL_get_list(tail, head, tail))
{ atom_t name;
int arity;
if ( PL_get_name_arity(head, &name, &arity) )
{ if ( name == ATOM_case_insensitive )
{ case_insensitive_table(t);
} else if ( name == ATOM_iso_latin_1 )
{ iso_latin_1_table(t);
} else if ( name == ATOM_iso_latin_1_case_insensitive )
{ iso_latin_1_case_table(t);
} else if ( name == ATOM_copy && arity == 1 )
{ term_t a = PL_new_term_ref();
OrdTable from;
_PL_get_arg(1, head, a);
if ( get_order_table(a, &from) )
{ copy_table(t, from);
} else
{ free(t);
return FALSE;
}
} else if ( arity == 1 )
{ fid_t fid = PL_open_foreign_frame();
term_t a = PL_new_term_ref();
_PL_get_arg(1, head, a);
if ( !parse_set(t, name, a) )
goto err1;
PL_close_foreign_frame(fid);
} else if ( name == ATOM_eq && arity == 2 )
{ fid_t fid = PL_open_foreign_frame();
term_t c = PL_new_term_ref();
int from, to;
if ( !PL_get_arg(1, head, c) || !get_char(c, &from) ||
!PL_get_arg(2, head, c) || !get_char(c, &to) )
{ free(t);
return FALSE;
}
ORD(t, from) = to;
PL_close_foreign_frame(fid);
} else
goto err1;
} else
{ err1:
free(t);
return error(ERR_INSTANTIATION, "new_order_table/2", 2, options);
}
}
if ( !PL_get_nil(tail) )
goto err1;
register_table(t);
PL_succeed;
}
bool
scan_options(term_t options, int flags, atom_t optype,
const opt_spec *specs, ...)
{ GET_LD
va_list args;
const opt_spec *s;
optvalue values[MAXOPTIONS];
term_t list = PL_copy_term_ref(options);
term_t head = PL_new_term_ref();
term_t tmp = PL_new_term_ref();
term_t val = PL_new_term_ref();
int n;
if ( truePrologFlag(PLFLAG_ISO) )
flags |= OPT_ALL;
va_start(args, specs);
for( n=0, s = specs; s->name; s++, n++ )
values[n].ptr = va_arg(args, void *);
va_end(args);
while ( PL_get_list(list, head, list) )
{ atom_t name;
int arity;
if ( PL_get_name_arity(head, &name, &arity) )
{ if ( name == ATOM_equals && arity == 2 )
{ _PL_get_arg(1, head, tmp);
if ( !PL_get_atom(tmp, &name) )
goto itemerror;
_PL_get_arg(2, head, val);
} else if ( arity == 1 )
{ _PL_get_arg(1, head, val);
} else if ( arity == 0 )
PL_put_atom(val, ATOM_true);
} else if ( PL_is_variable(head) )
{ return PL_error(NULL, 0, NULL, ERR_INSTANTIATION);
} else
{ itemerror:
return PL_error(NULL, 0, NULL, ERR_DOMAIN, optype, head);
}
for( n=0, s = specs; s->name; n++, s++ )
{ if ( s->name == name )
{ switch((s->type & OPT_TYPE_MASK))
{ case OPT_BOOL:
{ int bval;
if ( !PL_get_bool_ex(val, &bval) )
return FALSE;
*values[n].b = bval;
break;
}
case OPT_INT:
{ if ( !PL_get_integer_ex(val, values[n].i) )
return FALSE;
break;
}
case OPT_LONG:
{ if ( (s->type & OPT_INF) && PL_is_inf(val) )
*values[n].l = LONG_MAX;
else if ( !PL_get_long_ex(val, values[n].l) )
return FALSE;
break;
}
case OPT_NATLONG:
{ if ( !PL_get_long_ex(val, values[n].l) )
return FALSE;
if ( *(values[n].l) <= 0 )
return PL_error(NULL, 0, NULL, ERR_DOMAIN,
ATOM_not_less_than_one, val);
break;
}
case OPT_SIZE:
{ if ( (s->type & OPT_INF) && PL_is_inf(val) )
*values[n].sz = (size_t)-1;
else if ( !PL_get_size_ex(val, values[n].sz) )
return FALSE;
break;
}
case OPT_DOUBLE:
{ if ( !PL_get_float_ex(val, values[n].f) )
return FALSE;
break;
}
case OPT_STRING:
{ char *str;
if ( !PL_get_chars(val, &str, CVT_ALL|CVT_EXCEPTION) ) /* copy? */
return FALSE;
*values[n].s = str;
break;
}
case OPT_ATOM:
{ atom_t a;
if ( !PL_get_atom_ex(val, &a) )
return FALSE;
*values[n].a = a;
break;
}
#ifdef O_LOCALE
case OPT_LOCALE:
{ PL_locale *l;
PL_locale **lp = values[n].ptr;
if ( !getLocaleEx(val, &l) )
return FALSE;
*lp = l;
break;
}
#endif
case OPT_TERM:
{ *values[n].t = val;
val = PL_new_term_ref(); /* can't reuse anymore */
break;
}
default:
assert(0);
fail;
}
break;
}
}
if ( !s->name && (flags & OPT_ALL) )
goto itemerror;
}
if ( !PL_get_nil(list) )
return PL_error(NULL, 0, NULL, ERR_TYPE, ATOM_list, list);
succeed;
}
static foreign_t
udp_receive(term_t Socket, term_t Data, term_t From, term_t options)
{ struct sockaddr_in sockaddr;
#ifdef __WINDOWS__
int alen = sizeof(sockaddr);
#else
socklen_t alen = sizeof(sockaddr);
#endif
int socket;
int flags = 0;
char smallbuf[UDP_DEFAULT_BUFSIZE];
char *buf = smallbuf;
int bufsize = UDP_DEFAULT_BUFSIZE;
term_t varport = 0;
ssize_t n;
int as = PL_STRING;
int rc;
if ( !PL_get_nil(options) )
{ term_t tail = PL_copy_term_ref(options);
term_t head = PL_new_term_ref();
term_t arg = PL_new_term_ref();
while(PL_get_list(tail, head, tail))
{ atom_t name;
size_t arity;
if ( PL_get_name_arity(head, &name, &arity) && arity == 1 )
{ _PL_get_arg(1, head, arg);
if ( name == ATOM_as )
{ atom_t a;
if ( !PL_get_atom(arg, &a) )
return pl_error(NULL, 0, NULL, ERR_TYPE, head, "atom");
if ( a == ATOM_atom )
as = PL_ATOM;
else if ( a == ATOM_codes )
as = PL_CODE_LIST;
else if ( a == ATOM_string )
as = PL_STRING;
else
return pl_error(NULL, 0, NULL, ERR_DOMAIN, arg, "as_option");
} else if ( name == ATOM_max_message_size )
{ if ( !PL_get_integer(arg, &bufsize) )
return pl_error(NULL, 0, NULL, ERR_TYPE, arg, "integer");
if ( bufsize < 0 || bufsize > UDP_MAXDATA )
return pl_error(NULL, 0, NULL, ERR_DOMAIN, arg, "0 - 65535");
}
} else
return pl_error(NULL, 0, NULL, ERR_TYPE, head, "option");
}
if ( !PL_get_nil(tail) )
return pl_error(NULL, 0, NULL, ERR_TYPE, tail, "list");
}
if ( !tcp_get_socket(Socket, &socket) ||
!nbio_get_sockaddr(From, &sockaddr, &varport) )
return FALSE;
if ( bufsize > UDP_DEFAULT_BUFSIZE )
{ if ( !(buf = malloc(bufsize)) )
return pl_error(NULL, 0, NULL, ERR_RESOURCE, "memory");
}
if ( (n=nbio_recvfrom(socket, buf, bufsize, flags,
(struct sockaddr*)&sockaddr, &alen)) == -1 )
{ rc = nbio_error(errno, TCP_ERRNO);
goto out;
}
rc = ( PL_unify_chars(Data, as, n, buf) &&
unify_address(From, &sockaddr)
);
out:
if ( buf != smallbuf )
free(buf);
return rc;
}
static foreign_t
cgi_property(term_t cgi, term_t prop)
{ IOSTREAM *s;
cgi_context *ctx;
term_t arg = PL_new_term_ref();
atom_t name;
int arity;
int rc = TRUE;
if ( !get_cgi_stream(cgi, &s, &ctx) )
return FALSE;
if ( !PL_get_name_arity(prop, &name, &arity) || arity != 1 )
{ rc = type_error(prop, "cgi_property");
goto out;
}
_PL_get_arg(1, prop, arg);
if ( name == ATOM_request )
{ if ( ctx->request )
rc = unify_record(arg, ctx->request);
else
rc = PL_unify_nil(arg);
} else if ( name == ATOM_header )
{ if ( ctx->header )
rc = unify_record(arg, ctx->header);
else
rc = PL_unify_nil(arg);
} else if ( name == ATOM_id )
{ rc = PL_unify_int64(arg, ctx->id);
} else if ( name == ATOM_client )
{ rc = PL_unify_stream(arg, ctx->stream);
} else if ( name == ATOM_transfer_encoding )
{ rc = PL_unify_atom(arg, ctx->transfer_encoding);
} else if ( name == ATOM_connection )
{ rc = PL_unify_atom(arg, ctx->connection ? ctx->connection : ATOM_close);
} else if ( name == ATOM_content_length )
{ if ( ctx->transfer_encoding == ATOM_chunked )
rc = PL_unify_int64(arg, ctx->chunked_written);
else
rc = PL_unify_int64(arg, ctx->datasize - ctx->data_offset);
} else if ( name == ATOM_header_codes )
{ if ( ctx->data_offset > 0 )
rc = PL_unify_chars(arg, PL_CODE_LIST, ctx->data_offset, ctx->data);
else /* incomplete header */
rc = PL_unify_chars(arg, PL_CODE_LIST, ctx->datasize, ctx->data);
} else if ( name == ATOM_state )
{ atom_t state;
switch(ctx->state)
{ case CGI_HDR: state = ATOM_header; break;
case CGI_DATA: state = ATOM_data; break;
case CGI_DISCARDED: state = ATOM_discarded; break;
default:
assert(0);
}
rc = PL_unify_atom(arg, state);
} else
{ rc = existence_error(prop, "cgi_property");
}
out:
if ( !PL_release_stream(s) )
{ if ( PL_exception(0) )
PL_clear_exception();
}
return rc;
}
static foreign_t
pl_tipc_setopt(term_t Socket, term_t opt)
{ int socket;
atom_t a;
int arity;
if ( !tipc_get_socket(Socket, &socket) )
return FALSE;
if ( PL_get_name_arity(opt, &a, &arity) )
{ if ( a == ATOM_importance && arity == 1 )
{ atom_t val;
term_t a1 = PL_new_term_ref();
int ival = TIPC_LOW_IMPORTANCE;
if (PL_get_arg(1, opt, a1))
{ if(!PL_get_atom(a1, &val) )
return pl_error(NULL, 0, NULL, ERR_DOMAIN, a1, "atom");
if(val == ATOM_low)
ival = TIPC_LOW_IMPORTANCE;
else if(val == ATOM_medium)
ival = TIPC_MEDIUM_IMPORTANCE;
else if(val == ATOM_high)
ival = TIPC_HIGH_IMPORTANCE;
else if(val == ATOM_critical)
ival = TIPC_CRITICAL_IMPORTANCE;
else
return pl_error(NULL, 0, NULL, ERR_DOMAIN, a1, "low, medium, high, or critical");
return((tipc_setopt(socket, NB_TIPC_IMPORTANCE, ival) == 0) ? TRUE : FALSE);
}
}
if ( ((a == ATOM_dest_droppable) ||
(a == ATOM_src_droppable)) && arity == 1 )
{ int val;
term_t a1 = PL_new_term_ref();
int option = (a == ATOM_dest_droppable) ? NB_TIPC_DEST_DROPPABLE
: NB_TIPC_SRC_DROPPABLE;
if (PL_get_arg(1, opt, a1))
{ if(!PL_get_bool(a1, &val) )
return pl_error(NULL, 0, NULL, ERR_DOMAIN, a1, "boolean");
return((tipc_setopt(socket, option, val) == 0) ? TRUE : FALSE);
}
}
if ( a == ATOM_conn_timeout && arity == 1 )
{ double val;
int ival;
term_t a1 = PL_new_term_ref();
if (PL_get_arg(1, opt, a1))
{ if(!PL_get_float(a1, &val) || val < 0)
return pl_error(NULL, 0, NULL, ERR_DOMAIN, a1, "float");
ival = val * 1000; // time is in milliseconds
return((tipc_setopt(socket, NB_TIPC_CONN_TIMEOUT, ival) == 0) ? TRUE : FALSE);
}
}
if ( a == ATOM_nodelay && arity <= 1 )
{ int enable, rc;
if ( arity == 0 )
{ enable = TRUE;
} else /*if ( arity == 1 )*/
{ term_t a = PL_new_term_ref();
_PL_get_arg(1, opt, a);
if ( !PL_get_bool(a, &enable) )
return pl_error(NULL, 0, NULL, ERR_DOMAIN, a, "boolean");
}
if ( (rc=nbio_setopt(socket, TCP_NO_DELAY, enable) == 0) )
return TRUE;
if ( rc == -2 )
return pl_error(NULL, 0, NULL, ERR_DOMAIN, opt, "socket_option");
}
if ( a == ATOM_nonblock && arity == 0 )
return((nbio_setopt(socket, TCP_NONBLOCK) == 0) ? TRUE : FALSE );
if ( a == ATOM_dispatch && arity == 1 )
{ int val;
term_t a1 = PL_new_term_ref();
if ( PL_get_arg(1, opt, a1) && PL_get_bool(a1, &val) )
{ if ( nbio_setopt(socket, TCP_DISPATCH, val) == 0 )
return TRUE;
return FALSE;
}
}
}
return pl_error(NULL, 0, NULL, ERR_DOMAIN, opt, "socket_option");
}
static int
nbio_get_tipc(term_t tipc, struct sockaddr_tipc *sockaddr)
{ term_t a = PL_new_term_ref();
sockaddr->family = AF_TIPC;
do
{
if ( PL_is_functor(tipc, FUNCTOR_port_id) )
{
unsigned ref, node;
_PL_get_arg(1, tipc, a);
if ( !get_uint(a, &ref) )
break;
_PL_get_arg(2, tipc, a);
if ( !get_uint(a, &node) )
break;
sockaddr->addrtype = TIPC_ADDR_ID;
sockaddr->addr.id.ref = ref;
sockaddr->addr.id.node = node;
return TRUE;
}
if ( PL_is_functor(tipc, FUNCTOR_name3) )
{
unsigned arg1, arg2, arg3;
_PL_get_arg(1, tipc, a);
if ( !get_uint(a, &arg1) )
break;
_PL_get_arg(2, tipc, a);
if ( !get_uint(a, &arg2) )
break;
_PL_get_arg(3, tipc, a);
if ( !get_uint(a, &arg3) )
break;
sockaddr->addrtype = TIPC_ADDR_NAME;
sockaddr->addr.name.name.type = arg1;
sockaddr->addr.name.name.instance = arg2;
sockaddr->addr.name.domain = arg3;
return TRUE;
}
if ( PL_is_functor(tipc, FUNCTOR_name_seq3) ||
PL_is_functor(tipc, FUNCTOR_mcast3))
{
unsigned arg1, arg2, arg3;
_PL_get_arg(1, tipc, a);
if ( !get_uint(a, &arg1) )
break;
_PL_get_arg(2, tipc, a);
if ( !get_uint(a, &arg2) )
break;
_PL_get_arg(3, tipc, a);
if ( !get_uint(a, &arg3) )
break;
sockaddr->addrtype = TIPC_ADDR_NAMESEQ;
sockaddr->addr.nameseq.type = arg1;
sockaddr->addr.nameseq.lower = arg2;
sockaddr->addr.nameseq.upper = arg3;
return TRUE;
}
} while(FALSE);
return FALSE;
}
