core/XER.hh

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Copyright (c) 2000-2015 Ericsson Telecom AB
   3 // All rights reserved. This program and the accompanying materials
   4 // are made available under the terms of the Eclipse Public License v1.0
   5 // which accompanies this distribution, and is available at
   6 // http://www.eclipse.org/legal/epl-v10.html
   7 ///////////////////////////////////////////////////////////////////////////////
   8 #ifndef XER_HH_
   9 #define XER_HH_
  10
  11 #include "Types.h"
  12 #include "Encdec.hh"
  13 #include <stddef.h> // for size_t
  14 #include <string.h> // strncmp for the inline function
  15
  16 class XmlReaderWrap;
  17
  18 class Base_Type;
  19 #ifdef TITAN_RUNTIME_2
  20 class Record_Of_Type;
  21 class Erroneous_descriptor_t;
  22 #else
  23 namespace PreGenRecordOf {
  24   class PREGEN__RECORD__OF__UNIVERSAL__CHARSTRING;
  25   class PREGEN__RECORD__OF__UNIVERSAL__CHARSTRING__OPTIMIZED;
  26 }
  27 #endif
  28 class TTCN_Module;
  29
  30 /** @defgroup XER XER codec
  31  * @{
  32  *
  33  * @brief ASN.1 XML Encoding Rules, ITU-T Rec X.693 and amd1
  34  */
  35
  36 /** XER flags for various uses.
  37  *
  38  * Low values specify the XML encoding variant (Basic, Canonical, Extended)
  39  * Other bits have dual uses:
  40  * - set in XERdescriptor_t::xer_bits, according to XML encoding attributes
  41  * - passed in as additional flags in the \c flavor parameter, usually
  42  * to XER_encode. These are used when encoding attributes in a parent type
  43  * influence the encoding of its components (e.g. EMBED-VALUES on a record
  44  * change the encoding of all components).
  45  */
  46 enum XER_flavor {
  47   XER_BASIC           = 1U << 0, /**< Basic XER with indentation */
  48   XER_CANONICAL       = 1U << 1, /**< Canonical XER, no indentation */
  49   XER_EXTENDED        = 1U << 2, /**< Extended XER */
  50   DEF_NS_PRESENT      = 1U << 3, // 0x08
  51   DEF_NS_SQUASHED     = 1U << 4, // 0x10
  52   XER_MASK            = 0x1FU,   /**< All the "real" XER flavors plus DEF_NS */
  53
  54   /* Additional flags, for the parent to pass information to its children
  55    * (when the parent affects the child, e.g. LIST) */
  56   XER_ESCAPE_ENTITIES = 1U << 5, /**< Escape according to X.680/2002, 11.15.8,
  57   used internally by UNIVERSAL_CHARSTRING. */
  58   XER_RECOF          = 1U << 6, /**< Generating code for the contained type
  59   of a record-of/set-of. Only affects BOOLEAN, CHOICE, ENUMERATED and NULL
  60   (see Table 5 in X.680 (11/2008) clause 26.5) */
  61
  62   /* More flags for XERdescriptor_t::xer_bits */
  63   ANY_ATTRIBUTES = 1U << 7,  //  0xooo80
  64   ANY_ELEMENT    = 1U << 8,  //  0xoo100
  65   XER_ATTRIBUTE  = 1U << 9,  //  0xoo200
  66   BASE_64        = 1U << 10, //  0xoo400
  67   XER_DECIMAL    = 1U << 11, //  0xoo800
  68   // DEFAULT-FOR-EMPTY has its own field
  69   EMBED_VALUES   = 1U << 12, //  0xo1000
  70   /** LIST encoding instruction for record-of/set-of. */
  71   XER_LIST       = 1U << 13, //  0xo2000
  72   // NAME is stored in the descriptor
  73   // NAMESPACE is folded into the name
  74   XER_TEXT       = 1U << 14, //  0xo4000
  75   UNTAGGED       = 1U << 15, //  0xo8000
  76   USE_NIL        = 1U << 16, //  0x10000
  77   USE_NUMBER     = 1U << 17, //  0x20000
  78   USE_ORDER      = 1U << 18, //  0x40000
  79   USE_QNAME      = 1U << 19, //  0x80000
  80   USE_TYPE_ATTR  = 1U << 20, // 0x100000, either USE-TYPE or USE-UNION
  81   HAS_1UNTAGGED  = 1U << 21, // 0x200000 member, and it's character-encodable
  82   // another hint to pass down to the children:
  83   PARENT_CLOSED  = 1U << 22, // 0x400000
  84   FORM_UNQUALIFIED=1U << 23, // 0X800000 (qualified is more frequent)
  85   XER_TOPLEVEL   = 1U << 24, //0X1000000 (toplevel, for decoding)
  86   SIMPLE_TYPE    = 1U << 25, /*0X2000000 always encode on one line:
  87   <foo>content</foo>, never <foo>\ncontent\n</foo> */
  88   BXER_EMPTY_ELEM= 1U << 26,  /*0X4000000 boolean and enum encode themselves
  89   as empty elements in BXER only. This also influences them in record-of */
  90   ANY_FROM       = 1U << 27, // 0x8000000 anyElement from ... or anyAttributes from ...
  91   ANY_EXCEPT     = 1U << 28, // 0x10000000 anyElement except ... or anyAttributes except ...
  92   EXIT_ON_ERROR  = 1U << 29  /* 0x20000000 clean up and exit instead of throwing
  93   a decoding error, used on alternatives of a union with USE-UNION */
  94 };
  95
  96 /** WHITESPACE actions.
  97  * Note that WHITESPACE_COLLAPSE includes the effect of WHITESPACE_REPLACE
  98  * and the code relies on WHITESPACE_COLLAPSE having the higher value. */
  99 enum XER_whitespace_action {
 100   WHITESPACE_PRESERVE,
 101   WHITESPACE_REPLACE,
 102   WHITESPACE_COLLAPSE
 103 };
 104
 105 /// Check that \p f has the canonical flavor.
 106 inline bool is_canonical(unsigned int f)
 107 {
 108   return (f & XER_CANONICAL) != 0;
 109 }
 110
 111 inline bool is_exer(unsigned int f)
 112 {
 113   return (f & XER_EXTENDED) != 0;
 114 }
 115
 116 /** Is this a member of a SEQUENCE OF
 117  *
 118  * @param f XER flavor
 119  * @return \c true if \p contains \c XER_RECOF, \c false otherwise
 120  */
 121 inline bool is_record_of(unsigned int f)
 122 {
 123   return (f & XER_RECOF) != 0;
 124 }
 125
 126 /** Do list encoding
 127  *
 128  * This is now hijacked to mean "the enclosing type told us to omit our tag".
 129  * Hence the check for USE-NIL too.
 130  *
 131  * @param f XER flavor
 132  * @return \c true if \c XER_EXTENDED and either \c XER_LIST or \c USE_NIL is set.
 133  */
 134 inline bool is_exerlist(unsigned int f)
 135 {
 136   return (f & XER_EXTENDED) && ((f & (XER_LIST|USE_NIL|USE_TYPE_ATTR)) != 0);
 137 }
 138
 139 /** Descriptor for XER encoding/decoding during runtime.
 140  *
 141  * This structure contains XER enc/dec information for the runtime.
 142  *
 143  * There is an instance of this struct for most TTCN3/ASN1 types.
 144  * Because TITAN generates type aliases (typedefs) when one type references
 145  * another (e.g. "type integer i1" results in "typedef INTEGER i1"),
 146  * this struct holds information to distinguish them during encoding.
 147  *
 148  * Only those encoding instructions need to be recorded which can apply to
 149  * scalar types (e.g. BOOLEAN, REAL, etc., usually implemented by classes in core/)
 150  * because the same code needs to handle all varieties.
 151  *
 152  *  - ANY-ELEMENT : UFT8String
 153  *  - BASE64      : OCTET STRING, open type, restricted character string
 154  *  - DECIMAL     : REAL
 155  *  - NAME        : anything (this is already present as \c name)
 156  *  - NAMESPACE   : hmm
 157  *  - TEXT        : INTEGER, enum
 158  *  - USE-NUMBER  : enum
 159  *  - WHITESPACE  : restricted character string
 160  *
 161  * ANY-ATTRIBUTE, EMBED-VALUES, LIST, USE-TYPE, USE-UNION apply to sequence/choice types;
 162  * their effect will be resolved by the compiler.
 163  *
 164  * Instances of this type are written by the compiler into the generated code,
 165  * one for each type. For a TTCN3 type foo_bar, there will be a class
 166  * foo__bar and a XERdescriptor_t instance named foo__bar_xer_.
 167  *
 168  * Each built-in type has a descriptor (e.g. INTEGER_xer_) in the runtime.
 169  *
 170  * The \a name field contains the closing tag including a newline, e.g.
 171  * \c "</INTEGER>\n". This allows for a more efficient output of the tags,
 172  * minimizing the number of one-character inserts into the buffer.
 173  *
 174  * The start tag is written as an 'open angle bracket' character,
 175  * followed by the \a name field without its first two characters (\c "</" ).
 176  *
 177  * In case of the canonical encoding (\c CXER ) there is no indenting,
 178  * so the final newline is omitted by reducing the length by one.
 179  *
 180  * Example:
 181  * @code
 182  * int Foo::XER_encode(const XERdescriptor_t& p_td,
 183  *                     TTCN_Buffer& p_buf, unsigned int flavor, int indent, embed_values_enc_struct_t*) const {
 184  *   int canon = is_canonical(flavor);
 185  *   if (!canon) do_indent(p_buf, indent);
 186  *   // output the start tag
 187  *   p_buf.put_c('<');
 188  *   p_buf.put_s((size_t)p_td.namelen-2-canon, (const unsigned char*)p_td.name+2);
 189  *   // this is not right if Foo has attributes :(
 190  *   // we'll need to reduce namelen further (or just get rid of this hackery altogether)
 191  *
 192  *   // output actual content
 193  *   p_buf.put_.....
 194  *
 195  *   // output the closing tag
 196  *   if (!canon) do_indent(p_buf, indent);
 197  *   p_buf.put_s((size_t)p_td.namelen-canon, (const unsigned char*)p_td.name);
 198  * }
 199  * @endcode
 200  *
 201  * Empty element tag:
 202  *
 203  * @code
 204  * int Foo::XER_encode(const XERdescriptor_t& p_td,
 205  *                     TTCN_Buffer& p_buf, unsigned int flavor, int indent, embed_values_enc_struct_t*) const {
 206  *   int canon = is_canonical(flavor);
 207  *   if (!canon) do_indent(p_buf, indent);
 208  *   // output an empty element tag
 209  *   p_buf.put_c('<');
 210  *   p_buf.put_s((size_t)p_td.namelen-4, (const unsigned char*)p_td.name+2);
 211  *   p_buf.put_s(3 - canon, (const unsigned char*)"/>\n");
 212  * }
 213  * @endcode
 214  *
 215  * @note We don't generate the XML prolog. This is required for Canonical XER
 216  * (X.693 9.1.1) and permitted for Basic-XER (8.2.1).
 217  *
 218  * @note X.693 amd1 (EXER) 10.3.5 states: If an "ExtendedXMLValue" is empty,
 219  * and its associated tags have not been removed by the use of an UNTAGGED
 220  * encoding instruction, then the associated preceding and following tags
 221  * <b>can (as an encoder's option)</b> be replaced with
 222  * an XML empty-element tag (see ITU-T Rec. X.680 | ISO/IEC 8824-1, 16.8).
 223  * This is called the associated empty-element tag.
 224  *
 225  * @note X.693 (XER) 9.1.4 states: (for Canonical XER)
 226  * If the XML value notation permits the use of an XML empty-element tag
 227  * (see ITU-T Rec. X.680 |ISO/IEC 8824-1, 15.5 and 16.8),
 228  * then this empty-element tag @b shall be used.
 229  *
 230  * @note After editing XERdescriptor_t, make sure to change XER_STRUCT2 here
 231  * and generate_code_xerdescriptor() in Type.cc.
 232  * */
 233 struct XERdescriptor_t
 234 {
 235   /** (closing) Tag name, including a newline.
 236    * First is for basic and canonical XER, second for EXER */
 237   const          char *names[2];
 238   /** Length of closing tag string (strlen of names[i]) */
 239   const unsigned short namelens[2];
 240   /** Various EXER flags */
 241   const unsigned long xer_bits;
 242   /** Whitespace handling */
 243   const XER_whitespace_action whitespace;
 244   /** value to compare for DEFAULT-FOR-EMPTY */
 245   const Base_Type* dfeValue;
 246   /** The module to which the type belongs. May be NULL in a descriptor
 247    * for a built-in type, e.g. in INTEGER_xer_ */
 248   const TTCN_Module* my_module;
 249   /** Index into the module's namespace list.
 250    * -1 means no namespace.
 251    * >=+0 and FORM_UNQUALIFIED means that there IS a namespace,
 252    * it just doesn't show up in the XML (but libxml2 will return it). */
 253   const int ns_index;
 254
 255   /** Number of namespace URIs*/
 256   const unsigned short nof_ns_uris;
 257
 258   /** List of namespace URIs
 259     * In case of "anyElement" variants this list contains the valid ("anyElement from ...")
 260     * or invalid ("anyElement except ...") namespace URIs.
 261     * The unqualified namespace is marked by an empty string ("").*/
 262   const char** ns_uris;
 263
 264   /** Points to the element type's XER descriptor in case of 'record of' and 'set of' types */
 265   const XERdescriptor_t* oftype_descr;
 266 };
 267
 268 /** Information related to the embedded values in XML encoding
 269   *
 270   * Used when a record/set with the EMBED-VALUES coding instruction contains
 271   * one or more record of/set of fields. */
 272 struct embed_values_enc_struct_t
 273 {
 274 #ifdef TITAN_RUNTIME_2
 275   /** Stores the array of embedded values */
 276   const Record_Of_Type* embval_array;
 277   /** Stores the erroneous descriptor of the embedded values field (for negative tests) */
 278   const Erroneous_descriptor_t* embval_err;
 279   /** Error value index for the embedded values (for negative tests) */
 280   int embval_err_val_idx;
 281   /** Erroneous descriptor index for the embedded values (for negative tests) */
 282   int embval_err_descr_idx;
 283 #else
 284   /** Stores the array of embedded values (regular record-of) */
 285   const PreGenRecordOf::PREGEN__RECORD__OF__UNIVERSAL__CHARSTRING* embval_array_reg;
 286   /** Stores the array of embedded values (optimized record-of) */
 287   const PreGenRecordOf::PREGEN__RECORD__OF__UNIVERSAL__CHARSTRING__OPTIMIZED* embval_array_opt;
 288 #endif
 289   /** Stores the index of the next embedded value to be read */
 290   int embval_index;
 291 };
 292
 293 /** Information related to the embedded values in XML decoding
 294   *
 295   * Used when a record/set with the EMBED-VALUES coding instruction contains
 296   * one or more record of/set of fields. */
 297 struct embed_values_dec_struct_t
 298 {
 299 #ifdef TITAN_RUNTIME_2
 300   /** Stores the array of embedded values */
 301   Record_Of_Type* embval_array;
 302 #else
 303   /** Stores the array of embedded values (regular record-of) */
 304   PreGenRecordOf::PREGEN__RECORD__OF__UNIVERSAL__CHARSTRING* embval_array_reg;
 305   /** Stores the array of embedded values (optimized record-of) */
 306   PreGenRecordOf::PREGEN__RECORD__OF__UNIVERSAL__CHARSTRING__OPTIMIZED* embval_array_opt;
 307 #endif
 308   /** Stores the number of embedded values that are currently in the array,
 309     * and the index where the next one should be inserted */
 310   int embval_index;
 311 };
 312
 313 /** Check the name of an XML node against a XER type descriptor.
 314  *
 315  * @param name the (local, unqualified) name of the XML element
 316  * @param p_td the type descriptor
 317  * @param exer \c true if Extended XER decoding, \c false for Basic and Canonical XER
 318  * @return \c true if \p name corresponds to the type descriptor, \c false otherwise.
 319  */
 320 inline bool check_name(const char *name, const XERdescriptor_t& p_td, int exer)
 321 {
 322   return strncmp(name, p_td.names[exer], p_td.namelens[exer]-2) == 0
 323     && name[p_td.namelens[exer]-2] == '\0';
 324 }
 325
 326 /** Verify the namespace of an XML node against a XER type descriptor.
 327  *
 328  * @pre EXER decoding is in progress
 329  *
 330  * @param ns_uri the URI of the current node
 331  * @param p_td the type descriptor
 332  * @return \c true if \p ns_uri is NULL and the type has no namespace
 333  * or it's the default namespace.
 334  * @return \c true if \p ns_uri is not NULL and it matches the one referenced
 335  * by \p p_td.
 336  * @return \c false otherwise.
 337  */
 338 bool check_namespace(const char *ns_uri, const XERdescriptor_t& p_td);
 339
 340 /** Check that the current element matches the XER descriptor
 341  *
 342  * Calls TTCN_EncDec_ErrorContext::error() if it doesn't.
 343  *
 344  * @param reader XML reader
 345  * @param p_td XER descriptor
 346  * @param exer 0 for Basic/Canonical XER, 1 for EXER
 347  * @return the name of the current element
 348  */
 349 const char* verify_name(XmlReaderWrap& reader, const XERdescriptor_t& p_td, int exer);
 350
 351 /** Check the end tag
 352  *
 353  * Calls verify_name(), then compares \a depth with the current XML depth
 354  * and calls TTCN_EncDec_ErrorContext::error() if they don't match.
 355  *
 356  * @param reader XML reader
 357  * @param p_td XER descriptor
 358  * @param depth XML tag depth (0 for top-level element)
 359  * @param exer 0 for Basic/Canonical XER, 1 for EXER
 360  */
 361 void verify_end(XmlReaderWrap& reader, const XERdescriptor_t& p_td, const int depth, int exer);
 362
 363 class TTCN_Buffer;
 364
 365 /** Output the namespace prefix
 366  *
 367  * The namespace prefix is determined by the XER descriptor (@a my_module
 368  * and @a ns_index fields). It is not written if p_td.xer_bits has
 369  * FORM_UNQUALIFIED.
 370  *
 371  * @param p_td  XER descriptor
 372  * @param p_buf buffer to write into
 373  *
 374  * @pre the caller should check that E-XER encoding is in effect.
 375  */
 376 void write_ns_prefix(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf);
 377
 378 /** Output the beginning of an XML attribute.
 379  *
 380  * Writes a space, the attribute name (from \p p_td), and the string "='".
 381  * @post the buffer is ready to receive the actual value
 382  *
 383  * @param p_td  XER descriptor (contains the attribute name)
 384  * @param p_buf buffer to write into
 385  */
 386 inline void begin_attribute(const XERdescriptor_t& p_td, TTCN_Buffer& p_buf)
 387 {
 388   p_buf.put_c(' ');
 389   write_ns_prefix(p_td, p_buf);
 390   p_buf.put_s((size_t)p_td.namelens[1]-2, (const unsigned char*)p_td.names[1]);
 391   p_buf.put_s((size_t)2, (const unsigned char*)"='");
 392 }
 393
 394 /** Indent.
 395  *
 396  * @param buf buffer to write into.
 397  * @param level indent level
 398  *
 399  * Writes the appropriate amount of indentation into \p buf.
 400  *
 401  * Indentation is currently done with with tabs.
 402  * */
 403 int do_indent(TTCN_Buffer& buf, int level);
 404
 405 /** Ensures that the anyElement or anyAttribute field respects its namespace
 406   * restrictions.
 407   * In case of "anyElement from ..." or "anyAttributes from ..." the namespace
 408   * needs to be in the specified list.
 409   * In case of "anyElement except ..." or "anyAttributes except ..." it cannot
 410   * match any of the namespaces from the list.
 411   * An invalid namespace causes a dynamic test case error.
 412   *
 413   * @param p_td type descriptor of the field in question, contains the list of
 414   * valid or invalid namespaces
 415   * @param p_xmlns constains the namespace in question
 416   */
 417 void check_namespace_restrictions(const XERdescriptor_t& p_td, const char* p_xmlns);
 418
 419
 420 #ifdef DEFINE_XER_STRUCT
 421 # define XER_STRUCT2(type_name,xmlname) \
 422   extern const XERdescriptor_t type_name##_xer_ = { \
 423     { xmlname ">\n", xmlname ">\n" }, \
 424     { 2+sizeof(xmlname)-1, 2+sizeof(xmlname)-1 }, \
 425     0UL, WHITESPACE_PRESERVE, NULL, NULL, 0, 0, NULL, NULL }
 426 // The compiler should fold the two identical strings into one
 427
 428 # define XER_STRUCT_COPY(cpy,original) \
 429   const XERdescriptor_t& cpy##_xer_ = original##_xer_
 430 #else
 431 /** Declare a XER structure.
 432  *  @param type_name the name of a Titan runtime class
 433  *  @param xmlname the XML tag name
 434  */
 435 # define XER_STRUCT2(type_name,xmlname) extern const XERdescriptor_t type_name##_xer_
 436 # define XER_STRUCT_COPY(cpy,original)  extern const XERdescriptor_t& cpy##_xer_
 437 #endif
 438
 439 /** Declare a XER structure where the name of the type matches the tag */
 440 #       define XER_STRUCT(name) XER_STRUCT2(name, #name)
 441
 442 /* XER descriptors for built-in types.
 443  * The XML tag names are defined in Table 4, referenced by clause
 444  * 11.25.2 (X.680/2002) or 12.36.2 (X.680/2008) */
 445
 446 // Types shared between ASN.1 and TTCN-3
 447 XER_STRUCT2(BITSTRING, "BIT_STRING");
 448 XER_STRUCT (BOOLEAN);
 449 XER_STRUCT (CHARSTRING);
 450 XER_STRUCT2(FLOAT, "REAL");
 451 XER_STRUCT (INTEGER);
 452 XER_STRUCT2(OBJID, "OBJECT_IDENTIFIER");
 453 XER_STRUCT2(OCTETSTRING, "OCTET_STRING");
 454 XER_STRUCT (UNIVERSAL_CHARSTRING);
 455
 456 XER_STRUCT(RELATIVE_OID);
 457
 458 // ASN.1 types
 459
 460 XER_STRUCT2(EMBEDDED_PDV, "SEQUENCE");
 461 XER_STRUCT2(EMBEDDED_PDV_identification, "identification");
 462 XER_STRUCT2(EMBEDDED_PDV_identification_sxs, "syntaxes");
 463 XER_STRUCT2(EMBEDDED_PDV_identification_sxs_abs, "abstract");
 464 XER_STRUCT2(EMBEDDED_PDV_identification_sxs_xfr, "transfer");
 465 XER_STRUCT2(EMBEDDED_PDV_identification_sx , "syntax");
 466 XER_STRUCT2(EMBEDDED_PDV_identification_pci, "presentation-context-id");
 467 XER_STRUCT2(EMBEDDED_PDV_identification_cn , "context-negotiation");
 468 XER_STRUCT2(EMBEDDED_PDV_identification_cn_pci , "presentation-context-id");
 469 XER_STRUCT2(EMBEDDED_PDV_identification_cn_tsx , "transfer-syntax");
 470 XER_STRUCT2(EMBEDDED_PDV_identification_ts , "transfer-syntax");
 471 XER_STRUCT2(EMBEDDED_PDV_identification_fix, "fixed");
 472 XER_STRUCT2(EMBEDDED_PDV_data_value_descriptor, "data-value-descriptor");
 473 XER_STRUCT2(EMBEDDED_PDV_data_value, "data-value");
 474
 475
 476 XER_STRUCT2(EXTERNAL, "SEQUENCE");
 477 XER_STRUCT2(EXTERNAL_direct_reference  , "direct-reference");
 478 XER_STRUCT2(EXTERNAL_indirect_reference, "indirect-reference");
 479 XER_STRUCT2(EXTERNAL_data_value_descriptor, "data-value-descriptor");
 480 XER_STRUCT2(EXTERNAL_encoding, "encoding");
 481 XER_STRUCT2(EXTERNAL_encoding_singleASN    , "single-ASN1-type");
 482 XER_STRUCT2(EXTERNAL_encoding_octet_aligned, "octet-aligned");
 483 XER_STRUCT2(EXTERNAL_encoding_arbitrary    , "arbitrary");
 484
 485 // The big, scary ASN.1 unrestricted character string
 486 XER_STRUCT2(CHARACTER_STRING, "SEQUENCE");
 487 XER_STRUCT_COPY(CHARACTER_STRING_identification,         EMBEDDED_PDV_identification);
 488 XER_STRUCT_COPY(CHARACTER_STRING_identification_sxs,     EMBEDDED_PDV_identification_sxs);
 489 XER_STRUCT_COPY(CHARACTER_STRING_identification_sxs_abs, EMBEDDED_PDV_identification_sxs_abs);
 490 XER_STRUCT_COPY(CHARACTER_STRING_identification_sxs_xfr, EMBEDDED_PDV_identification_sxs_xfr);
 491 XER_STRUCT_COPY(CHARACTER_STRING_identification_sx ,     EMBEDDED_PDV_identification_sx);
 492 XER_STRUCT_COPY(CHARACTER_STRING_identification_pci,     EMBEDDED_PDV_identification_pci);
 493 XER_STRUCT_COPY(CHARACTER_STRING_identification_cn ,     EMBEDDED_PDV_identification_cn);
 494 XER_STRUCT_COPY(CHARACTER_STRING_identification_cn_pci , EMBEDDED_PDV_identification_cn_pci);
 495 XER_STRUCT_COPY(CHARACTER_STRING_identification_cn_tsx , EMBEDDED_PDV_identification_cn_tsx);
 496 XER_STRUCT_COPY(CHARACTER_STRING_identification_ts ,     EMBEDDED_PDV_identification_ts);
 497 XER_STRUCT_COPY(CHARACTER_STRING_identification_fix,     EMBEDDED_PDV_identification_fix);
 498 // this one is used for decoding only (only to check that it's absent)
 499 XER_STRUCT2(CHARACTER_STRING_data_value_descriptor, "data-value-descriptor");
 500 // this can not be folded with EMBEDDED-PDV
 501 XER_STRUCT2(CHARACTER_STRING_data_value, "string-value");
 502
 503 // ASN.1 restricted character strings
 504 XER_STRUCT(GeneralString);
 505 XER_STRUCT(NumericString);
 506 XER_STRUCT(UTF8String);
 507 XER_STRUCT(PrintableString);
 508 XER_STRUCT(UniversalString);
 509
 510 XER_STRUCT(BMPString);
 511 XER_STRUCT(GraphicString);
 512 XER_STRUCT(IA5String);
 513 XER_STRUCT(TeletexString);
 514 XER_STRUCT(VideotexString);
 515 XER_STRUCT(VisibleString);
 516
 517 XER_STRUCT2(ASN_NULL, "NULL");
 518 XER_STRUCT2(ASN_ROID, "RELATIVE_OID");
 519 XER_STRUCT (ASN_ANY); // obsoleted by 2002
 520
 521 // TTCN-3 types
 522 XER_STRUCT2(HEXSTRING, "hexstring");
 523 XER_STRUCT2(VERDICTTYPE, "verdicttype");
 524
 525 /** @} */
 526
 527 #endif /*XER_HH_*/