static void parse_dynd_builtin_json(const ndt::type& tp, const char *DYND_UNUSED(metadata), char *out_data,
const char *&begin, const char *end)
{
const char *saved_begin = begin;
const char *nbegin = NULL, *nend = NULL;
string val;
if (parse_json_number(begin, end, nbegin, nend)) {
try {
assign_utf8_string_to_builtin(tp.get_type_id(), out_data, nbegin, nend);
} catch (const std::exception& e) {
throw json_parse_error(skip_whitespace(saved_begin, begin), e.what(), tp);
}
} else if (parse_json_string(begin, end, val)) {
try {
assign_utf8_string_to_builtin(tp.get_type_id(), out_data, val.data(), val.data() + val.size());
} catch (const std::exception& e) {
throw json_parse_error(skip_whitespace(saved_begin, begin), e.what(), tp);
}
} else {
throw json_parse_error(begin, "invalid input", tp);
}
}
bool cfixed_dim_type::is_lossless_assignment(const ndt::type &dst_tp,
const ndt::type &src_tp) const
{
if (dst_tp.extended() == this) {
if (src_tp.extended() == this) {
return true;
} else if (src_tp.get_type_id() == cfixed_dim_type_id) {
return *dst_tp.extended() == *src_tp.extended();
}
}
return false;
}
size_t make_expr_kernel(void *ckb, intptr_t ckb_offset,
const ndt::type &dst_tp, const char *dst_arrmeta,
size_t src_count, const ndt::type *src_tp,
const char *const *src_arrmeta,
kernel_request_t kernreq,
const eval::eval_context *ectx) const
{
if (src_count != 1) {
stringstream ss;
ss << "date_strftime_kernel_generator requires 1 src operand, ";
ss << "received " << src_count;
throw runtime_error(ss.str());
}
bool require_elwise = dst_tp.get_type_id() != string_type_id ||
src_tp[0].get_type_id() != date_type_id;
// If the types don't match the ones for this generator,
// call the elementwise dimension handler to handle one dimension,
// giving 'this' as the next kernel generator to call
if (require_elwise) {
return make_elwise_dimension_expr_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta, src_count, src_tp, src_arrmeta,
kernreq, ectx, this);
}
date_strftime_kernel_extra *e =
reinterpret_cast<ckernel_builder<kernel_request_host> *>(ckb)
->alloc_ck<date_strftime_kernel_extra>(ckb_offset);
switch (kernreq) {
case kernel_request_single:
e->base.function =
reinterpret_cast<void *>(&date_strftime_kernel_extra::single_unary);
break;
case kernel_request_strided:
e->base.function =
reinterpret_cast<void *>(&date_strftime_kernel_extra::strided_unary);
break;
default: {
stringstream ss;
ss << "date_strftime_kernel_generator: unrecognized request "
<< (int)kernreq;
throw runtime_error(ss.str());
}
}
// The lifetime of kernels must be shorter than that of the kernel
// generator,
// so we can point at data in the kernel generator
e->format_size = m_format.size();
e->format = m_format.c_str();
e->dst_arrmeta = reinterpret_cast<const string_type_arrmeta *>(dst_arrmeta);
return ckb_offset;
}
ndt::type ndt::make_strided_dim(const ndt::type& element_tp)
{
// Static instances of the types, which have a reference
// count > 0 for the lifetime of the program. This static
// construction is inside a function to ensure correct creation
// order during startup.
static static_strided_dims ssd;
if (element_tp.is_builtin()) {
return ssd.static_builtins_instance[element_tp.get_type_id()];
} else {
return ndt::type(new strided_dim_type(element_tp), false);
}
}
static void format_json_bool(output_data &out, const ndt::type &dt, const char *arrmeta, const char *data)
{
bool1 value(false);
if (dt.get_type_id() == bool_type_id) {
value = (*data != 0);
} else {
typed_data_assign(ndt::type::make<bool1>(), NULL, reinterpret_cast<char *>(&value), dt, arrmeta, data);
}
if (value) {
out.write("true");
} else {
out.write("false");
}
}
static void format_json_string(output_data& out, const ndt::type& dt, const char *metadata, const char *data)
{
if (dt.get_type_id() == json_type_id) {
// Copy the JSON data directly
const json_type_data *d = reinterpret_cast<const json_type_data *>(data);
out.write(d->begin, d->end);
} else {
const base_string_type *bsd = static_cast<const base_string_type *>(dt.extended());
string_encoding_t encoding = bsd->get_encoding();
const char *begin = NULL, *end = NULL;
bsd->get_string_range(&begin, &end, metadata, data);
format_json_encoded_string(out, begin, end, encoding);
}
}
size_t dynd::make_value_to_pointer_assignment_kernel(void *ckb,
intptr_t ckb_offset,
const ndt::type &tp,
kernel_request_t kernreq)
{
if (tp.is_builtin()) {
return make_builtin_value_to_pointer_assignment_kernel(
ckb, ckb_offset, tp.get_type_id(), kernreq);
}
stringstream ss;
ss << "make_value_to_pointer_assignment_kernel: unrecognized type " << tp;
throw runtime_error(ss.str());
}
static nd::array view_concrete(const nd::array &arr, const ndt::type &tp)
{
// Allocate a result array to attempt the view in it
nd::array result(make_array_memory_block(tp.get_arrmeta_size()));
// Copy the fields
result.get_ndo()->data.ptr = arr.get_ndo()->data.ptr;
if (arr.get_ndo()->data.ref == NULL) {
// Embedded data, need reference to the array
result.get_ndo()->data.ref = arr.get_memblock().release();
} else {
// Use the same data reference, avoid producing a chain
result.get_ndo()->data.ref = arr.get_data_memblock().release();
}
result.get_ndo()->m_type = ndt::type(tp).release();
result.get_ndo()->m_flags = arr.get_ndo()->m_flags;
// First handle a special case of viewing outermost "var" as "fixed[#]"
if (arr.get_type().get_type_id() == var_dim_type_id && tp.get_type_id() == fixed_dim_type_id) {
const var_dim_type_arrmeta *in_am = reinterpret_cast<const var_dim_type_arrmeta *>(arr.get_arrmeta());
const var_dim_type_data *in_dat = reinterpret_cast<const var_dim_type_data *>(arr.get_readonly_originptr());
fixed_dim_type_arrmeta *out_am = reinterpret_cast<fixed_dim_type_arrmeta *>(result.get_arrmeta());
out_am->dim_size = tp.extended<ndt::fixed_dim_type>()->get_fixed_dim_size();
out_am->stride = in_am->stride;
if ((intptr_t)in_dat->size == out_am->dim_size) {
// Use the more specific data reference from the var arrmeta if possible
if (in_am->blockref != NULL) {
memory_block_decref(result.get_ndo()->data.ref);
memory_block_incref(in_am->blockref);
result.get_ndo()->data.ref = in_am->blockref;
}
result.get_ndo()->data.ptr = in_dat->begin + in_am->offset;
// Try to copy the rest of the arrmeta as a view
if (try_view(arr.get_type().extended<ndt::base_dim_type>()->get_element_type(),
arr.get_arrmeta() + sizeof(var_dim_type_arrmeta),
tp.extended<ndt::base_dim_type>()->get_element_type(),
result.get_arrmeta() + sizeof(fixed_dim_type_arrmeta), arr.get_memblock().get())) {
return result;
}
}
}
// Otherwise try to copy the arrmeta as a view
else if (try_view(arr.get_type(), arr.get_arrmeta(), tp, result.get_arrmeta(), arr.get_memblock().get())) {
// If it succeeded, return it
return result;
}
stringstream ss;
ss << "Unable to view nd::array of type " << arr.get_type();
ss << " as type " << tp;
throw type_error(ss.str());
}
static void format_json_dynamic(output_data &out, const ndt::type &dt,
const char *DYND_UNUSED(arrmeta),
const char *data)
{
if (dt.get_type_id() == json_type_id) {
// Copy the JSON data directly
const json_type_data *d = reinterpret_cast<const json_type_data *>(data);
out.write(d->begin, d->end);
} else {
stringstream ss;
ss << "Formatting dynd type " << dt << " as JSON is not implemented yet";
throw runtime_error(ss.str());
}
}
ndt::type ndt::make_pointer(const ndt::type& target_tp)
{
// Static instances of the type, which have a reference
// count > 0 for the lifetime of the program. This static
// construction is inside a function to ensure correct creation
// order during startup.
static static_pointer sp;
if (target_tp.is_builtin()) {
return sp.static_builtins_instance[target_tp.get_type_id()];
} else {
return ndt::type(new pointer_type(target_tp), false);
}
}
static void parse_number_json(const ndt::type &tp, const char *arrmeta,
char *out_data, const char *&rbegin,
const char *end, bool option,
const eval::eval_context *ectx)
{
const char *begin = rbegin;
const char *nbegin, *nend;
bool escaped = false;
if (option && parse::parse_token_no_ws(begin, end, "null")) {
ndt::option_type::make(tp).extended<ndt::option_type>()->assign_na(
arrmeta, out_data, ectx);
} else if (parse::parse_json_number_no_ws(begin, end, nbegin, nend)) {
parse::string_to_number(out_data, tp.get_type_id(), nbegin, nend, false,
ectx->errmode);
} else if (parse::parse_doublequote_string_no_ws(begin, end, nbegin, nend,
escaped)) {
// Interpret the data inside the string as an int
try {
if (!escaped) {
parse::string_to_number(out_data, tp.get_type_id(), nbegin, nend,
option, ectx->errmode);
} else {
string s;
parse::unescape_string(nbegin, nend, s);
parse::string_to_number(out_data, tp.get_type_id(), nbegin, nend,
option, ectx->errmode);
}
}
catch (const std::exception &e) {
throw json_parse_error(rbegin, e.what(), tp);
}
} else {
throw json_parse_error(rbegin, "expected a number", tp);
}
rbegin = begin;
}
bool datetime_type::is_lossless_assignment(const ndt::type& dst_tp, const ndt::type& src_tp) const
{
if (dst_tp.extended() == this) {
if (src_tp.extended() == this) {
return true;
} else if (src_tp.get_type_id() == date_type_id) {
// There is only one possibility for the date type (TODO: timezones!)
return true;
} else {
return false;
}
} else {
return false;
}
}
bool fixedbytes_type::is_lossless_assignment(const ndt::type& dst_tp, const ndt::type& src_tp) const
{
if (dst_tp.extended() == this) {
if (src_tp.extended() == this) {
return true;
} else if (src_tp.get_type_id() == fixedbytes_type_id) {
const fixedbytes_type *src_fs = static_cast<const fixedbytes_type*>(src_tp.extended());
return get_data_size() == src_fs->get_data_size();
} else {
return false;
}
} else {
return false;
}
}
size_t make_expr_kernel(void *ckb, intptr_t ckb_offset,
const ndt::type &dst_tp, const char *dst_arrmeta,
size_t src_count, const ndt::type *src_tp,
const char *const *src_arrmeta,
kernel_request_t kernreq,
const eval::eval_context *ectx) const
{
if (src_count != 1) {
stringstream ss;
ss << "date_replace_kernel_generator requires 1 src operand, ";
ss << "received " << src_count;
throw runtime_error(ss.str());
}
bool require_elwise = dst_tp.get_type_id() != date_type_id ||
src_tp[0].get_type_id() != date_type_id;
// If the types don't match the ones for this generator,
// call the elementwise dimension handler to handle one dimension,
// giving 'this' as the next kernel generator to call
if (require_elwise) {
return make_elwise_dimension_expr_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta, src_count, src_tp,
src_arrmeta, kernreq, ectx, this);
}
date_replace_kernel_extra *e =
reinterpret_cast<ckernel_builder<kernel_request_host> *>(ckb)
->alloc_ck_leaf<date_replace_kernel_extra>(ckb_offset);
switch (kernreq) {
case kernel_request_single:
e->base.set_function<expr_single_t>(
&date_replace_kernel_extra::single_unary);
break;
case kernel_request_strided:
e->base.set_function<expr_strided_t>(
&date_replace_kernel_extra::strided_unary);
break;
default: {
stringstream ss;
ss << "date_replace_kernel_generator: unrecognized request "
<< (int)kernreq;
throw runtime_error(ss.str());
}
}
e->year = m_year;
e->month = m_month;
e->day = m_day;
return ckb_offset;
}
size_t date_type::make_assignment_kernel(
ckernel_builder *out, size_t offset_out,
const ndt::type& dst_tp, const char *dst_metadata,
const ndt::type& src_tp, const char *src_metadata,
kernel_request_t kernreq, assign_error_mode errmode,
const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
if (src_tp.get_type_id() == date_type_id) {
return make_pod_typed_data_assignment_kernel(out, offset_out,
get_data_size(), get_data_alignment(), kernreq);
} else if (src_tp.get_kind() == string_kind) {
// Assignment from strings
return make_string_to_date_assignment_kernel(out, offset_out,
src_tp, src_metadata,
kernreq, errmode, ectx);
} else if (src_tp.get_kind() == struct_kind) {
// Convert to struct using the "struct" property
return ::make_assignment_kernel(out, offset_out,
ndt::make_property(dst_tp, "struct"), dst_metadata,
src_tp, src_metadata,
kernreq, errmode, ectx);
} else if (!src_tp.is_builtin()) {
return src_tp.extended()->make_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
src_tp, src_metadata,
kernreq, errmode, ectx);
}
} else {
if (dst_tp.get_kind() == string_kind) {
// Assignment to strings
return make_date_to_string_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
kernreq, errmode, ectx);
} else if (dst_tp.get_kind() == struct_kind) {
// Convert to struct using the "struct" property
return ::make_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
ndt::make_property(src_tp, "struct"), src_metadata,
kernreq, errmode, ectx);
}
// TODO
}
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw runtime_error(ss.str());
}
size_t make_expr_kernel(
ckernel_builder *out, size_t offset_out,
const ndt::type& dst_tp, const char *dst_metadata,
size_t src_count, const ndt::type *src_tp, const char **src_metadata,
kernel_request_t kernreq, const eval::eval_context *ectx) const
{
if (src_count != 1) {
stringstream ss;
ss << "date_strftime_kernel_generator requires 1 src operand, ";
ss << "received " << src_count;
throw runtime_error(ss.str());
}
bool require_elwise = dst_tp.get_type_id() != string_type_id ||
src_tp[0].get_type_id() != date_type_id;
// If the types don't match the ones for this generator,
// call the elementwise dimension handler to handle one dimension,
// giving 'this' as the next kernel generator to call
if (require_elwise) {
return make_elwise_dimension_expr_kernel(out, offset_out,
dst_tp, dst_metadata,
src_count, src_tp, src_metadata,
kernreq, ectx,
this);
}
size_t extra_size = sizeof(date_strftime_kernel_extra);
out->ensure_capacity_leaf(offset_out + extra_size);
date_strftime_kernel_extra *e = out->get_at<date_strftime_kernel_extra>(offset_out);
switch (kernreq) {
case kernel_request_single:
e->base.set_function<unary_single_operation_t>(&date_strftime_kernel_extra::single_unary);
break;
case kernel_request_strided:
e->base.set_function<unary_strided_operation_t>(&date_strftime_kernel_extra::strided_unary);
break;
default: {
stringstream ss;
ss << "date_strftime_kernel_generator: unrecognized request " << (int)kernreq;
throw runtime_error(ss.str());
}
}
// The lifetime of kernels must be shorter than that of the kernel generator,
// so we can point at data in the kernel generator
e->format_size = m_format.size();
e->format = m_format.c_str();
e->dst_metadata = reinterpret_cast<const string_type_metadata *>(dst_metadata);
return offset_out + extra_size;
}
static void parse_datetime_json(const ndt::type &tp, const char *arrmeta, char *out_data, const char *&rbegin,
const char *end, bool option, const eval::eval_context *ectx)
{
const char *begin = rbegin;
begin = skip_whitespace(begin, end);
const char *strbegin, *strend;
bool escaped;
if (option && parse_token(begin, end, "null")) {
switch (tp.get_type_id()) {
case date_type_id:
*reinterpret_cast<int32_t *>(out_data) = DYND_DATE_NA;
return;
case time_type_id:
*reinterpret_cast<int64_t *>(out_data) = DYND_TIME_NA;
return;
case datetime_type_id:
*reinterpret_cast<int64_t *>(out_data) = DYND_DATETIME_NA;
return;
default:
break;
}
stringstream ss;
ss << "Unrecognized datetime type " << tp;
throw runtime_error(ss.str());
} else if (parse::parse_doublequote_string_no_ws(begin, end, strbegin, strend, escaped)) {
std::string val;
if (escaped) {
parse::unescape_string(strbegin, strend, val);
strbegin = val.data();
strend = strbegin + val.size();
}
try
{
tp.extended()->set_from_utf8_string(arrmeta, out_data, strbegin, strend, ectx);
}
catch (const std::exception &e)
{
throw json_parse_error(skip_whitespace(rbegin, begin), e.what(), tp);
}
catch (const dynd::dynd_exception &e)
{
throw json_parse_error(skip_whitespace(rbegin, begin), e.what(), tp);
}
} else {
throw json_parse_error(begin, "expected a string", tp);
}
rbegin = begin;
}
static void format_json_dim(output_data& out, const ndt::type& dt, const char *arrmeta, const char *data)
{
out.write('[');
switch (dt.get_type_id()) {
case cfixed_dim_type_id:
case fixed_dim_type_id: {
const base_dim_type *sad = dt.extended<base_dim_type>();
const fixed_dim_type_arrmeta *md =
reinterpret_cast<const fixed_dim_type_arrmeta *>(arrmeta);
ndt::type element_tp = sad->get_element_type();
intptr_t size = md->dim_size, stride = md->stride;
arrmeta += sizeof(fixed_dim_type_arrmeta);
for (intptr_t i = 0; i < size; ++i) {
::format_json(out, element_tp, arrmeta, data + i * stride);
if (i != size - 1) {
out.write(',');
}
}
break;
}
case var_dim_type_id: {
const var_dim_type *vad = dt.extended<var_dim_type>();
const var_dim_type_arrmeta *md =
reinterpret_cast<const var_dim_type_arrmeta *>(arrmeta);
const var_dim_type_data *d =
reinterpret_cast<const var_dim_type_data *>(data);
ndt::type element_tp = vad->get_element_type();
intptr_t size = d->size, stride = md->stride;
const char *begin = d->begin + md->offset;
arrmeta += sizeof(var_dim_type_arrmeta);
for (intptr_t i = 0; i < size; ++i) {
::format_json(out, element_tp, arrmeta, begin + i * stride);
if (i != size - 1) {
out.write(',');
}
}
break;
}
default: {
stringstream ss;
ss << "Formatting dynd type " << dt << " as JSON is not implemented yet";
throw runtime_error(ss.str());
}
}
out.write(']');
}
static void format_json_type(output_data &out, const ndt::type &dt, const char *arrmeta, const char *data)
{
switch (dt.get_type_id()) {
case type_type_id: {
stringstream ss;
dt.print_data(ss, arrmeta, data);
std::string s = ss.str();
format_json_encoded_string(out, s.data(), s.data() + s.size(), string_encoding_ascii);
break;
}
default: {
stringstream ss;
ss << "Formatting dynd type \"" << dt << "\" as JSON is not implemented yet";
throw runtime_error(ss.str());
}
}
}
memory_block_ptr dynd::make_zeroinit_memory_block(const ndt::type &element_tp, intptr_t initial_capacity_bytes)
{
// This is a temporary hack until the new bytes and string types are working
size_t data_size;
switch (element_tp.get_type_id()) {
case bytes_type_id:
case string_type_id:
data_size = 1;
break;
default:
data_size = element_tp.get_default_data_size();
}
zeroinit_memory_block *pmb =
new zeroinit_memory_block(data_size, element_tp.get_data_alignment(), initial_capacity_bytes);
return memory_block_ptr(reinterpret_cast<memory_block_data *>(pmb), false);
}
bool dynd::busdate_type::is_lossless_assignment(const ndt::type& dst_tp, const ndt::type& src_tp) const
{
if (dst_tp.extended() == this) {
if (src_tp.extended() == this) {
return true;
} else if (src_tp.get_type_id() == date_type_id) {
const busdate_type *src_fs = static_cast<const busdate_type*>(src_tp.extended());
// No need to compare the roll policy, just the weekmask and holidays determine this
return memcmp(m_workweek, src_fs->m_workweek, sizeof(m_workweek)) == 0 &&
m_holidays.equals_exact(src_fs->m_holidays);
} else {
return false;
}
} else {
return false;
}
}
static void parse_dim_json(const ndt::type &tp, const char *arrmeta, char *out_data, const char *&begin,
const char *end, const eval::eval_context *ectx)
{
switch (tp.get_type_id()) {
case fixed_dim_type_id:
parse_strided_dim_json(tp, arrmeta, out_data, begin, end, ectx);
break;
case var_dim_type_id:
parse_var_dim_json(tp, arrmeta, out_data, begin, end, ectx);
break;
default: {
stringstream ss;
ss << "parse_json: unsupported dynd dimension type \"" << tp << "\"";
throw runtime_error(ss.str());
}
}
}
pointer_type::pointer_type(const ndt::type& target_tp)
: base_expr_type(pointer_type_id, expr_kind, sizeof(void *),
sizeof(void *),
inherited_flags(target_tp.get_flags(), type_flag_zeroinit|type_flag_blockref),
sizeof(pointer_type_arrmeta) + target_tp.get_arrmeta_size(),
target_tp.get_ndim()),
m_target_tp(target_tp)
{
// I'm not 100% sure how blockref pointer types should interact with
// the computational subsystem, the details will have to shake out
// when we want to actually do something with them.
if (target_tp.get_kind() == expr_kind && target_tp.get_type_id() != pointer_type_id) {
stringstream ss;
ss << "A dynd pointer type's target cannot be the expression type ";
ss << target_tp;
throw dynd::type_error(ss.str());
}
}
static void parse_datetime_json(const ndt::type& tp, const char *metadata, char *out_data,
const char *&begin, const char *end, const eval::eval_context *ectx)
{
const char *saved_begin = begin;
string val;
if (parse_json_string(begin, end, val)) {
if (tp.get_type_id() == date_type_id) {
const date_type *dd = static_cast<const date_type *>(tp.extended());
try {
dd->set_utf8_string(metadata, out_data, assign_error_fractional, val, ectx);
} catch (const std::exception& e) {
throw json_parse_error(skip_whitespace(saved_begin, begin), e.what(), tp);
}
}
} else {
throw json_parse_error(begin, "expected a string", tp);
}
}
static void parse_type(const ndt::type &tp, const char *DYND_UNUSED(arrmeta), char *out_data, const char *&rbegin,
const char *end, bool option, const eval::eval_context *DYND_UNUSED(ectx))
{
const char *begin = rbegin;
begin = skip_whitespace(begin, end);
const char *strbegin, *strend;
bool escaped;
if (option && parse_token(begin, end, "null")) {
switch (tp.get_type_id()) {
case type_type_id:
*reinterpret_cast<ndt::type *>(out_data) = ndt::type();
return;
default:
break;
}
stringstream ss;
ss << "Unrecognized type type \"" << tp << "\"";
throw runtime_error(ss.str());
} else if (parse::parse_doublequote_string_no_ws(begin, end, strbegin, strend, escaped)) {
std::string val;
if (escaped) {
parse::unescape_string(strbegin, strend, val);
strbegin = val.data();
strend = strbegin + val.size();
}
try
{
*reinterpret_cast<ndt::type *>(out_data) = ndt::type(strbegin, strend);
}
catch (const std::exception &e)
{
throw json_parse_error(skip_whitespace(rbegin, begin), e.what(), tp);
}
catch (const dynd::dynd_exception &e)
{
throw json_parse_error(skip_whitespace(rbegin, begin), e.what(), tp);
}
} else {
throw json_parse_error(begin, "expected a string", tp);
}
rbegin = begin;
}
static void parse_json(const ndt::type& tp, const char *metadata, char *out_data,
const char *&json_begin, const char *json_end, const eval::eval_context *ectx)
{
switch (tp.get_kind()) {
case uniform_dim_kind:
parse_uniform_dim_json(tp, metadata, out_data, json_begin, json_end, ectx);
break;
case struct_kind:
parse_struct_json(tp, metadata, out_data, json_begin, json_end, ectx);
break;
case bool_kind:
parse_bool_json(tp, metadata, out_data, json_begin, json_end);
return;
case int_kind:
case uint_kind:
parse_integer_json(tp, metadata, out_data, json_begin, json_end);
return;
case real_kind:
parse_real_json(tp, metadata, out_data, json_begin, json_end);
return;
case complex_kind:
parse_complex_json(tp, metadata, out_data, json_begin, json_end);
return;
case string_kind:
if (tp.get_type_id() == json_type_id) {
// The json type is a special string type that contains JSON directly
// Copy the JSON verbatim in this case.
parse_jsonstring_json(tp, metadata, out_data, json_begin, json_end);
} else {
parse_string_json(tp, metadata, out_data, json_begin, json_end);
}
return;
case datetime_kind:
parse_datetime_json(tp, metadata, out_data, json_begin, json_end, ectx);
return;
default: {
stringstream ss;
ss << "parse_json: unsupported dynd type " << tp;
throw runtime_error(ss.str());
}
}
}
void dynd::typed_data_copy(const ndt::type &tp, const char *dst_arrmeta,
char *dst_data, const char *src_arrmeta,
const char *src_data)
{
if (tp.get_type_id() == option_type_id) {
return typed_data_copy(tp.extended<ndt::option_type>()->get_value_type(),
dst_arrmeta, dst_data, src_arrmeta, src_data);
}
size_t data_size = tp.get_data_size();
if (tp.is_pod()) {
memcpy(dst_data, src_data, data_size);
} else {
ckernel_builder<kernel_request_host> k;
make_assignment_kernel(&k, 0, tp, dst_arrmeta, tp, src_arrmeta,
kernel_request_single, &eval::default_eval_context);
expr_single_t fn = k.get()->get_function<expr_single_t>();
char *src = const_cast<char *>(src_data);
fn(dst_data, &src, k.get());
}
}
size_t void_pointer_type::make_assignment_kernel(
void *ckb, intptr_t ckb_offset, const ndt::type &dst_tp,
const char *dst_arrmeta, const ndt::type &src_tp, const char *src_arrmeta,
kernel_request_t kernreq, const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
if (src_tp.get_type_id() == void_pointer_type_id) {
return ::make_pod_typed_data_assignment_kernel(ckb, ckb_offset,
get_data_size(), get_data_alignment(),
kernreq);
} else if (!src_tp.is_builtin()) {
src_tp.extended()->make_assignment_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta, src_tp, src_arrmeta,
kernreq, ectx);
}
}
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw dynd::type_error(ss.str());
}
size_t pointer_type::make_assignment_kernel(
void *ckb, intptr_t ckb_offset, const ndt::type &dst_tp,
const char *dst_arrmeta, const ndt::type &src_tp, const char *src_arrmeta,
kernel_request_t kernreq, const eval::eval_context *ectx) const
{
if (dst_tp.get_type_id() == pointer_type_id) {
if (dst_tp == src_tp) {
return make_pod_typed_data_assignment_kernel(ckb, ckb_offset, get_data_size(), get_data_alignment(), kernreq);
} else {
ndt::type dst_target_tp = dst_tp.extended<pointer_type>()->get_target_type();
if (dst_target_tp == src_tp) {
return make_value_to_pointer_assignment_kernel(ckb, ckb_offset,
dst_target_tp, kernreq);
}
}
}
return base_expr_type::make_assignment_kernel(ckb, ckb_offset,
dst_tp, dst_arrmeta, src_tp, src_arrmeta,
kernreq, ectx);
}
intptr_t dynd::make_cuda_device_builtin_type_assignment_kernel(
const callable_type_data *DYND_UNUSED(self),
const ndt::callable_type *DYND_UNUSED(af_tp), char *DYND_UNUSED(data),
void *ckb, intptr_t ckb_offset, const ndt::type &dst_tp,
const char *DYND_UNUSED(dst_arrmeta), intptr_t DYND_UNUSED(nsrc),
const ndt::type *src_tp, const char *const *DYND_UNUSED(src_arrmeta),
kernel_request_t kernreq, const eval::eval_context *ectx,
const nd::array &kwds, const std::map<std::string, ndt::type> &tp_vars)
{
assign_error_mode errmode = ectx->cuda_device_errmode;
if (errmode != assign_error_nocheck &&
is_lossless_assignment(dst_tp, *src_tp)) {
errmode = assign_error_nocheck;
}
if (!dst_tp.is_builtin() || !src_tp->is_builtin() ||
errmode == assign_error_default) {
stringstream ss;
ss << "cannot do cuda device assignment from " << *src_tp << " to "
<< dst_tp;
throw runtime_error(ss.str());
}
if ((kernreq & kernel_request_cuda_device) == 0) {
// Create a trampoline ckernel from host to device
nd::cuda_launch_ck<1> *self =
nd::cuda_launch_ck<1>::make(ckb, kernreq, ckb_offset, 1, 1);
// Make the assignment on the device
make_cuda_device_builtin_type_assignment_kernel(
NULL, NULL, NULL, &self->ckb, 0, dst_tp, NULL, 1, src_tp, NULL,
kernreq | kernel_request_cuda_device, ectx, kwds, tp_vars);
// Return the offset for the original ckb
return ckb_offset;
}
return make_builtin_type_assignment_kernel(
ckb, ckb_offset, dst_tp.get_type_id(), src_tp->get_type_id(), kernreq,
errmode);
}
