Commit 746fecb2 authored by BenceJanosSzabo's avatar BenceJanosSzabo
Browse files

XER: usage of Fractiondigits encoding instruction is implemented (Bug 506196)



Change-Id: I6053c66638e56af3c20a8a223ad89b3ac0b99f75
Signed-off-by: default avatarBenceJanosSzabo <bence.janos.szabo@ericsson.com>
parent 1138a9a9
......@@ -2188,7 +2188,14 @@ void Type::chk_xer() { // XERSTUFF semantic check
if (last->typetype != T_REAL) {
error("DECIMAL shall only be assigned to a real type");
}
} // if DECIMAL
if (xerattrib->has_fractionDigits_) {
if (xerattrib->fractionDigits_ < 0) {
error("The value of fractionDigits must be equal or greater than zero");
}
}
} else if (xerattrib->has_fractionDigits_) {
error("The fractionDigits encoding instruction shall be used with XSD.Decimal types.");
} // if DECIMAL
if (xerattrib->defaultForEmpty_ != 0) {
chk_xer_dfe();
......
......@@ -505,7 +505,7 @@ void Type::generate_code_xerdescriptor(output_struct* target)
int atrib=0, any_atr=0, any_elem=0, base64=0, decimal=0, embed=0, list=0,
text=0, untagged=0, use_nil=0, use_number=0, use_order=0, use_qname=0,
use_type_attr=0, ws=0, has_1untag=0, form_qualified=0, any_from=0,
any_except=0, nof_ns_uris=0, blocked=0;
any_except=0, nof_ns_uris=0, blocked=0, fractionDigits=-1;
const char* dfe_str = 0;
char** ns_uris = 0;
char* oftype_descr_name = 0;
......@@ -527,6 +527,7 @@ void Type::generate_code_xerdescriptor(output_struct* target)
embed = xerattrib->embedValues_;
form_qualified = (xerattrib->form_ & XerAttributes::QUALIFIED)
|| (xerattrib->element_); // a global element is always qualified
fractionDigits = xerattrib->has_fractionDigits_ ? xerattrib->fractionDigits_ : -1;
list = xerattrib->list_;
untagged= xerattrib->untagged_;
ws = xerattrib->whitespace_;
......@@ -619,12 +620,12 @@ void Type::generate_code_xerdescriptor(output_struct* target)
}
target->source.global_vars = mputstrn(target->source.global_vars, "};\n", 3);
}
// Generate the XER descriptor itself
target->source.global_vars = mputprintf(target->source.global_vars,
"const XERdescriptor_t %s_xer_ = { {\"%s>\\n\", \"%s>\\n\"},"
" {%lu, %lu}, %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s, WHITESPACE_%s, %c%s, "
"&%s, %ld, %u, %s, %s };\n",
"&%s, %ld, %u, %s, %s, %i };\n",
gennameown_str,
bxer_name.c_str(), last_s.c_str(), // names
(unsigned long)bxer_len, (unsigned long)last_len, // lengths
......@@ -654,7 +655,8 @@ void Type::generate_code_xerdescriptor(output_struct* target)
ns_index,
nof_ns_uris,
(ns_uris_var ? ns_uris_var : "NULL"),
(oftype_descr_name ? oftype_descr_name : "NULL")
(oftype_descr_name ? oftype_descr_name : "NULL"),
fractionDigits
);
Free(ns_uris_var);
......
......@@ -10,6 +10,7 @@
* Baranyi, Botond
* Raduly, Csaba
* Szabados, Kristof
* Szabo, Bence Janos
*
******************************************************************************/
/*
......@@ -44,6 +45,8 @@ XerAttributes::XerAttributes()
, element_(false)
, embedValues_(false)
, form_(UNSET)
, has_fractionDigits_(false)
, fractionDigits_(0)
, hex_(false)
, list_(false)
, name_(nochange)
......@@ -171,6 +174,7 @@ void XerAttributes::print(const char *type_name) const {
if (element_) fputs("ELEMENT\n", stderr);
fputs(embedValues_ ? "EMBED-VALUES\n" : "", stderr);
fputs((form_ & QUALIFIED) ? "FORM AS QUALIFIED\n" : "", stderr);
if (has_fractionDigits_) fprintf(stderr, "FRACTIONDIGITS '%i'\n", fractionDigits_);
fputs(hex_ ? "hexBinary" : "", stderr);
fputs(list_ ? "LIST\n" : "", stderr);
......@@ -283,6 +287,8 @@ other.print("other");
element_ |= other.element_;
embedValues_ |= other.embedValues_;
form_ = other.form_;
has_fractionDigits_ = other.has_fractionDigits_;
fractionDigits_ = other.fractionDigits_;
hex_ |= other.hex_;
list_ |= other.list_;
if (other.name_.kw_ != NamespaceSpecification::NO_MANGLING) {
......@@ -386,6 +392,7 @@ bool XerAttributes::empty() const
&& !element_
&& !embedValues_
&& !(form_ & LOCALLY_SET)
&& !has_fractionDigits_
&& !hex_
&& !list_
&& name_.kw_ == NamespaceSpecification::NO_MANGLING
......
......@@ -9,6 +9,7 @@
* Balasko, Jeno
* Baranyi, Botond
* Raduly, Csaba
* Szabo, Bence Janos
*
******************************************************************************/
/*
......@@ -161,6 +162,10 @@ public:
bool embedValues_;
/// Qualified or unqualified form for local elements and attributes
unsigned short form_;
// True if there was fractionDigits variant
bool has_fractionDigits_;
// fractionDigits on float number
int fractionDigits_;
/// XSD:hexBinary
bool hex_;
/// space-separated values for record-of/set-of
......
......@@ -357,6 +357,7 @@ element RETURN(XKWelement);
elementFormQualified RETURN(XKWelementFormQualified);
embedValues RETURN(XKWembedValues);
form RETURN(XKWform);
fractionDigits RETURN(XKWfractionDigits);
list RETURN(XKWlist);
name RETURN(XKWname);
namespace RETURN(XKWnamespace);
......
......@@ -194,6 +194,7 @@ static void yyprint(FILE *file, int type, const YYSTYPE& value);
%token XKWelementFormQualified "elementFormQualified"
%token XKWembedValues "embedValues"
%token XKWform "form"
%token XKWfractionDigits "fractionDigits"
%token XKWlist "list"
%token XKWname "name"
%token XKWnamespace "namespace"
......@@ -333,7 +334,7 @@ static void yyprint(FILE *file, int type, const YYSTYPE& value);
%type <nsspec> namespace namespacespecification controlNamespace text
%type <intval> whiteSpace
%type <intval> whiteSpace fractionDigits
/* destructors */
%destructor { Free($$); }
......@@ -1311,6 +1312,7 @@ XERattribute:
| XKWelementFormQualified { xerstruct->form_ |= XerAttributes::ELEMENT_DEFAULT_QUALIFIED; }
| XKWembedValues { xerstruct->embedValues_ = true; }
| form { xerstruct->form_ |= $1; }
| fractionDigits { xerstruct->fractionDigits_ = $1; xerstruct->has_fractionDigits_ = true; }
| XKWlist { xerstruct->list_ = true; }
| name
{ /* overwrites any previous name */
......@@ -1469,6 +1471,10 @@ defaultForEmpty:
{ $$ = $3; }
;
fractionDigits:
XKWfractionDigits XNumber
{ $$ = $2; }
whiteSpace:
......
......@@ -872,6 +872,14 @@ int FLOAT::XER_encode(const XERdescriptor_t& p_td,
n = snprintf(buf, sizeof(buf), "%s", XER_NEG_INF_STR);
} else {
n = snprintf(buf, sizeof(buf), "%f", (double)float_value);
if (p_td.fractionDigits != -1) {
char *p = strchr(buf, '.');
if (p != NULL) {
int offset = p_td.fractionDigits == 0 ? 0 : p_td.fractionDigits + 1;
p[offset] = 0;
n = strlen(buf);
}
}
}
p_buf.put_s((size_t)n, (const unsigned char*)buf);
}
......@@ -966,6 +974,18 @@ tagless:
const char * value = (const char *)reader.Value();
if (value) {
if (is_float(value)) {
if (exer && (p_td.xer_bits & XER_DECIMAL) && p_td.fractionDigits != -1) {
char *p = strchr((char*)value, '.');
if (p != NULL) {
unsigned int fraction_digits_pos = (int)(p - value) + 1 + p_td.fractionDigits;
if (fraction_digits_pos < strlen(value)) {
TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_FLOAT_TR,
"The float value (%s) contains too many fractionDigits. Expected %i or less.",
value,
p_td.fractionDigits);
}
}
}
bound_flag = true;
sscanf(value, "%lf", &float_value);
} else if (strcmp(XER_NAN_STR, value) == 0 ) {
......@@ -1008,6 +1028,18 @@ tagless:
const char * value = (const char*)reader.Value();
if (value) {
if (is_float(value)) {
if (exer && (p_td.xer_bits & XER_DECIMAL) && p_td.fractionDigits != -1) {
char *p = strchr((char*)value, '.');
if (p != NULL) {
unsigned int fraction_digits_pos = (int)(p - value) + 1 + p_td.fractionDigits;
if (fraction_digits_pos < strlen(value)) {
TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_FLOAT_TR,
"The float value (%s) contains too many fractionDigits. Expected %i or less.",
value,
p_td.fractionDigits);
}
}
}
bound_flag = true;
sscanf(value, "%lf", &float_value);
} else if (strcmp("NaN", value) == 0 ) {
......
......@@ -279,6 +279,12 @@ struct XERdescriptor_t
/** Points to the element type's XER descriptor in case of 'record of' and 'set of' types */
const XERdescriptor_t* oftype_descr;
/** Fraction digits value
* It is already checked that is must not be a negative number.
* The -1 value is used to determine if fractionDigits encoding instruction is present,
* so if the value is -1, no checks will be made. */
const int fractionDigits;
};
/** Information related to the embedded values in XML encoding
......@@ -448,7 +454,7 @@ void check_namespace_restrictions(const XERdescriptor_t& p_td, const char* p_xml
extern const XERdescriptor_t type_name##_xer_ = { \
{ xmlname ">\n", xmlname ">\n" }, \
{ 2+sizeof(xmlname)-1, 2+sizeof(xmlname)-1 }, \
0UL, WHITESPACE_PRESERVE, NULL, NULL, 0, 0, NULL, NULL }
0UL, WHITESPACE_PRESERVE, NULL, NULL, 0, 0, NULL, NULL, -1 }
// The compiler should fold the two identical strings into one
# define XER_STRUCT_COPY(cpy,original) \
......
/******************************************************************************
* Copyright (c) 2000-2016 Ericsson Telecom AB
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Szabo, Bence Janos
*
******************************************************************************/
module fractionDigits_SE { //^In TTCN-3 module `fractionDigits_SE'://
type float MyFloat //^In type definition// //^error: The fractionDigits encoding instruction shall be used with XSD\.Decimal types\.//
with {
variant "fractionDigits 2";
};
type float MyFloat2
with {
variant "fractionDigits 2";
variant "XSD:decimal"
};
type float MyFloat3;
type record MyRec { //^In type definition//
MyFloat3 myfloat //^In record field// //^error: The fractionDigits encoding instruction shall be used with XSD\.Decimal types//
}
with {
variant (myfloat) "fractionDigits 2";
variant (myfloat) "attribute";
};
}
with {
encode "XML";
}
......@@ -71,6 +71,189 @@ A 2014-04-29 EBOTBAR New document
.*---------------------------------------------------------------------*
:h4. Encoding record template with explicitly unspecified field
.*---------------------------------------------------------------------*
.*---------------------------------------------------------------------*
:h4. Too many fraction digits when fractionDigits is 2
.*---------------------------------------------------------------------*
:xmp tab=0.
<TC - Too many fraction digits when fractionDigits is 2>
<STATIC>
type component Test_CT{};
<TTCN_TC:PURE_EXEC>
type float MyFloat
with {
encode "XML";
variant "fractionDigits 2";
variant "XSD:decimal";
};
external function ef_xer_dec(in octetstring par) return MyFloat
with { extension "prototype(convert) decode (XER:XER_EXTENDED) errorbehavior(ALL:ERROR)" }
testcase tc_dec_fractiondigits() runs on Test_CT {
var universal charstring xml := "<MyFloat>1234567890.111</MyFloat>\n";
ef_xer_dec(unichar2oct(xml));
setverdict(pass);
}
control {
execute(tc_dec_fractiondigits());
}
<RESULT>
Dynamic test case error: While XER-decoding type '@Temp.MyFloat': The float value (1234567890.111) contains too many fractionDigits. Expected 2 or less
<END_TC>
:exmp.
.*---------------------------------------------------------------------*
:h4. Too many fraction digits when fractionDigits is 0
.*---------------------------------------------------------------------*
:xmp tab=0.
<TC - Too many fraction digits when fractionDigits is 0>
<STATIC>
type component Test_CT{};
<TTCN_TC:PURE_EXEC>
type float MyFloat
with {
encode "XML";
variant "fractionDigits 0";
variant "XSD:decimal";
};
external function ef_xer_dec(in octetstring par) return MyFloat
with { extension "prototype(convert) decode (XER:XER_EXTENDED) errorbehavior(ALL:ERROR)" }
testcase tc_dec_fractiondigits() runs on Test_CT {
var universal charstring xml := "<MyFloat>1234567890.1</MyFloat>\n";
ef_xer_dec(unichar2oct(xml));
setverdict(pass);
}
control {
execute(tc_dec_fractiondigits());
}
<RESULT>
Dynamic test case error: While XER-decoding type '@Temp.MyFloat': The float value (1234567890.1) contains too many fractionDigits. Expected 0 or less
<END_TC>
:exmp.
.*---------------------------------------------------------------------*
:h4. Too many fraction digits when fractionDigits is 2 in attribute
.*---------------------------------------------------------------------*
:xmp tab=0.
<TC - Too many fraction digits when fractionDigits is 2 in attribute>
<STATIC>
type component Test_CT{};
<TTCN_TC:PURE_EXEC>
type float MyFloat
with {
encode "XML";
variant "XSD:decimal";
};
type record MyRec {
MyFloat myfloat
}
with {
encode "XML";
variant (myfloat) "fractionDigits 2";
variant (myfloat) "attribute";
};
external function ef_xer_dec(in octetstring par) return MyRec
with { extension "prototype(convert) decode (XER:XER_EXTENDED) errorbehavior(ALL:ERROR)" }
testcase tc_dec_fractiondigits_attr() runs on Test_CT {
var universal charstring xml := "<MyRec myfloat='1234567890.111'></MyRec>\n";
ef_xer_dec(unichar2oct(xml));
setverdict(pass);
}
control {
execute(tc_dec_fractiondigits_attr());
}
<RESULT>
Dynamic test case error: While XER-decoding type '@Temp.MyRec': Component 'myfloat': The float value (1234567890.111) contains too many fractionDigits. Expected 2 or less.
<END_TC>
:exmp.
.*---------------------------------------------------------------------*
:h4. Too many fraction digits when fractionDigits is 0 in attribute
.*---------------------------------------------------------------------*
:xmp tab=0.
<TC - Too many fraction digits when fractionDigits is 0 in attribute>
<STATIC>
type component Test_CT{};
<TTCN_TC:PURE_EXEC>
type float MyFloat
with {
encode "XML";
variant "XSD:decimal";
};
type record MyRec {
MyFloat myfloat
}
with {
encode "XML";
variant (myfloat) "fractionDigits 0";
variant (myfloat) "attribute";
};
external function ef_xer_dec(in octetstring par) return MyRec
with { extension "prototype(convert) decode (XER:XER_EXTENDED) errorbehavior(ALL:ERROR)" }
testcase tc_dec_fractiondigits_attr() runs on Test_CT {
var universal charstring xml := "<MyRec myfloat='1234567890.1'></MyRec>\n";
ef_xer_dec(unichar2oct(xml));
setverdict(pass);
}
control {
execute(tc_dec_fractiondigits_attr());
}
<RESULT>
Dynamic test case error: While XER-decoding type '@Temp.MyRec': Component 'myfloat': The float value (1234567890.1) contains too many fractionDigits. Expected 0 or less.
<END_TC>
:exmp.
:xmp tab=0.
<TC - Encoding record with any element from unqualified namespace>
......
/******************************************************************************
* Copyright (c) 2000-2016 Ericsson Telecom AB
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Szabo, Bence Janos
*
******************************************************************************/
module FractionDigitsTest {
modulepar boolean FractionDigitsTest_verbose := false;
#define verbose FractionDigitsTest_verbose
#include "../macros.ttcnin"
type float MyFloatDecimal2
with {
variant "XSD:decimal"
variant "fractionDigits 2"
}
type float MyFloatDecimal0
with {
variant "XSD:decimal"
variant "fractionDigits 0"
}
type record MyRec {
MyFloatDecimal2 myfloat
}
with {
variant (myfloat) "fractionDigits 2";
variant (myfloat) "attribute";
};
type component FDT {}
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
DECLARE_XER_ENCODERS(MyFloatDecimal2, fdec2)
DECLARE_EXER_ENCODERS(MyFloatDecimal2, fdec2)
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
const MyFloatDecimal2 myfdec2 := 12345.6789;
const universal charstring c_myfxml2_bxer := "<MyFloatDecimal2>12345.678900</MyFloatDecimal2>\n";
const universal charstring c_myfxml2_exer := "<MyFloatDecimal2>12345.67</MyFloatDecimal2>\n";
const MyFloatDecimal2 myfdec2_2 := 12345.1;
const universal charstring c_myfxml2_2_bxer := "<MyFloatDecimal2>12345.100000</MyFloatDecimal2>\n";
const universal charstring c_myfxml2_2_exer := "<MyFloatDecimal2>12345.10</MyFloatDecimal2>\n";
const MyFloatDecimal2 myfdec2_3 := 12345E-4;
const universal charstring c_myfxml2_3_bxer := "<MyFloatDecimal2>1.234500</MyFloatDecimal2>\n";
const universal charstring c_myfxml2_3_exer := "<MyFloatDecimal2>1.23</MyFloatDecimal2>\n";
const MyFloatDecimal2 myfdec2_4 := 12345E-1;
const universal charstring c_myfxml2_4_bxer := "<MyFloatDecimal2>1234.500000</MyFloatDecimal2>\n";
const universal charstring c_myfxml2_4_exer := "<MyFloatDecimal2>1234.50</MyFloatDecimal2>\n";
const MyFloatDecimal2 myfdec2_5 := 12345E+0;
const universal charstring c_myfxml2_5_bxer := "<MyFloatDecimal2>12345.000000</MyFloatDecimal2>\n";
const universal charstring c_myfxml2_5_exer := "<MyFloatDecimal2>12345.00</MyFloatDecimal2>\n";
const MyFloatDecimal2 myfdec2_6 := 12345E-0;
const universal charstring c_myfxml2_6_bxer := "<MyFloatDecimal2>12345.000000</MyFloatDecimal2>\n";
const universal charstring c_myfxml2_6_exer := "<MyFloatDecimal2>12345.00</MyFloatDecimal2>\n";
const MyFloatDecimal2 myfdec2_7 := 12345E+1;
const universal charstring c_myfxml2_7_bxer := "<MyFloatDecimal2>123450.000000</MyFloatDecimal2>\n";
const universal charstring c_myfxml2_7_exer := "<MyFloatDecimal2>123450.00</MyFloatDecimal2>\n";
const MyFloatDecimal2 myfdec2_8 := 1234567890.0987654321;
const universal charstring c_myfxml2_8_bxer := "<MyFloatDecimal2>1234567890.098770</MyFloatDecimal2>\n";
const universal charstring c_myfxml2_8_exer := "<MyFloatDecimal2>1234567890.09</MyFloatDecimal2>\n";
testcase float_decimal_enc2() runs on FDT
{
CHECK_METHOD(bxer_enc_fdec2, myfdec2, c_myfxml2_bxer);
CHECK_METHOD(exer_enc_fdec2, myfdec2, c_myfxml2_exer);
CHECK_METHOD(bxer_enc_fdec2, myfdec2_2, c_myfxml2_2_bxer);
CHECK_METHOD(exer_enc_fdec2, myfdec2_2, c_myfxml2_2_exer);
CHECK_METHOD(bxer_enc_fdec2, myfdec2_3, c_myfxml2_3_bxer);
CHECK_METHOD(exer_enc_fdec2, myfdec2_3, c_myfxml2_3_exer);
CHECK_METHOD(bxer_enc_fdec2, myfdec2_4, c_myfxml2_4_bxer);
CHECK_METHOD(exer_enc_fdec2, myfdec2_4, c_myfxml2_4_exer);
CHECK_METHOD(bxer_enc_fdec2, myfdec2_5, c_myfxml2_5_bxer);
CHECK_METHOD(exer_enc_fdec2, myfdec2_5, c_myfxml2_5_exer);
CHECK_METHOD(bxer_enc_fdec2, myfdec2_6, c_myfxml2_6_bxer);
CHECK_METHOD(exer_enc_fdec2, myfdec2_6, c_myfxml2_6_exer);
CHECK_METHOD(bxer_enc_fdec2, myfdec2_7, c_myfxml2_7_bxer);
CHECK_METHOD(exer_enc_fdec2, myfdec2_7, c_myfxml2_7_exer);
CHECK_METHOD(bxer_enc_fdec2, myfdec2_8, c_myfxml2_8_bxer);
CHECK_METHOD(exer_enc_fdec2, myfdec2_8, c_myfxml2_8_exer);
}
testcase float_decimal_dec2() runs on FDT
{
CHECK_DECODE(bxer_dec_fdec2, c_myfxml2_bxer, MyFloatDecimal2, myfdec2);
CHECK_DECODE(exer_dec_fdec2, c_myfxml2_exer, MyFloatDecimal2, 12345.670000);
CHECK_DECODE(bxer_dec_fdec2, c_myfxml2_2_bxer, MyFloatDecimal2, myfdec2_2);
CHECK_DECODE(exer_dec_fdec2, c_myfxml2_2_exer, MyFloatDecimal2, 12345.100000);
CHECK_DECODE(bxer_dec_fdec2, c_myfxml2_3_bxer, MyFloatDecimal2, myfdec2_3);
CHECK_DECODE(exer_dec_fdec2, c_myfxml2_3_exer, MyFloatDecimal2, 1.230000);
CHECK_DECODE(bxer_dec_fdec2, c_myfxml2_4_bxer, MyFloatDecimal2, myfdec2_4);
CHECK_DECODE(exer_dec_fdec2, c_myfxml2_4_exer, MyFloatDecimal2, 1234.500000);
CHECK_DECODE(bxer_dec_fdec2, c_myfxml2_5_bxer, MyFloatDecimal2, myfdec2_5);
CHECK_DECODE(exer_dec_fdec2, c_myfxml2_5_exer, MyFloatDecimal2, 12345.000000);
CHECK_DECODE(bxer_dec_fdec2, c_myfxml2_6_bxer, MyFloatDecimal2, myfdec2_6);
CHECK_DECODE(exer_dec_fdec2, c_myfxml2_6_exer, MyFloatDecimal2, 12345.000000);
CHECK_DECODE(bxer_dec_fdec2, c_myfxml2_7_bxer, MyFloatDecimal2, myfdec2_7);
CHECK_DECODE(exer_dec_fdec2, c_myfxml2_7_exer, MyFloatDecimal2, 123450.000000);
CHECK_DECODE(bxer_dec_fdec2, c_myfxml2_8_bxer, MyFloatDecimal2, myfdec2_8);
CHECK_DECODE(exer_dec_fdec2, c_myfxml2_8_exer, MyFloatDecimal2, 1234567890.090000);
}
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
DECLARE_XER_ENCODERS(MyFloatDecimal0, fdec0)
DECLARE_EXER_ENCODERS(MyFloatDecimal0, fdec0)
const MyFloatDecimal0 myfdec0 := 12345.6789;
const universal charstring c_myfxml0_bxer := "<MyFloatDecimal0>12345.678900</MyFloatDecimal0>\n";
const universal charstring c_myfxml0_exer := "<MyFloatDecimal0>12345</MyFloatDecimal0>\n";
const MyFloatDecimal0 myfdec0_2 := 12345.1;
const universal charstring c_myfxml0_2_bxer := "<MyFloatDecimal0>12345.100000</MyFloatDecimal0>\n";
const universal charstring c_myfxml0_2_exer := "<MyFloatDecimal0>12345</MyFloatDecimal0>\n";
const MyFloatDecimal0 myfdec0_3 := 12345E-4;
const universal charstring c_myfxml0_3_bxer := "<MyFloatDecimal0>1.234500</MyFloatDecimal0>\n";
const universal charstring c_myfxml0_3_exer := "<MyFloatDecimal0>1</MyFloatDecimal0>\n";
const MyFloatDecimal0 myfdec0_4 := 12345E-1;
const universal charstring c_myfxml0_4_bxer := "<MyFloatDecimal0>1234.500000</MyFloatDecimal0>\n";