}
int Base_Type::XER_encode_negtest(const Erroneous_descriptor_t* /*p_err_descr*/,
- const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, unsigned int flavor, int indent) const
+ const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, unsigned int flavor, int indent, embed_values_enc_struct_t*) const
{
- return XER_encode(p_td, p_buf, flavor, indent); // ignore erroneous
+ return XER_encode(p_td, p_buf, flavor, indent, 0); // ignore erroneous
}
int Base_Type::RAW_encode_negtest(const Erroneous_descriptor_t *,
val_ptr = NULL;
}
else if (val_ptr->ref_count == 1) {
- if (refd_indices.empty()) {
+ if (NULL == refd_ind_ptr) {
for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) {
if (val_ptr->value_elements[elem_count] != NULL) {
delete val_ptr->value_elements[elem_count];
}
Record_Of_Type::Record_Of_Type(null_type /*other_value*/)
-: Base_Type(), val_ptr(new recordof_setof_struct), err_descr(NULL), max_refd_index(-1)
+: Base_Type(), val_ptr(new recordof_setof_struct), err_descr(NULL), refd_ind_ptr(NULL)
{
val_ptr->ref_count = 1;
val_ptr->n_elements = 0;
}
Record_Of_Type::Record_Of_Type(const Record_Of_Type& other_value)
-: Base_Type(other_value), val_ptr(NULL), err_descr(other_value.err_descr), max_refd_index(-1)
+: Base_Type(other_value), val_ptr(NULL), err_descr(other_value.err_descr), refd_ind_ptr(NULL)
{
if (!other_value.is_bound())
TTCN_error("Copying an unbound record of/set of value.");
// Increment ref_count only if val_ptr is not NULL
if (other_value.val_ptr != NULL) {
- if (other_value.refd_indices.empty()) {
+ if (NULL == other_value.refd_ind_ptr) {
val_ptr = other_value.val_ptr;
val_ptr->ref_count++;
}
int Record_Of_Type::get_nof_elements() const
{
int nof_elements = (val_ptr != NULL) ? val_ptr->n_elements : 0;
- if (!refd_indices.empty()) {
+ if (NULL != refd_ind_ptr) {
while (nof_elements > 0) {
if (is_elem_bound(nof_elements - 1)) {
break;
int Record_Of_Type::get_max_refd_index()
{
- if (refd_indices.empty()) {
+ if (NULL == refd_ind_ptr) {
return -1;
}
- if (-1 == max_refd_index) {
- for (size_t i = 0; i < refd_indices.size(); ++i) {
- if (refd_indices[i] > max_refd_index) {
- max_refd_index = refd_indices[i];
+ if (-1 == refd_ind_ptr->max_refd_index) {
+ for (size_t i = 0; i < refd_ind_ptr->refd_indices.size(); ++i) {
+ if (refd_ind_ptr->refd_indices[i] > refd_ind_ptr->max_refd_index) {
+ refd_ind_ptr->max_refd_index = refd_ind_ptr->refd_indices[i];
}
}
}
- return max_refd_index;
+ return refd_ind_ptr->max_refd_index;
}
bool Record_Of_Type::is_index_refd(int index)
{
- for (size_t i = 0; i < refd_indices.size(); ++i) {
- if (index == refd_indices[i]) {
+ if (NULL == refd_ind_ptr) {
+ return false;
+ }
+ for (size_t i = 0; i < refd_ind_ptr->refd_indices.size(); ++i) {
+ if (index == refd_ind_ptr->refd_indices[i]) {
return true;
}
}
TTCN_error("Assigning an unbound value of type %s.",
other_value->get_descriptor()->name);
if (this != other_recof) {
- if (refd_indices.empty() && other_recof->refd_indices.empty()) {
+ if (NULL == refd_ind_ptr && NULL == other_recof->refd_ind_ptr) {
clean_up();
val_ptr = other_recof->val_ptr;
val_ptr->ref_count++;
boolean Record_Of_Type::is_bound() const
{
- if (refd_indices.empty()) {
+ if (NULL == refd_ind_ptr) {
return (val_ptr != NULL);
}
return (get_nof_elements() != 0);
break;
}
sep_found=FALSE;
- if (refd_indices.empty()) {
+ if (NULL == refd_ind_ptr) {
val_ptr->value_elements = (Base_Type**)reallocate_pointers(
(void**)val_ptr->value_elements, val_ptr->n_elements, val_ptr->n_elements + 1);
val_ptr->value_elements[val_ptr->n_elements]=val;
}
return JSON_ERROR_FATAL;
}
- if (refd_indices.empty()) {
+ if (NULL == refd_ind_ptr) {
val_ptr->value_elements = (Base_Type**)reallocate_pointers(
(void**)val_ptr->value_elements, val_ptr->n_elements, val_ptr->n_elements + 1);
val_ptr->value_elements[val_ptr->n_elements] = val;
case TTCN_EncDec::CT_XER: {
TTCN_EncDec_ErrorContext ec("While XER-encoding type '%s': ", p_td.name);
unsigned XER_coding=va_arg(pvar, unsigned);
- XER_encode(*(p_td.xer),p_buf, XER_coding, 0);
+ XER_encode(*(p_td.xer),p_buf, XER_coding, 0, 0);
p_buf.put_c('\n');
break;}
case TTCN_EncDec::CT_JSON: {
for (int success=reader.Read(); success==1; success=reader.Read()) {
if (reader.NodeType() == XML_READER_TYPE_ELEMENT) break;
}
- XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL);
+ XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL, 0);
size_t bytes = reader.ByteConsumed();
p_buf.set_pos(bytes);
break;}
static const universal_char tb = { 0,0,0,9 };
int Record_Of_Type::XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf,
- unsigned int flavor, int indent) const
+ unsigned int flavor, int indent, embed_values_enc_struct_t* emb_val) const
{
if (err_descr) {
- return XER_encode_negtest(err_descr, p_td, p_buf, flavor, indent);
+ return XER_encode_negtest(err_descr, p_td, p_buf, flavor, indent, emb_val);
}
if (val_ptr == 0) TTCN_error(
check_namespace_restrictions(p_td, (const char*)cs);
}
before.XER_encode(UNIVERSAL_CHARSTRING_xer_, p_buf,
- flavor | ANY_ATTRIBUTES, indent);
+ flavor | ANY_ATTRIBUTES, indent, 0);
p_buf.put_c('\'');
p_buf.put_c(' ');
UNIVERSAL_CHARSTRING after(len - j, (const universal_char*)(*elem) + j);
after.XER_encode(UNIVERSAL_CHARSTRING_xer_, p_buf,
- flavor | ANY_ATTRIBUTES, indent);
+ flavor | ANY_ATTRIBUTES, indent, 0);
// Put this attribute in a dummy element and walk through it to check its validity
TTCN_Buffer check_buf;
unsigned int sub_flavor = flavor | XER_RECOF | (p_td.xer_bits & (XER_LIST));
for (int i = 0; i < nof_elements; ++i) {
+ if (i > 0 && !own_tag && 0 != emb_val &&
+ emb_val->embval_index < emb_val->embval_array->size_of()) {
+ emb_val->embval_array->get_at(emb_val->embval_index)->XER_encode(
+ UNIVERSAL_CHARSTRING_xer_, p_buf, flavor | EMBED_VALUES, indent+1, 0);
+ ++emb_val->embval_index;
+ }
if (exer && (p_td.xer_bits & XER_LIST) && i>0) p_buf.put_c(' ');
get_at(i)->XER_encode(*get_elem_descr()->xer, p_buf,
- sub_flavor, indent+own_tag);
+ sub_flavor, indent+own_tag, emb_val);
}
if (indenting && nof_elements && !is_exerlist(flavor)) {
*/
int Record_Of_Type::encode_element(int i,
const Erroneous_values_t* ev, const Erroneous_descriptor_t* ed,
- TTCN_Buffer& p_buf, unsigned int sub_flavor, int indent) const
+ TTCN_Buffer& p_buf, unsigned int sub_flavor, int indent, embed_values_enc_struct_t* emb_val) const
{
int enc_len = p_buf.get_len();
TTCN_EncDec_ErrorContext ec;
if (ev->before->type_descr==NULL) TTCN_error(
"internal error: erroneous before type descriptor missing");
ev->before->errval->XER_encode(*ev->before->type_descr->xer,
- p_buf, sub_flavor, indent);
+ p_buf, sub_flavor, indent, 0);
}
}
if (ev->value->type_descr==NULL) TTCN_error(
"internal error: erroneous value type descriptor missing");
ev->value->errval->XER_encode(*ev->value->type_descr->xer,
- p_buf, sub_flavor, indent);
+ p_buf, sub_flavor, indent, 0);
}
} // else -> omit
} else {
ec.set_msg("Component #%d: ", i);
if (ed) {
- get_at(i)->XER_encode_negtest(ed, *get_elem_descr()->xer, p_buf, sub_flavor, indent);
+ get_at(i)->XER_encode_negtest(ed, *get_elem_descr()->xer, p_buf, sub_flavor, indent, emb_val);
} else {
// the "real" encoder
- get_at(i)->XER_encode(*get_elem_descr()->xer, p_buf, sub_flavor, indent);
+ get_at(i)->XER_encode(*get_elem_descr()->xer, p_buf, sub_flavor, indent, emb_val);
}
}
if (ev->after->type_descr==NULL) TTCN_error(
"internal error: erroneous after type descriptor missing");
ev->after->errval->XER_encode(*ev->after->type_descr->xer,
- p_buf, sub_flavor, indent);
+ p_buf, sub_flavor, indent, 0);
}
}
// XERSTUFF Record_Of_Type::XER_encode_negtest
int Record_Of_Type::XER_encode_negtest(const Erroneous_descriptor_t* p_err_descr,
- const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, unsigned flavor, int indent) const
+ const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, unsigned flavor, int indent,
+ embed_values_enc_struct_t* emb_val) const
{
if (val_ptr == 0) TTCN_error(
"Attempt to XER-encode an unbound record of type %s", get_descriptor()->name);
if (ev->before->type_descr==NULL) TTCN_error(
"internal error: erroneous before type descriptor missing");
else ev->before->errval->XER_encode(*ev->before->type_descr->xer,
- p_buf, flavor, indent);
+ p_buf, flavor, indent, 0);
}
}
if (ev->value->type_descr==NULL) TTCN_error(
"internal error: erroneous value type descriptor missing");
else ev->value->errval->XER_encode(*ev->value->type_descr->xer,
- p_buf, flavor, indent);
+ p_buf, flavor, indent, 0);
}
}
}
UNIVERSAL_CHARSTRING before(sp_at, (const universal_char*)(*elem));
before.XER_encode(UNIVERSAL_CHARSTRING_xer_, p_buf,
- flavor | ANY_ATTRIBUTES, indent);
+ flavor | ANY_ATTRIBUTES, indent, 0);
p_buf.put_c('\'');
p_buf.put_c(' ');
UNIVERSAL_CHARSTRING after(len - j, (const universal_char*)(*elem) + j);
after.XER_encode(UNIVERSAL_CHARSTRING_xer_, p_buf,
- flavor | ANY_ATTRIBUTES, indent);
+ flavor | ANY_ATTRIBUTES, indent, 0);
}
}
if (ev->after->type_descr==NULL) TTCN_error(
"internal error: erroneous after type descriptor missing");
else ev->after->errval->XER_encode(*ev->after->type_descr->xer,
- p_buf, flavor, indent);
+ p_buf, flavor, indent, 0);
}
}
}
for (int i = 0; i < nof_elements; ++i) {
if (i < p_err_descr->omit_before) continue;
+
+ if (0 != emb_val && i > 0 && !own_tag &&
+ emb_val->embval_index < emb_val->embval_array->size_of()) {
+ const Erroneous_values_t * ev0_i = NULL;
+ const Erroneous_descriptor_t* ed0_i = NULL;
+ if (emb_val->embval_err) {
+ ev0_i = emb_val->embval_err->next_field_err_values(emb_val->embval_index, emb_val->embval_err_val_idx);
+ ed0_i = emb_val->embval_err->next_field_emb_descr (emb_val->embval_index, emb_val->embval_err_descr_idx);
+ }
+ emb_val->embval_array->encode_element(emb_val->embval_index, ev0_i, ed0_i,
+ p_buf, flavor | EMBED_VALUES, indent + own_tag, 0);
+ ++emb_val->embval_index;
+ }
const Erroneous_values_t* err_vals =
p_err_descr->next_field_err_values(i, values_idx);
const Erroneous_descriptor_t* emb_descr =
p_err_descr->next_field_emb_descr (i, edescr_idx);
- encode_element(i, err_vals, emb_descr, p_buf, sub_flavor, indent+own_tag);
+ encode_element(i, err_vals, emb_descr, p_buf, sub_flavor, indent+own_tag, emb_val);
// omit_after value -1 becomes "very big"
if ((unsigned int)i >= (unsigned int)p_err_descr->omit_after) break;
}
int Record_Of_Type::XER_decode(const XERdescriptor_t& p_td,
- XmlReaderWrap& reader, unsigned int flavor)
+ XmlReaderWrap& reader, unsigned int flavor, embed_values_dec_struct_t* emb_val)
{
int exer = is_exer(flavor);
int xerbits = p_td.xer_bits;
// The call to the non-const operator[], I mean get_at(), creates
// a new element (because it is indexing one past the last element).
// Then we call its XER_decode with the temporary XML reader.
- get_at(get_nof_elements())->XER_decode(sub_xer, reader2, flavor);
+ get_at(get_nof_elements())->XER_decode(sub_xer, reader2, flavor, 0);
if (flavor & EXIT_ON_ERROR && !is_elem_bound(get_nof_elements() - 1)) {
if (1 == get_nof_elements()) {
// Failed to decode even the first element
}
ec_1.set_msg("%d: ", get_nof_elements());
/* The call to the non-const get_at() creates the element */
- get_at(get_nof_elements())->XER_decode(*get_elem_descr()->xer, reader, flavor);
+ get_at(get_nof_elements())->XER_decode(*get_elem_descr()->xer, reader, flavor, emb_val);
+ if (0 != emb_val && !own_tag && get_nof_elements() > 1) {
+ ++emb_val->embval_index;
+ }
}
}
else if (XML_READER_TYPE_END_ELEMENT == type) {
}
break;
}
+ else if (XML_READER_TYPE_TEXT == type && 0 != emb_val && !own_tag && get_nof_elements() > 0) {
+ UNIVERSAL_CHARSTRING emb_ustr((const char*)reader.Value());
+ emb_val->embval_array->get_at(emb_val->embval_index)->set_value(&emb_ustr);
+ success = reader.Read();
+ }
else {
success = reader.Read();
}
void Record_Of_Type::add_refd_index(int index)
{
- refd_indices.push_back(index);
+ if (NULL == refd_ind_ptr) {
+ refd_ind_ptr = new refd_index_struct;
+ refd_ind_ptr->max_refd_index = -1;
+ }
+ refd_ind_ptr->refd_indices.push_back(index);
if (index > get_max_refd_index()) {
- max_refd_index = index;
+ refd_ind_ptr->max_refd_index = index;
}
}
void Record_Of_Type::remove_refd_index(int index)
{
- for (size_t i = refd_indices.size(); i > 0; --i) {
- if (refd_indices[i - 1] == index) {
- refd_indices.erase_at(i - 1);
+ for (size_t i = refd_ind_ptr->refd_indices.size(); i > 0; --i) {
+ if (refd_ind_ptr->refd_indices[i - 1] == index) {
+ refd_ind_ptr->refd_indices.erase_at(i - 1);
break;
}
}
- if (get_max_refd_index() == index) {
- max_refd_index = -1;
+ if (refd_ind_ptr->refd_indices.empty()) {
+ delete refd_ind_ptr;
+ refd_ind_ptr = NULL;
+ }
+ else if (get_max_refd_index() == index) {
+ refd_ind_ptr->max_refd_index = -1;
}
}
case TTCN_EncDec::CT_XER: {
TTCN_EncDec_ErrorContext ec("While XER-encoding type '%s': ", p_td.name);
unsigned XER_coding=va_arg(pvar, unsigned);
- XER_encode(*(p_td.xer),p_buf, XER_coding, 0);
+ XER_encode(*(p_td.xer),p_buf, XER_coding, 0, 0);
p_buf.put_c('\n');
break;}
case TTCN_EncDec::CT_JSON: {
for (int success=reader.Read(); success==1; success=reader.Read()) {
if (reader.NodeType() == XML_READER_TYPE_ELEMENT) break;
}
- XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL);
+ XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL, 0);
size_t bytes = reader.ByteConsumed();
p_buf.set_pos(bytes);
break;}
}
int Record_Type::XER_encode(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf,
- unsigned int flavor, int indent) const
+ unsigned int flavor, int indent, embed_values_enc_struct_t*) const
{
if (err_descr) {
- return XER_encode_negtest(err_descr, p_td, p_buf, flavor, indent);
+ return XER_encode_negtest(err_descr, p_td, p_buf, flavor, indent, 0);
}
if (!is_bound()) {
TTCN_EncDec_ErrorContext::error
const Base_Type * const q_uri = get_at(0);
if (q_uri->is_present()) {
p_buf.put_s(11, (cbyte*)" xmlns:b0='");
- q_uri->XER_encode(*xer_descr(0), p_buf, flavor | XER_LIST, indent+1);
+ q_uri->XER_encode(*xer_descr(0), p_buf, flavor | XER_LIST, indent+1, 0);
p_buf.put_c('\'');
}
sub_len += 3;
}
const Base_Type* const q_name = get_at(1);
- sub_len += q_name->XER_encode(*xer_descr(1), p_buf, flavor | XER_LIST, indent+1);
+ sub_len += q_name->XER_encode(*xer_descr(1), p_buf, flavor | XER_LIST, indent+1, 0);
if (p_td.xer_bits & XER_ATTRIBUTE) p_buf.put_c('\'');
}
else { // not USE-QNAME
if (!exer && (p_td.xer_bits & EMBED_VALUES)) {
// The EMBED-VALUES member as an ordinary record of string
- sub_len += embed_values->XER_encode(*xer_descr(0), p_buf, flavor, indent+1);
+ sub_len += embed_values->XER_encode(*xer_descr(0), p_buf, flavor, indent+1, 0);
}
if (!exer && (p_td.xer_bits & USE_ORDER)) {
// The USE-ORDER member as an ordinary record of enumerated
- sub_len += use_order->XER_encode(*xer_descr(uo_index), p_buf, flavor, indent+1);
+ sub_len += use_order->XER_encode(*xer_descr(uo_index), p_buf, flavor, indent+1, 0);
}
if (exer && (indent==0 || (flavor & DEF_NS_SQUASHED))) // write namespaces for toplevel only
for (i = start_at; i < first_nonattr; ++i) {
boolean is_xer_attr_field = xer_descr(i)->xer_bits & XER_ATTRIBUTE;
ec_1.set_msg("%s': ", fld_name(i)); // attr
- int tmp_len = get_at(i)->XER_encode(*xer_descr(i), p_buf, flavor, indent+1);
+ int tmp_len = get_at(i)->XER_encode(*xer_descr(i), p_buf, flavor, indent+1, 0);
if (is_xer_attr_field && !exer) sub_len += tmp_len; /* do not add if attribute and EXER */
}
p_buf.put_s(start_tag_len , (cbyte*)">\n");
}
- int expected_embed = (field_cnt - first_nonattr + 1);
if (exer && (p_td.xer_bits & EMBED_VALUES)) {
- ec_1.set_msg("%s': ", fld_name(0));
- int num_opt;
- if ((p_td.xer_bits & USE_NIL) && !get_at(field_cnt-1)->ispresent()) {
- expected_embed = 0; //25.2.6 a
- }
- else if ((num_opt = optional_count())) {
- const int * optionals = get_optional_indexes();
- for (int opt_idx = 0; opt_idx < num_opt; ++opt_idx) {
- // skip optional attributes
- if (optionals[opt_idx] < start_at + num_attributes) continue;
- // reduce for each omitted member
- if (!get_at(optionals[opt_idx])->is_present()) --expected_embed;
- }
- }
- // Check the correct number of EMBED-VALUES (regular non-attributes + 1)
- if (embed_values->size_of() != expected_embed)
- TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_CONSTRAINT,
- "Wrong number %d of EMBED-VALUEs, expected %d",
- embed_values->size_of(), expected_embed);
/* write the first string */
- if (expected_embed > 0) {
+ if (embed_values->size_of() > 0) {
sub_len += embed_values->get_at(0)->XER_encode(UNIVERSAL_CHARSTRING_xer_,
- p_buf, flavor | EMBED_VALUES, indent+1);
+ p_buf, flavor | EMBED_VALUES, indent+1, 0);
}
}
* pseudo-members for USE-ORDER, etc.) */
// early_to_bed can only be true if exer is true (transitive through nil_attribute)
- if (!early_to_bed) for ( i = begin; i < end; ++i ) {
- const Base_Type *uoe = 0; // "useOrder enum"
- const Enum_Type *enm = 0; // the enum value selecting the field
- if (exer && use_order) {
- uoe = use_order->get_at(i - begin);
- enm = static_cast<const Enum_Type *>(uoe);
- }
-
- // "actual" index, may be perturbed by USE-ORDER
- int ai = !(exer && (p_td.xer_bits & USE_ORDER)) ? i :
- enm->as_int() + useorder_base;
- ec_1.set_msg("%s': ", ordered->fld_name(ai)); // non-attr
-
- const XERdescriptor_t& descr = *ordered->xer_descr(ai);
- sub_len += ordered->get_at(ai)->XER_encode(descr, p_buf,
- // Pass USE-NIL to the last field (except when USE-ORDER is also in effect,
- // because the tag-stripping effect of USE-NIL has been achieved
- // by encoding the sub-fields directly).
- flavor | ((exer && !use_order && (i == field_cnt-1)) ? (p_td.xer_bits & USE_NIL) : 0),
- indent+!omit_tag);
-
- // Now the next embed-values string (NOT affected by USE-ORDER!)
- if (exer && (p_td.xer_bits & EMBED_VALUES) && (i - begin + 1) < expected_embed) {
- embed_values->get_at(i - begin + 1)->XER_encode(UNIVERSAL_CHARSTRING_xer_
- , p_buf, flavor | EMBED_VALUES, indent+1);
- }
- } //for
+ if (!early_to_bed) {
+ embed_values_enc_struct_t* emb_val = 0;
+ if (exer && (p_td.xer_bits & EMBED_VALUES) && embed_values->size_of() > 1) {
+ emb_val = new embed_values_enc_struct_t;
+ emb_val->embval_array = embed_values;
+ emb_val->embval_index = 1;
+ emb_val->embval_err = 0;
+ }
+
+ for ( i = begin; i < end; ++i ) {
+ const Base_Type *uoe = 0; // "useOrder enum"
+ const Enum_Type *enm = 0; // the enum value selecting the field
+ if (exer && use_order) {
+ uoe = use_order->get_at(i - begin);
+ enm = static_cast<const Enum_Type *>(uoe);
+ }
+
+ // "actual" index, may be perturbed by USE-ORDER
+ int ai = !(exer && (p_td.xer_bits & USE_ORDER)) ? i :
+ enm->as_int() + useorder_base;
+ ec_1.set_msg("%s': ", ordered->fld_name(ai)); // non-attr
+
+ const XERdescriptor_t& descr = *ordered->xer_descr(ai);
+ sub_len += ordered->get_at(ai)->XER_encode(descr, p_buf,
+ // Pass USE-NIL to the last field (except when USE-ORDER is also in effect,
+ // because the tag-stripping effect of USE-NIL has been achieved
+ // by encoding the sub-fields directly).
+ flavor | ((exer && !use_order && (i == field_cnt-1)) ? (p_td.xer_bits & USE_NIL) : 0),
+ indent+!omit_tag, emb_val);
+
+ // Now the next embed-values string (NOT affected by USE-ORDER!)
+ if (exer && (p_td.xer_bits & EMBED_VALUES) && 0 != emb_val &&
+ emb_val->embval_index < embed_values->size_of()) {
+ embed_values->get_at(emb_val->embval_index)->XER_encode(UNIVERSAL_CHARSTRING_xer_
+ , p_buf, flavor | EMBED_VALUES, indent+1, 0);
+ ++emb_val->embval_index;
+ }
+ } //for
+
+ if (0 != emb_val) {
+ if (emb_val->embval_index < embed_values->size_of()) {
+ ec_1.set_msg("%s': ", fld_name(0));
+ TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_CONSTRAINT,
+ "Too many EMBED-VALUEs specified: %d (expected %d or less)",
+ embed_values->size_of(), emb_val->embval_index);
+ }
+ delete emb_val;
+ }
+ } // if (!early_to_bed)
} // if (QNAME)
if (!omit_tag) {
*/
int Record_Type::encode_field(int i,
const Erroneous_values_t* err_vals, const Erroneous_descriptor_t* emb_descr,
- TTCN_Buffer& p_buf, unsigned int sub_flavor, int indent) const
+ TTCN_Buffer& p_buf, unsigned int sub_flavor, int indent, embed_values_enc_struct_t* emb_val) const
{
int enc_len = 0;
TTCN_EncDec_ErrorContext ec;
if (err_vals->before->type_descr==NULL) TTCN_error(
"internal error: erroneous before typedescriptor missing");
enc_len += err_vals->before->errval->XER_encode(
- *err_vals->before->type_descr->xer, p_buf, sub_flavor, indent);
+ *err_vals->before->type_descr->xer, p_buf, sub_flavor, indent, 0);
}
}
if (err_vals->value->type_descr==NULL) TTCN_error(
"internal error: erroneous value typedescriptor missing");
enc_len += err_vals->value->errval->XER_encode(
- *err_vals->value->type_descr->xer, p_buf, sub_flavor, indent);
+ *err_vals->value->type_descr->xer, p_buf, sub_flavor, indent, 0);
}
} // else -> omit
} else {
ec.set_msg("Component %s: ", fld_name(i));
if (emb_descr) {
enc_len += get_at(i)->XER_encode_negtest(emb_descr, *xer_descr(i), p_buf,
- sub_flavor, indent);
+ sub_flavor, indent, emb_val);
} else {
// the "real" encoder
enc_len += get_at(i)->XER_encode(*xer_descr(i), p_buf,
- sub_flavor, indent);
+ sub_flavor, indent, emb_val);
}
}
if (err_vals->after->type_descr==NULL) TTCN_error(
"internal error: erroneous after typedescriptor missing");
enc_len += err_vals->after->errval->XER_encode(
- *err_vals->after->type_descr->xer, p_buf, sub_flavor, indent);
+ *err_vals->after->type_descr->xer, p_buf, sub_flavor, indent, 0);
}
}
// XERSTUFF Record_Type::XER_encode_negtest
int Record_Type::XER_encode_negtest(const Erroneous_descriptor_t* p_err_descr,
- const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, unsigned int flavor, int indent) const
+ const XERdescriptor_t& p_td, TTCN_Buffer& p_buf, unsigned int flavor, int indent,
+ embed_values_enc_struct_t*) const
{
if (!is_bound()) {
TTCN_EncDec_ErrorContext::error
if (ev->before->type_descr==NULL) TTCN_error(
"internal error: erroneous before typedescriptor missing");
sub_len += ev->before->errval->XER_encode(
- *ev->before->type_descr->xer, p_buf, flavor, indent);
+ *ev->before->type_descr->xer, p_buf, flavor, indent, 0);
}
}
if (ev->value->type_descr==NULL) TTCN_error(
"internal error: erroneous value typedescriptor missing");
sub_len += ev->value->errval->XER_encode(
- *ev->value->type_descr->xer, p_buf, flavor, indent);
+ *ev->value->type_descr->xer, p_buf, flavor, indent, 0);
}
} // else -> omit
} else {
// the "real" encoder
if (q_uri->is_present()) {
p_buf.put_s(11, (cbyte*)" xmlns:b0='");
- sub_len += q_uri->XER_encode(*xer_descr(0), p_buf, flavor | XER_LIST, indent+1);
+ sub_len += q_uri->XER_encode(*xer_descr(0), p_buf, flavor | XER_LIST, indent+1, 0);
p_buf.put_c('\'');
}
}
if (ev->after->type_descr==NULL) TTCN_error(
"internal error: erroneous after typedescriptor missing");
sub_len += ev->after->errval->XER_encode(
- *ev->after->type_descr->xer, p_buf, flavor, indent);
+ *ev->after->type_descr->xer, p_buf, flavor, indent, 0);
}
}
if (ev->before->type_descr==NULL) TTCN_error(
"internal error: erroneous before typedescriptor missing");
sub_len += ev->before->errval->XER_encode(
- *ev->before->type_descr->xer, p_buf, flavor, indent);
+ *ev->before->type_descr->xer, p_buf, flavor, indent, 0);
}
}
if (ev->value->type_descr==NULL) TTCN_error(
"internal error: erroneous value typedescriptor missing");
sub_len += ev->value->errval->XER_encode(
- *ev->value->type_descr->xer, p_buf, flavor, indent);
+ *ev->value->type_descr->xer, p_buf, flavor, indent, 0);
}
} // else -> omit
} else {
sub_len += 3;
}
- sub_len += get_at(1)->XER_encode(*xer_descr(1), p_buf, flavor | XER_LIST, indent+1);
+ sub_len += get_at(1)->XER_encode(*xer_descr(1), p_buf, flavor | XER_LIST, indent+1, 0);
}
}
if (ev->after->type_descr==NULL) TTCN_error(
"internal error: erroneous after typedescriptor missing");
sub_len += ev->after->errval->XER_encode(
- *ev->after->type_descr->xer, p_buf, flavor, indent);
+ *ev->after->type_descr->xer, p_buf, flavor, indent, 0);
}
}
else { // not USE-QNAME
if (!exer && (p_td.xer_bits & EMBED_VALUES)) {
// The EMBED-VALUES member as an ordinary record of string
- sub_len += embed_values->XER_encode(*xer_descr(0), p_buf, flavor, indent+1);
+ sub_len += embed_values->XER_encode(*xer_descr(0), p_buf, flavor, indent+1, 0);
}
if (!exer && (p_td.xer_bits & USE_ORDER)) {
// The USE-ORDER member as an ordinary record of enumerated
- sub_len += use_order->XER_encode(*xer_descr(uo_index), p_buf, flavor, indent+1);
+ sub_len += use_order->XER_encode(*xer_descr(uo_index), p_buf, flavor, indent+1, 0);
}
if (exer && (indent==0 || (flavor & DEF_NS_SQUASHED))) // write namespaces for toplevel only
boolean is_xer_attr_field = xer_descr(i)->xer_bits & XER_ATTRIBUTE;
ec_1.set_msg("%s': ", fld_name(i)); // attr
- tmp_len = encode_field(i, ev, ed, p_buf, flavor, indent + !omit_tag);
+ tmp_len = encode_field(i, ev, ed, p_buf, flavor, indent + !omit_tag, 0);
if (is_xer_attr_field && !exer) sub_len += tmp_len; // do not add if attribute and EXER
int embed_values_val_idx = 0;
int embed_values_descr_idx = 0;
- int expected_embed = (field_cnt - first_nonattr + 1);
if (exer && (p_td.xer_bits & EMBED_VALUES)) {
ed0 = p_err_descr->next_field_emb_descr(0, edescr_idx);
- ec_1.set_msg("%s': ", fld_name(0));
- int num_opt;
- if ((p_td.xer_bits & USE_NIL) && !get_at(field_cnt-1)->ispresent()) {
- expected_embed = 0; //25.2.6 a
- }
- else if ((num_opt = optional_count()) > 0) {
- const int * optionals = get_optional_indexes();
- for (int opt_idx = 0; opt_idx < num_opt; ++opt_idx) {
- // skip optional attributes
- if (optionals[opt_idx] < start_at + num_attributes) continue;
- // reduce for each omitted member
- if (!get_at(optionals[opt_idx])->is_present()) --expected_embed;
- }
- }
- // Check the correct number of EMBED-VALUES (regular non-attributes + 1)
- if (embed_values->size_of() != expected_embed)
- TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_CONSTRAINT,
- "Wrong number %d of EMBED-VALUEs, expected %d",
- embed_values->size_of(), expected_embed);
// write the first string
- if (expected_embed > 0) {
+ if (embed_values->size_of() > 0) {
const Erroneous_values_t * ev0_0 = NULL;
const Erroneous_descriptor_t* ed0_0 = NULL;
if (ed0) {
ed0_0 = ed0->next_field_emb_descr (0, embed_values_descr_idx);
}
sub_len += embed_values->encode_element(0, ev0_0, ed0_0,
- p_buf, flavor | EMBED_VALUES, indent+!omit_tag);
+ p_buf, flavor | EMBED_VALUES, indent+!omit_tag, 0);
}
}
// fields of this record; and the USE_ORDER case (with or without USE-NIL).
//
// early_to_bed can only be true if exer is true (transitive through nil_attribute)
- if (!early_to_bed) for ( i = begin; i < end; ++i ) {
-
- const Base_Type *uoe = 0; // "useOrder enum"
- const Enum_Type *enm = 0; // the enum value selecting the field
-
- // "actual" index, may be perturbed by USE-ORDER.
- // We use this value to index the appropriate record.
- int ai = i;
-
- const Erroneous_values_t * ev = NULL;
- const Erroneous_descriptor_t* ed = NULL;
- if (exer && use_order) {
- // If USE-ORDER is in effect, it introduces a level of indirection
- // into the indexing of fields: "i" is used to select an element
- // of the use_order member (an enum), whose value is used to select
- // the field being encoded.
- uoe = use_order->get_at(i - begin);
- enm = static_cast<const Enum_Type *>(uoe);
- ai = enm->as_int() + useorder_base;
-
- // Because it is not guaranteed that ai will increase monotonically,
- // we can't use next_field_...().
- ev = p_err_descr->get_field_err_values(ai);
- ed = p_err_descr->get_field_emb_descr (ai);
- }
- else { // not USE-ORDER, sequential access
- ev = p_err_descr->next_field_err_values(ai, values_idx);
- ed = p_err_descr->next_field_emb_descr (ai, edescr_idx);
- }
- ec_1.set_msg("%s': ", ordered->fld_name(ai)); // non-attr
-
- if (ai < p_err_descr->omit_before) continue;
-
- // omit_after value -1 becomes "very big".
- if ((unsigned int)ai > (unsigned int)p_err_descr->omit_after) continue;
- // We can't skip all fields with break, because the next ai may be lower
- // than omit_after.
-
- sub_len += ordered->encode_field(ai, ev, ed, p_buf,
- // Pass USE-NIL to the last field (except when USE-ORDER is also in effect,
- // because the tag-stripping effect of USE-NIL has been achieved
- // by encoding the sub-fields directly).
- flavor | ((exer && !use_order && (i == field_cnt-1)) ? (p_td.xer_bits & USE_NIL) : 0),
- indent + !omit_tag);
-
- // Now the next embed-values string (NOT affected by USE-ORDER!)
- int i1 = i - begin + 1;
- if (exer && (p_td.xer_bits & EMBED_VALUES) && i1 < expected_embed) {
- const Erroneous_values_t * ev0_i = NULL;
- const Erroneous_descriptor_t* ed0_i = NULL;
- if (ed0) {
- ev0_i = ed0->next_field_err_values(i1, embed_values_val_idx);
- ed0_i = ed0->next_field_emb_descr (i1, embed_values_descr_idx);
+ if (!early_to_bed) {
+ embed_values_enc_struct_t* emb_val = 0;
+ if (exer && (p_td.xer_bits & EMBED_VALUES) && embed_values->size_of() > 1) {
+ emb_val = new embed_values_enc_struct_t;
+ emb_val->embval_array = embed_values;
+ emb_val->embval_index = 1;
+ emb_val->embval_err = ed0;
+ emb_val->embval_err_val_idx = embed_values_val_idx;
+ emb_val->embval_err_descr_idx = embed_values_descr_idx;
+ }
+
+ for ( i = begin; i < end; ++i ) {
+
+ const Base_Type *uoe = 0; // "useOrder enum"
+ const Enum_Type *enm = 0; // the enum value selecting the field
+
+ // "actual" index, may be perturbed by USE-ORDER.
+ // We use this value to index the appropriate record.
+ int ai = i;
+
+ const Erroneous_values_t * ev = NULL;
+ const Erroneous_descriptor_t* ed = NULL;
+ if (exer && use_order) {
+ // If USE-ORDER is in effect, it introduces a level of indirection
+ // into the indexing of fields: "i" is used to select an element
+ // of the use_order member (an enum), whose value is used to select
+ // the field being encoded.
+ uoe = use_order->get_at(i - begin);
+ enm = static_cast<const Enum_Type *>(uoe);
+ ai = enm->as_int() + useorder_base;
+
+ // Because it is not guaranteed that ai will increase monotonically,
+ // we can't use next_field_...().
+ ev = p_err_descr->get_field_err_values(ai);
+ ed = p_err_descr->get_field_emb_descr (ai);
+ }
+ else { // not USE-ORDER, sequential access
+ ev = p_err_descr->next_field_err_values(ai, values_idx);
+ ed = p_err_descr->next_field_emb_descr (ai, edescr_idx);
+ }
+ ec_1.set_msg("%s': ", ordered->fld_name(ai)); // non-attr
+
+ if (ai < p_err_descr->omit_before) continue;
+
+ // omit_after value -1 becomes "very big".
+ if ((unsigned int)ai > (unsigned int)p_err_descr->omit_after) continue;
+ // We can't skip all fields with break, because the next ai may be lower
+ // than omit_after.
+
+ sub_len += ordered->encode_field(ai, ev, ed, p_buf,
+ // Pass USE-NIL to the last field (except when USE-ORDER is also in effect,
+ // because the tag-stripping effect of USE-NIL has been achieved
+ // by encoding the sub-fields directly).
+ flavor | ((exer && !use_order && (i == field_cnt-1)) ? (p_td.xer_bits & USE_NIL) : 0),
+ indent + !omit_tag, emb_val);
+
+ // Now the next embed-values string (NOT affected by USE-ORDER!)
+ if (exer && (p_td.xer_bits & EMBED_VALUES) && 0 != emb_val &&
+ emb_val->embval_index < embed_values->size_of()) {
+ const Erroneous_values_t * ev0_i = NULL;
+ const Erroneous_descriptor_t* ed0_i = NULL;
+ if (ed0) {
+ ev0_i = ed0->next_field_err_values(emb_val->embval_index, emb_val->embval_err_val_idx);
+ ed0_i = ed0->next_field_emb_descr (emb_val->embval_index, emb_val->embval_err_descr_idx);
+ }
+ embed_values->encode_element(emb_val->embval_index, ev0_i, ed0_i,
+ p_buf, flavor | EMBED_VALUES, indent + !omit_tag, 0);
+ ++emb_val->embval_index;
+ }
+ } //for
+ if (0 != emb_val) {
+ if (emb_val->embval_index < embed_values->size_of()) {
+ ec_1.set_msg("%s': ", fld_name(0));
+ TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_CONSTRAINT,
+ "Too many EMBED-VALUEs specified: %d (expected %d or less)",
+ embed_values->size_of(), emb_val->embval_index);
}
- embed_values->encode_element(i1, ev0_i, ed0_i,
- p_buf, flavor | EMBED_VALUES, indent + !omit_tag);
+ delete emb_val;
}
- } //for
+ } // if (!early_to_bed)
} // if (QNAME)
return (int)p_buf.get_len() - encoded_length;
}
-int Record_Type::XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader, unsigned int flavor)
+int Record_Type::XER_decode(const XERdescriptor_t& p_td, XmlReaderWrap& reader,
+ unsigned int flavor, embed_values_dec_struct_t*)
{
bound_flag = TRUE;
int exer = is_exer(flavor);
for (int k = 0; k < first_nonattr; ++k) {
if (xer_descr(k)->xer_bits & ANY_ATTRIBUTES) {
aa_index = k;
- static_cast<Record_Of_Type*>(get_at(aa_index))->set_size(0);
+ if (!get_at(aa_index)->is_optional()) {
+ static_cast<Record_Of_Type*>(get_at(aa_index))->set_size(0);
+ }
break; // there can be only one, 18.2.2
}
}
// First, the (would-be) attributes (unaffected by USE-ORDER)
for (i = 0; i < first_nonattr; i++) {
ec_1.set_msg("%s': ", fld_name(i));
- get_at(i)->XER_decode(*xer_descr(i), reader, flavor);
+ get_at(i)->XER_decode(*xer_descr(i), reader, flavor, 0);
} // next field
}
else if (own_tag || parent_tag) { // EXER and not UNTAGGED: do attributes
if (field_index != -1) {
// There is a field. Let it decode the attribute.
ec_1.set_msg("%s': ", fld_name(field_index));
- get_at(field_index)->XER_decode(*xer_descr(field_index), reader, flavor);
+ get_at(field_index)->XER_decode(*xer_descr(field_index), reader, flavor, 0);
continue;
}
TTCN_EncDec_ErrorContext ec_2("Attribute %d: ", num_aa);
// We have a component with ANY-ATTRIBUTE. It must be a record of
// UNIVERSAL_CHARSTRING. Add the attribute to it.
- Record_Of_Type *aa = static_cast<Record_Of_Type *>(get_at(aa_index));
+ Record_Of_Type *aa = 0;
+ if (get_at(aa_index)->is_optional()) {
+ if (num_aa == 0) {
+ get_at(aa_index)->set_to_present();
+ }
+ aa = static_cast<Record_Of_Type*>(get_at(aa_index)->get_opt_value());
+ }
+ else {
+ aa = static_cast<Record_Of_Type*>(get_at(aa_index));
+ }
UNIVERSAL_CHARSTRING *new_elem = static_cast<UNIVERSAL_CHARSTRING *>
(aa->get_at(num_aa++));
} // end if (own_tag)
/* * * * * * * * Non-attributes (elements) * * * * * * * * * * * */
- Record_Of_Type* embed_values = 0;
+ embed_values_dec_struct_t* emb_val = 0;
if (exer && (p_td.xer_bits & EMBED_VALUES)) {
- embed_values = static_cast<Record_Of_Type*>(get_at(0));
+ emb_val = new embed_values_dec_struct_t;
+ emb_val->embval_array = static_cast<Record_Of_Type*>(get_at(0));
+ emb_val->embval_array->set_size(0);
+ emb_val->embval_index = 0;
}
if (exer && (p_td.xer_bits & USE_ORDER)) {
int *seen = new int[end-begin];
int num_seen = 0;
int last_any_elem = begin - 1;
+ // The index of the latest embedded value can change outside of this function
+ // (if the field is a untagged record of), in this case the next value should
+ // be ignored, as it's already been handled by the record of
+ int last_embval_index = 0;
for (i = begin; i < end; i++) {
for (success = reader.Ok(); success == 1; success = reader.Read()) {
type = reader.NodeType();
- if (embed_values) {
- if (reader.NodeType()==XML_READER_TYPE_TEXT) {
- UNIVERSAL_CHARSTRING emb_ustr((const char*)reader.Value());
- embed_values->get_at(i-begin)->set_value(&emb_ustr);
- }
+ if (0 != emb_val && reader.NodeType()==XML_READER_TYPE_TEXT) {
+ UNIVERSAL_CHARSTRING emb_ustr((const char*)reader.Value());
+ emb_val->embval_array->get_at(emb_val->embval_index)->set_value(&emb_ustr);
}
// The non-attribute components must not be UNTAGGED
if (type == XML_READER_TYPE_ELEMENT) break;
// else if (type==XML_READER_TYPE_END_ELEMENT) panic?
}
+ if (0 != emb_val) {
+ if (last_embval_index == emb_val->embval_index) {
+ ++emb_val->embval_index;
+ }
+ last_embval_index = emb_val->embval_index;
+ }
if (success != 1) break;
const char *name = (const char *)reader.LocalName();
boolean field_name_found = false;
static_cast<Enum_Type*>(use_order->get_at(i - begin))
->from_int(in_dex);
Base_Type *b = jumbled->get_at(k);
- b->XER_decode(*jumbled->xer_descr(k), reader, flavor);
+ b->XER_decode(*jumbled->xer_descr(k), reader, flavor, emb_val);
field_name_found = true;
break;
}
static_cast<Enum_Type*>(use_order->get_at(i - begin))
->from_int(in_dex);
Base_Type *b = jumbled->get_at(k);
- b->XER_decode(*jumbled->xer_descr(k), reader, flavor);
+ b->XER_decode(*jumbled->xer_descr(k), reader, flavor, emb_val);
last_any_elem = k;
break;
}
}
}
} // next field
- if (embed_values) {
+ if (0 != emb_val) {
if (reader.NodeType()==XML_READER_TYPE_TEXT) {
UNIVERSAL_CHARSTRING emb_ustr((const char*)reader.Value());
- embed_values->get_at(i-begin)->set_value(&emb_ustr);
+ emb_val->embval_array->get_at(emb_val->embval_index)->set_value(&emb_ustr);
+ }
+ if (last_embval_index == emb_val->embval_index) {
+ ++emb_val->embval_index;
}
}
delete [] seen;
if (usenil_attribute) {
reader.MoveToElement(); // value absent, nothing more to do
} else {
- int emb_idx = 0;
+ // The index of the latest embedded value can change outside of this function
+ // (if the field is a untagged record of), in this case the next value should
+ // be ignored, as it's already been handled by the record of
+ // Omitted fields can also reset this value
+ int last_embval_index = 0;
for (; i<field_cnt; i++) {
- if (embed_values) {
+ if (0 != emb_val) {
if (reader.NodeType()==XML_READER_TYPE_TEXT) {
UNIVERSAL_CHARSTRING emb_ustr((const char*)reader.Value());
- embed_values->get_at(emb_idx)->set_value(&emb_ustr);
+ emb_val->embval_array->get_at(emb_val->embval_index)->set_value(&emb_ustr);
}
- emb_idx++;
+ if (last_embval_index == emb_val->embval_index) {
+ ++emb_val->embval_index;
+ }
+ last_embval_index = emb_val->embval_index;
}
ec_1.set_msg("%s': ", fld_name(i));
if (exer && i==field_cnt-1 && p_td.dfeValue && reader.IsEmptyElement()) {
if (i == field_cnt-1) new_flavor |= (p_td.xer_bits & USE_NIL);
if (tag_closed) new_flavor |= PARENT_CLOSED;
- get_at(i)->XER_decode(*xer_descr(i), reader, new_flavor);
+ get_at(i)->XER_decode(*xer_descr(i), reader, new_flavor, emb_val);
}
}
+ if (!get_at(i)->is_present()) {
+ // there was no new element, the last embedded value is for the next field
+ // (or the end of the record if this is the last field)
+ last_embval_index = -1;
+ }
} // next field
- if (embed_values) {
+ if (0 != emb_val) {
if (reader.NodeType()==XML_READER_TYPE_TEXT) {
UNIVERSAL_CHARSTRING emb_ustr((const char*)reader.Value());
- embed_values->get_at(emb_idx)->set_value(&emb_ustr);
+ emb_val->embval_array->get_at(emb_val->embval_index)->set_value(&emb_ustr);
+ }
+ if (last_embval_index == emb_val->embval_index) {
+ ++emb_val->embval_index;
}
}
}
} // if use-order
- if (embed_values) {
- // Set the embed_values member to the correct number of strings
- int num_embedded = 0; // if usenil_attribute
- if (!usenil_attribute) {
- num_embedded = field_cnt - first_nonattr + 1;
- const int num_opt = optional_count();
- const int * optionals = get_optional_indexes();
- for (int opt_idx = 0; opt_idx < num_opt; ++opt_idx) {
- // skip optional attributes
- if (optionals[opt_idx] < start_at + num_attributes) continue;
- // reduce for each omitted member
- if (!get_at(optionals[opt_idx])->is_present()) --num_embedded;
- }
- }
- embed_values->set_size(num_embedded);
+ if (0 != emb_val) {
static const UNIVERSAL_CHARSTRING emptystring(0, (const char*)NULL);
- for (int j = 0; j < num_embedded; ++j) {
- if (!embed_values->get_at(j)->is_bound()) embed_values->get_at(j)->set_value(&emptystring);
+ for (int j = 0; j < emb_val->embval_index; ++j) {
+ if (!emb_val->embval_array->get_at(j)->is_bound()) {
+ emb_val->embval_array->get_at(j)->set_value(&emptystring);
+ }
}
+ delete emb_val;
} // if embed-values
} // if use-qname
case TTCN_EncDec::CT_XER: {
TTCN_EncDec_ErrorContext ec("While XER-encoding type '%s': ", p_td.name);
unsigned XER_coding=va_arg(pvar, unsigned);
- XER_encode(*(p_td.xer),p_buf, XER_coding, 0);
+ XER_encode(*(p_td.xer),p_buf, XER_coding, 0, 0);
p_buf.put_c('\n');
break;}
case TTCN_EncDec::CT_JSON: {
for (int success=reader.Read(); success==1; success=reader.Read()) {
if (reader.NodeType() == XML_READER_TYPE_ELEMENT) break;
}
- XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL);
+ XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL, 0);
size_t bytes = reader.ByteConsumed();
p_buf.set_pos(bytes);
break;}
}
int Empty_Record_Type::XER_encode(const XERdescriptor_t& p_td,
- TTCN_Buffer& p_buf, unsigned int flavor, int indent) const
+ TTCN_Buffer& p_buf, unsigned int flavor, int indent, embed_values_enc_struct_t*) const
{
int encoded_length=(int)p_buf.get_len();
int indenting = !is_canonical(flavor);
}
int Empty_Record_Type::XER_decode(const XERdescriptor_t& p_td,
- XmlReaderWrap& reader, unsigned int flavor)
+ XmlReaderWrap& reader, unsigned int flavor, embed_values_dec_struct_t*)
{
int exer = is_exer(flavor);
bound_flag = true;
projects / deliverable / titan.core.git / blobdiff