Type.hh 66.3 KB
Newer Older
Elemer Lelik's avatar
Elemer Lelik committed
1
/******************************************************************************
Adam Knapp's avatar
Adam Knapp committed
2
 * Copyright (c) 2000-2021 Ericsson Telecom AB
Elemer Lelik's avatar
Elemer Lelik committed
3
 * All rights reserved. This program and the accompanying materials
4
 * are made available under the terms of the Eclipse Public License v2.0
Elemer Lelik's avatar
Elemer Lelik committed
5
 * which accompanies this distribution, and is available at
6
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
Elemer Lelik's avatar
Elemer Lelik committed
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 *
 * Contributors:
 *   Baji, Laszlo
 *   Balasko, Jeno
 *   Baranyi, Botond
 *   Beres, Szabolcs
 *   Bibo, Zoltan
 *   Cserveni, Akos
 *   Delic, Adam
 *   Forstner, Matyas
 *   Gecse, Roland
 *   Kovacs, Ferenc
 *   Raduly, Csaba
 *   Szabados, Kristof
21
 *   Szabo, Bence Janos
Elemer Lelik's avatar
Elemer Lelik committed
22
23
24
25
26
27
 *   Szabo, Janos Zoltan – initial implementation
 *   Szalai, Gabor
 *   Tatarka, Gabor
 *   Zalanyi, Balazs Andor
 *
 ******************************************************************************/
28

Elemer Lelik's avatar
Elemer Lelik committed
29
30
31
32
33
34
35
36
37
38
#ifndef _Common_Type_HH
#define _Common_Type_HH

#include "Setting.hh"
#include "Code.hh"
#include "Int.hh"
#include "subtype.hh"
#include "ttcn3/rawASTspec.h"
#include "ttcn3/TextAST.hh"
#include "ttcn3/BerAST.hh"
39
#include "ttcn3/OerAST.hh"
Elemer Lelik's avatar
Elemer Lelik committed
40
41
42
#include <float.h>

class XerAttributes;
43
class RawAST;
44
class JsonAST;
45
46
enum namedbool { INCOMPLETE_NOT_ALLOWED = 0, INCOMPLETE_ALLOWED = 1, WARNING_FOR_INCOMPLETE = 2,
  NO_SUB_CHK = 0, SUB_CHK = 3,
47
48
  OMIT_NOT_ALLOWED = 0, OMIT_ALLOWED = 4,
  ANY_OR_OMIT_NOT_ALLOWED = 0, ANY_OR_OMIT_ALLOWED = 5,
49
  NOT_IMPLICIT_OMIT = 0, IMPLICIT_OMIT = 6,
50
  NOT_STR_ELEM = 0, IS_STR_ELEM = 7,
51
  ISBOUND = 8, ISPRESENT = 9, ISCHOSEN = 10, ISVALUE = 11
Elemer Lelik's avatar
Elemer Lelik committed
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
};

namespace Asn {
  // not defined here
  class Tags;
  class Tag;
  class TagCollection;
  class Block;
  class OC_defn;
  class TableConstraint;
} // namespace Asn

namespace Ttcn {
  // not defined here
  class ArrayDimension;
  class FieldOrArrayRefs;
  class Template;
  class Definitions;
  class Definition;
  class SingleWithAttrib;
  class MultiWithAttrib;
  class WithAttribPath;
  class FormalPar;
  class FormalParList;
  class Reference;
  class PortTypeBody;
  class Def_Type;
79
  class ClassTypeBody;
80
81
82
83
84
85
86
  
  /** Stores the modifier of an attribute */
  enum attribute_modifier_t {
    MOD_NONE, ///< no modifier
    MOD_OVERRIDE, ///< 'override' modifier
    MOD_LOCAL ///< '@local' modifier
  };
Elemer Lelik's avatar
Elemer Lelik committed
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
} // namespace Ttcn

// not defined here
class JSON_Tokenizer;

namespace Common {

  /**
   * \ingroup AST
   *
   * \defgroup AST_Type Type
   * @{
   */
  using Asn::Tag;
  using Asn::Tags;
  using Asn::TagCollection;
  using Asn::Block;
  using Asn::OC_defn;
  using Asn::TableConstraint;
  using Ttcn::Template;

  class Type;

  // not defined here
  class Identifier;
  class Constraints;
  class Value;
  class CompField;
  class CompFieldMap;
  class EnumItem;
  class EnumItems;
  class ExcSpec;
  class NamedValues;
  class CTs_EE_CTs;
  class TypeSet;
  class TypeChain;
  class TypeCompatInfo;
  class ComponentTypeBody;
  class SignatureParam;
  class SignatureParamList;
  class SignatureExceptions;
  class CodeGenHelper;
129
  class Assignment;
Elemer Lelik's avatar
Elemer Lelik committed
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

  /**
   * This is the base class for types.
   */
  class Type : public Governor {
  public:

    /** type of type */
    enum typetype_t {
      /** Undefined.
       *  There is never a Type object with this typetype.
       *  It may be returned by Value::get_expr_returntype() or
       *  ValueRange::get_expr_returntype().        */
      T_UNDEF,
      T_ERROR, /**< erroneous (e.g. nonexistent reference) */
      T_NULL, /**< null (ASN.1) */
      T_BOOL, /**< boolean */
      T_INT, /**< integer */
      T_INT_A, /**< integer / ASN */
      T_REAL, /**< real/float */
      T_ENUM_A, /**< enumerated / ASN */
      T_ENUM_T, /**< enumerated / TTCN */
      T_BSTR, /**< bitstring */
      T_BSTR_A, /**< bitstring */
      T_HSTR, /**< hexstring (TTCN-3) */
      T_OSTR, /**< octetstring */
      T_CSTR, /**< charstring (TTCN-3) */
      T_USTR, /**< universal charstring (TTCN-3) */
      T_UTF8STRING, /**< UTF8String (ASN.1) */
      T_NUMERICSTRING, /**< NumericString (ASN.1) */
      T_PRINTABLESTRING, /**< PrintableString (ASN.1) */
      T_TELETEXSTRING, /**< TeletexString (ASN.1) */
      T_VIDEOTEXSTRING, /**< VideotexString (ASN.1) */
      T_IA5STRING, /**< IA5String (ASN.1) */
      T_GRAPHICSTRING, /**< GraphicString (ASN.1) */
      T_VISIBLESTRING, /**< VisibleString (ASN.1) */
      T_GENERALSTRING, /**< GeneralString (ASN.1) */
      T_UNIVERSALSTRING,  /**< UniversalString (ASN.1) */
      T_BMPSTRING, /**< BMPString (ASN.1) */
      T_UNRESTRICTEDSTRING, /**< UnrestrictedCharacterString (ASN.1) */
      T_UTCTIME, /**< UTCTime (ASN.1) */
      T_GENERALIZEDTIME, /**< GeneralizedTime (ASN.1) */
      T_OBJECTDESCRIPTOR, /** Object descriptor, a kind of string (ASN.1) */
      T_OID, /**< object identifier */
      T_ROID, /**< relative OID (ASN.1) */
      T_CHOICE_A, /**< choice /ASN, uses u.secho */
      T_CHOICE_T, /**< union /TTCN, uses u.secho */
      T_SEQOF, /**< sequence (record) of */
      T_SETOF, /**< set of */
      T_SEQ_A, /**< sequence /ASN, uses u.secho */
      T_SEQ_T, /**< record /TTCN, uses u.secho */
      T_SET_A, /**< set /ASN, uses u.secho */
      T_SET_T, /**< set /TTCN, uses u.secho */
      T_OCFT, /**< ObjectClassFieldType (ASN.1) */
      T_OPENTYPE, /**< open type (ASN.1) */
      T_ANY, /**< ANY (deprecated ASN.1) */
      T_EXTERNAL, /**< %EXTERNAL (ASN.1) */
      T_EMBEDDED_PDV, /**< EMBEDDED PDV (ASN.1) */
      T_REFD, /**< referenced */
      T_REFDSPEC, /**< special referenced (by pointer, not by name) */
      T_SELTYPE, /**< selection type (ASN.1) */
      T_VERDICT, /**< verdict type (TTCN-3) */
      T_PORT, /**< port type (TTCN-3) */
      T_COMPONENT, /**< component type (TTCN-3) */
      T_ADDRESS, /**< address type (TTCN-3) */
      T_DEFAULT, /**< default type (TTCN-3) */
      T_ARRAY, /**< array (TTCN-3), uses u.array */
      T_SIGNATURE, /**< signature (TTCN-3) */
      T_FUNCTION, /**< function reference (TTCN-3) */
      T_ALTSTEP, /**< altstep reference (TTCN-3) */
      T_TESTCASE, /**< testcase reference (TTCN-3) */
      T_ANYTYPE, /**< anytype (TTCN-3) */
202
      T_CLASS, /**< class (TTCN-3) */
Elemer Lelik's avatar
Elemer Lelik committed
203
204
205
206
207
208
209
210
211
      // WRITE new type before this line
      T_LAST
    };       //DO NOT FORGET to update type_as_string[] in Type.cc 

    /**
     * Enumeration to represent message encoding types.
     */
    enum MessageEncodingType_t {
      CT_UNDEF, /**< undefined/unused */
212
213
      CT_BER,   /**< ASN.1 BER (built-in) */
      CT_PER,   /**< ASN.1 PER (through user defined coder functions) */
214
      CT_OER,   /**< ASN.1 OER (built-in) */
215
216
217
218
219
      CT_RAW,   /**< TTCN-3 RAW (built-in) */
      CT_TEXT,  /**< TTCN-3 TEXT (built-in) */
      CT_XER,    /**< TTCN-3 XER (built-in) */
      CT_JSON,   /**< TTCN-3 and ASN.1 JSON (built-in) */
      CT_CUSTOM  /**< user defined encoding (through user defined coder functions) */
Elemer Lelik's avatar
Elemer Lelik committed
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
    };

    /** selector for value checking algorithms */
    enum expected_value_t {
      /** the value must be known at compile time (i.e. it may refer
       *  to a TTCN-3 constant or an ASN.1 value) */
      EXPECTED_CONSTANT,
      /** the value must be static at execution time, but may be
       *  unknown at compilation time (i.e. it may refer to a TTCN-3
       *  module parameter as well) */
      EXPECTED_STATIC_VALUE,
      /** the value is known only at execution time (i.e. it may refer
       *  to a variable in addition to static values) */
      EXPECTED_DYNAMIC_VALUE,
      /** the reference may point to a dynamic value or a template
       *  (this selector is also used in template bodies where the
       *  variable references are unaccessible because of the scope
       *  hierarchy) */
      EXPECTED_TEMPLATE
    };

    /** Enumeration to represent the owner of the type.
242
      */
Elemer Lelik's avatar
Elemer Lelik committed
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
    enum TypeOwner_t {
      OT_UNKNOWN,
      OT_TYPE_ASS, ///< ASN.1 type assignment (Ass_T)
      OT_VAR_ASS,  ///< ASN.1 variable assignment (Ass_V)
      OT_VSET_ASS, ///< ASN.1 value set assignment (Ass_VS)
      OT_TYPE_FLD, ///< ASN.1 TypeFieldSpec (FieldSpec_T)
      OT_FT_V_FLD, ///< ASN.1 FixedTypeValueFieldSpec (FieldSpec_V_FT)
      OT_TYPE_MAP, ///< TTCN-3 TypeMapping
      OT_TYPE_MAP_TARGET, ///< TTCN-3 TypeMappingTarget
      OT_TYPE_DEF, ///< TTCN-3 type definition (Def_Type)
      OT_CONST_DEF, ///< TTCN-3 constant definition (DefConst, Def_ExtCOnst)
      OT_MODPAR_DEF, ///< TTCN-3 module parameter definition (Def_Modulepar)
      OT_VAR_DEF, ///< TTCN-3 variable definition (Def_Var)
      OT_VARTMPL_DEF, ///< TTCN-3 var template definition (Def_Var_Template)
      OT_FUNCTION_DEF, ///< TTCN-3 function (Def_Function, Def_ExtFunction)
      OT_TEMPLATE_DEF, ///< TTCN-3 template definition (Def_Template)
      OT_ARRAY, ///< another Type: TTCN-3 array(T_ARRAY)
      OT_RECORD_OF, ///< another Type (T_SEQOF, T_SETOF), ASN.1 or TTCN-3
      OT_FUNCTION, ///< another Type: TTCN-3 function (T_FUNCTION)
      OT_SIGNATURE, ///< another Type: TTCN-3 signature (T_SIGNATURE)
      OT_REF, ///< another Type (T_REFD)
      OT_REF_SPEC, ///< another Type (T_REFDSPEC)
      OT_COMP_FIELD, ///< a field of a record/set/union (CompField)
      OT_COMPS_OF, ///< ASN.1 "COMPONENTS OF" (CT_CompsOf)
      OT_FORMAL_PAR, ///< formal parameter (FormalPar), TTCN-3
      OT_TYPE_LIST, ///< TypeList for a 'with "extension anytype t1,t2..." '
      OT_FIELDSETTING, ///< ASN.1 FieldSetting_Type
      OT_SELTYPE, ///< another Type (T_SELTYPE), ASN.1 selection type
      OT_OCFT, ///< another Type (T_OCFT), ASN.1 obj.class field type
      OT_TEMPLATE_INST, ///< a TemplateInstance (TTCN-3)
      OT_RUNSON_SCOPE, ///< a RunsOnScope (TTCN-3)
274
      OT_PORT_SCOPE, ///< a port scope
Elemer Lelik's avatar
Elemer Lelik committed
275
276
277
278
      OT_EXC_SPEC, ///< exception Specification (ExcSpec)
      OT_SIG_PAR, ///< signature parameter (SignatureParam)
      OT_POOL ///< It's a pool type, owned by the type pool
    };
279
280
281
282
283
284
285
286
287
288
289
290
    
    /**
     * Enumeration to represent the default method of encoding or decoding for a type.
     */
    enum coding_type_t {
      CODING_UNSET, ///< No encoding/decoding method has been set for the type.
      CODING_BUILT_IN, ///< The type uses a built-in codec for encoding/decoding.
      CODING_BY_FUNCTION, ///< The type uses a user defined function for encoding/decoding.
      CODING_MULTIPLE ///< Multiple encoding/decoding methods have been set for the type.
    };
    
    /**
291
292
     * Structure containing the default encoding or decoding settings for a type
     * when using legacy codec handling.
293
294
295
296
297
     * These settings determine how values of the type are encoded or decoded by
     * the following TTCN-3 language elements:
     * 'encvalue' (encode), 'encvalue_unichar' (encode), 'decvalue' (decode),
     * 'decvalue_unichar' (decode), 'decmatch' (decode) and '@decoded' (decode).
     */
298
    struct legacy_coding_t {
299
300
301
302
303
304
      coding_type_t type; ///< Type of encoding/decoding
      union {
        MessageEncodingType_t built_in_coding; ///< Built-in codec (if type is CODING_BUILT_IN)
        Assignment* function_def; ///< Pointer to external function definition (if type is CODING_BY_FUNCTION)
      };
    };
305
    
306
307
308
309
310
311
    /** Stores information about the custom encoder or decoder function of a type */
    struct coder_function_t {
      Assignment* func_def; ///< definition of the encoder or decoder function
      boolean conflict; ///< indicates whether there are multiple encoder/decoder functions for this type and codec
    };
    
312
313
314
315
    /** Stores information related to an encoding type (codec), when using new
      * codec handling. */
    struct coding_t {
      boolean built_in; ///< built-in or user defined codec
316
      Ttcn::attribute_modifier_t modifier; ///< the 'encode' attribute's modifier
317
318
319
320
      union {
        MessageEncodingType_t built_in_coding; ///< built-in codec
        struct {
          char* name; ///< name of the user defined codec (the string in the 'encode' attribute)
321
322
323
          // note: other types that use this type's coding table may have their own encoder/decoder functions
          map<Type*, coder_function_t>* encoders; ///< the map of encoder functions per type
          map<Type*, coder_function_t>* decoders; ///< the map of decoder functions per type
324
325
326
        } custom_coding;
      };
    };
Elemer Lelik's avatar
Elemer Lelik committed
327
328
329
330
331

    /** Returns the display string of \a encoding_type. */
    static const char *get_encoding_name(MessageEncodingType_t encoding_type);
    /** Returns a pool type that represents the encoded stream of the given
     * \a encoding_type. */
Elemer Lelik's avatar
Elemer Lelik committed
332
    static Type *get_stream_type(MessageEncodingType_t encoding_type, int stream_variant=0);
Elemer Lelik's avatar
Elemer Lelik committed
333
334
335
336
337
338
339
340
341
342
343
344
345
346

    enum truth {
      No, Maybe, Yes
    };

  private:
    typetype_t typetype;
    bool tags_checked;
    bool tbl_cons_checked;
    bool text_checked;
    bool json_checked;
    bool raw_parsed;
    bool raw_checked;
    bool xer_checked;
347
    bool variants_checked;
348
349
    bool coding_attribs_checked;
    static dynamic_array<Type*> coding_attrib_check_stack;
Elemer Lelik's avatar
Elemer Lelik committed
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
    bool raw_length_calculated;
    bool has_opentypes;
    bool opentype_outermost;
    bool code_generated;
    bool embed_values_possible;
    bool use_nil_possible;
    bool use_order_possible;
    int raw_length;
    Type *parent_type;
    Tags *tags;
    Constraints *constraints;
    /// The type's attributes (with context)
    Ttcn::WithAttribPath* w_attrib_path;
    /** A copy of all the AT_ENCODEs  */
    Ttcn::WithAttribPath* encode_attrib_path;
    RawAST *rawattrib;
    TextAST *textattrib;
    XerAttributes *xerattrib;
    BerAST *berattrib;
    JsonAST *jsonattrib;
370
    OerAST *oerattrib;
Elemer Lelik's avatar
Elemer Lelik committed
371
372
373
374

    vector<SubTypeParse> *parsed_restr; ///< parsed subtype restrictions are stored here until they are moved to the sub_type member
    SubType *sub_type; ///< effective/aggregate subtype of this type, NULL if neither inherited nor own subtype restrictions exist

375
376
377
378
379
380
    legacy_coding_t default_encoding; ///< default settings for encoding values of this type (when using legacy codec handling)
    legacy_coding_t default_decoding; ///< default settings for decoding values of this type (when using legacy codec handling)
    
    /** Stores the list of encodings this type supports (when using new codec
     * handling). */
    vector<coding_t> coding_table;
381
    
Elemer Lelik's avatar
Elemer Lelik committed
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
    /** What kind of AST element owns the type.
     *  It may not be known at creation type, so it's initially OT_UNKNOWN.
     *  We want this information so we don't have to bother with XER
     *  if the type is an ASN.1 construct, or it's the type in a "runs on" scope,
     *  the type of a variable declaration/module par/const, etc. */
    TypeOwner_t ownertype;
    Node *owner;

    union {
      struct {
        Block *block;
        NamedValues *nvs;
      } namednums;
      struct {
        EnumItems *eis; ///< Final set of enum items
        Int first_unused;  ///< First  unused >=0 value (for UNKNOWN_VALUE)
        Int second_unused; ///< Second unused >=0 value (for UNBOUND_VALUE)
        Block *block; ///< ASN.1 block to be parsed
        EnumItems *eis1; ///< First set of enum items before the ellipsis
        bool ellipsis; ///< true if there was an ellipsis, false otherwise
        ExcSpec *excSpec; ///< Exception specification
        EnumItems *eis2; ///< Second set of enum items after the ellipsis
        map<string, size_t> *eis_by_name;
      } enums;
      struct {
        CompFieldMap *cfm;
        Block *block; ///< Unparsed block; will be 0 after parse_block_...()
        CTs_EE_CTs *ctss;
        bool tr_compsof_ready;
        bool component_internal;
        map<string, size_t> *field_by_name;
        OC_defn *oc_defn; /**< link to...  */
        const Identifier *oc_fieldname; /**< link to...  */
        const TableConstraint *my_tableconstraint; /**< link to...  */
        bool has_single_charenc; /**< Has a single character-encodable field
                                  * with the UNTAGGED encoding instruction.
                                  * X693amd1 32.2.2 applies to the field. */
      } secho; /**< data for T_(SEQUENCE|SET_CHOICE)_[AT] */
      struct {
        Type *ofType;
        bool component_internal;
      } seof; /**< data for SEQUENCE OF/SET OF */
      struct {
        Reference *ref;
        Type *type_refd; /**< link to...  */
        OC_defn *oc_defn; /**< link to...  */
        const Identifier *oc_fieldname; /**< link to...  */
        bool component_internal;
      } ref;
      struct {
        Identifier *id;
        Type *type;
        Type *type_refd;
      } seltype;
      struct {
        Type *element_type;
	Ttcn::ArrayDimension *dimension;
	bool in_typedef;
        bool component_internal;
      } array;
      Ttcn::PortTypeBody *port;
      ComponentTypeBody *component;
      Type *address; /**< link to...  */
      struct {
	SignatureParamList *parameters;
	Type *return_type;
	bool no_block;
        bool component_internal;
	SignatureExceptions *exceptions;
      } signature;
      struct {
        Ttcn::FormalParList *fp_list;
	struct {
          bool self;
          Ttcn::Reference *ref;
          Type *type; // useful only after check
	} runs_on;
        union {
          Type *return_type;
          struct {
            Ttcn::Reference *ref;
            Type *type; // useful only after check
          } system;
        };
        bool returns_template;
        template_restriction_t template_restriction;
        bool is_startable;
      } fatref;
470
      Ttcn::ClassTypeBody* class_;
Elemer Lelik's avatar
Elemer Lelik committed
471
472
473
474
475
476
    } u;
    static const char* type_as_string[];
    
    /** True if chk() has finished running. 
      * Prevents force_raw() from running chk_raw(), chk_text() or chk_json() on unchecked types. */
    bool chk_finished;
Elemer Lelik's avatar
Elemer Lelik committed
477
478
479
480
481
    
    /** Signifies that this type is an instance of an ASN.1 parameterized type.
      * It will not have its own segment and reference generated in the JSON schema,
      * its schema segment will be generated as an embedded type's would. */
    bool pard_type_instance;
482
483
484
485
486
    
    /** Indicates that the component array version (used with the help of the
      * 'any from' clause) of the 'done' function needs to be generated for
      * this type. */
    bool needs_any_from_done;
487
    
488
489
490
    /** True if we already checked this type for default or port field*/
    bool checked_incorrect_field;
    
491
492
493
494
495
496
    /** Contains a list of the built-in coder functions that need to be
      * generated for this type.
      * When using legacy codec handling, only the JSON coders are set with this
      * method. */
    vector<MessageEncodingType_t> coders_to_generate;
    
497
498
499
500
501
502
503
    /** Indicates whether an 'encode' attribute modifier conflict error has
      * already been displayed for the type. */
    bool encode_attrib_mod_conflict;
    
    /** Helper class that tracks the execution of recursive functions in the 
      * Type class in order to prevent infinite recursions. */
    class RecursionTracker {
504
      static map<Type*, void> types;
505
      Type* key;
506
    public:
507
508
      RecursionTracker(Type* t): key(t) { types.add(t, NULL); }
      ~RecursionTracker() { types.erase(key); }
509
510
      static bool is_happening(Type* t) { return types.has_key(t); }
    };
Elemer Lelik's avatar
Elemer Lelik committed
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534

    /** Copy constructor, for the use of Type::clone() only. */
    Type(const Type& p);
    /** Assignment disabled */
    Type& operator=(const Type& p);
    /** Set fields to their default values */
    void init();
    /** Free up resources */
    void clean_up();
    /** Returns the default tag of the type. */
    Tag *get_default_tag();
    /** Returns the number in UNIVERSAL tag class that belongs to ASN.1 type
     * type \a p_tt. In case of invalid argument -1 is returned */
    static int get_default_tagnumber(typetype_t p_tt);
    /** Container for the allocated tags that do not belong to a particular
     * Type object */
    static map<typetype_t, Tag> *default_tags;
    static void destroy_default_tags();
    /** Container for the allocated pool types */
    static map<typetype_t, Type> *pooltypes;
    /** Drops the elements of \a pooltypes */
    static void destroy_pooltypes();
    /** Returns the TTCN-3 equivalent of \a p_tt. */
    static typetype_t get_typetype_ttcn3(typetype_t p_tt);
535
536
537
538
539
540
541
    
    /** Fills the list parameter with the types that have an empty coding table.
      * The types considered are the type itself and its field and element types.
      * Recursive.
      * @param only_own_table if true, then only the type's own coding table is
      * checked, otherwise inherited coding tables are also checked */
    void get_types_w_no_coding_table(vector<Type>& type_list, bool only_own_table);
Elemer Lelik's avatar
Elemer Lelik committed
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591

  public:
    /** @name Constructors
     *  @{ */
    /// Construct a predefined type (including anytype and address)
    Type(typetype_t p_tt);
    /// Construct a TTCN enumerated type
    Type(typetype_t p_tt, EnumItems *p_eis);
    /** Construct an ASN.1 enum, sequence, set, choice, integer with
     * named numbers, or a bitstring with named bits */
    Type(typetype_t p_tt, Block *p_block);
    /// Construct an ASN.1 enum, with or without extension
    Type(typetype_t p_tt,
         EnumItems *p_eis1, bool p_ellipsis, EnumItems *p_eis2);
    /// Construct a TTCN3 sequence, set or choice
    Type(typetype_t p_tt, CompFieldMap *p_cfm);
    /** Construct a type with an embedded type: a record-of, set-of,
    * or a special reference (involved in: ASN.1 table constraint,
    * TTCN3 (ext)const definition, module parameter, variable instance) */
    Type(typetype_t p_tt, Type *p_type);
    /// Create an ASN.1 selection type
    Type(typetype_t p_tt, Identifier *p_id, Type *p_type);
    /// ASN.1 ObjectClassFieldType
    Type(typetype_t p_tt, Type *p_type, OC_defn *p_oc_defn,
         const Identifier *p_id);
    /// Create a TTCN3 array
    Type(typetype_t p_tt, Type *p_type, Ttcn::ArrayDimension *p_dim,
	 bool p_in_typedef);
    /// Create an ASN.1 open type
    Type(typetype_t p_tt, OC_defn *p_oc_defn, const Identifier *p_id);
    /// Create a reference
    Type(typetype_t p_tt, Reference *p_ref);
    /// Create a TTCN3 port type
    Type(typetype_t p_tt, Ttcn::PortTypeBody *p_pb);
    /// Create a TTCN3 component type
    Type(typetype_t p_tt, ComponentTypeBody *p_cb);
    /// Create a TTCN3 signature
    Type(typetype_t p_tt, SignatureParamList *p_params, Type *p_returntype,
	bool p_noblock, SignatureExceptions *p_exceptions);
    /// Create a TTCN3 function reference
    Type(typetype_t p_tt,Ttcn::FormalParList *p_params,
        Ttcn::Reference* p_runs_on_ref, bool p_runs_on_self,
        Type *p_returntype, bool p_returns_template,
        template_restriction_t p_template_restriction);
    /// Create a TTCN3 altstep
    Type(typetype_t p_tt,Ttcn::FormalParList *p_params,
        Ttcn::Reference* p_runs_on_ref, bool p_runs_on_self);
    /// Create a TTCN3 testcase
    Type(typetype_t p_tt,Ttcn::FormalParList *p_params,
        Ttcn::Reference* p_runs_on_ref, Ttcn::Reference *p_system_ref);
592
    Type(typetype_t p_tt, Ttcn::ClassTypeBody* p_class);
Elemer Lelik's avatar
Elemer Lelik committed
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
    /** @} */
    virtual ~Type();
    /** This function must be called to clean up the pool types,
     *  tags, etc. It is called by main() */
    static void free_pools();
    /** Create a (partial) copy of the object */
    virtual Type* clone() const;
    /** Return the type of type. */
    typetype_t get_typetype() const { return typetype; }
    /** Returns the TTCN-3 equivalent of \a typetype. */
    typetype_t get_typetype_ttcn3() const
      { return get_typetype_ttcn3(typetype); }
    /** Returns a simple/built-in type from the pool */
    static Type* get_pooltype(typetype_t p_typetype);
    /** Returns whether the type is defined in an ASN.1 module. */
    bool is_asn1() const;
    /** Returns true if it is a type reference. */
    bool is_ref() const;
    /** Returns true if it is a Sequence, Set or Choice. */
    bool is_secho() const;
    /** Returns true if this is a character-encodable type.
     *  Being character-encodable is a requirement for a type to be
     *  encoded as an XML attribute. */
    truth is_charenc();
    /** Return true if at least one abstract value of the type
     *  has an empty "ExtendedXMLValue" encoding (only possible with EXER).
     *  Possible for record/set when all components are optional,
     *  and record-of/set-of when 0 length is not forbidden. */
    bool has_empty_xml();
    /** Returns whether \a this is a sequence-of/record-of or set-of type. */
    bool is_seof() const { return typetype == T_SEQOF || typetype == T_SETOF; }
    /** Returns the \a sub_type member */
    SubType* get_sub_type() const { return sub_type; }
    /** If this is a reference, returns the referenced type.
     *  Otherwise, it's a fatal error. */
    Type* get_type_refd(ReferenceChain *refch=0);
    /** Walk through all references to the referenced type */
    Type* get_type_refd_last(ReferenceChain *refch=0);
    /** Returns the type of the field, which is referenced by \a subrefs from
     * \a this. It checks the array indices against \a expected_index. In case
     * of error NULL is returned.
     * Special case: if \a interrupt_if_optional is true then return NULL if an
     * optional field has been reached. Using this bool parameter it can be
     * checked if a referenced field is on an optional path (used by template
637
638
639
640
641
642
     * restriction checking code)
     * @param last_method if not null, indicates that a method with no return
     * value is valid at the end of the subreferences, and should not produce
     * an error; the function assignment is also stored in the pointer pointed
     * to by this parameter if the last subreference is a method (even if it has
     * a return value) */
Elemer Lelik's avatar
Elemer Lelik committed
643
644
    Type *get_field_type(Ttcn::FieldOrArrayRefs *subrefs,
      expected_value_t expected_index, ReferenceChain *refch = 0,
645
      bool interrupt_if_optional = false, Assignment** last_method = NULL);
Elemer Lelik's avatar
Elemer Lelik committed
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
    /** subrefs must point to an existing field, get_field_type() should be used
      * to check. subrefs_array will be filled with the indexes of the fields,
      * type_array will be filled with types whose field indexes were collected,
      * if an invalid index is encountered false will be returned */
    bool get_subrefs_as_array(const Ttcn::FieldOrArrayRefs *subrefs,
      dynamic_array<size_t>& subrefs_array, dynamic_array<Type*>& type_array);
    /** Returns whether the last field referenced by \a subrefs is an optional
     * record/SEQUENCE or set/SET field. It can be used only after a successful
     * semantic check (e.g. during code generation) or the behaviour will be
     * unpredictable. */
    bool field_is_optional(Ttcn::FieldOrArrayRefs *subrefs);
    /** Returns whether this type instance is the type of an optional field.  */
    bool is_optional_field() const;
    virtual void set_fullname(const string& p_fullname);
    /** Sets the internal pointer my_scope to \a p_scope. */
    virtual void set_my_scope(Scope *p_scope);
    /** Checks the type (including tags). */
    virtual void chk();
664
665
666
667
668
669
670
    
    /** Checks the encodings supported by the type (when using new codec handling).
      * TTCN-3 types need to have an 'encode' attribute to support an encoding.
      * ASN.1 types automatically support BER, PER and JSON encodings, and XER
      * encoding, if set by the compiler option. */
    void chk_encodings();
    
671
672
673
674
675
676
677
678
679
680
681
682
683
    /** Checks the type's variant attributes (when using the new codec handling). */
    void chk_variants();
    
    /** Parses the specified variant attribute and checks its validity (when 
      * using the new codec handling). */
    void chk_this_variant(const Ttcn::SingleWithAttrib* swa, bool global);
    
    /** Checks the coding instructions set by the parsed variant attributes.
      * The check is performed recursively on the type's fields and elements
      * when using the new codec handling.
      * The check is only performed on this type, when using legacy codec handling. */
    void chk_coding_attribs();
    
684
685
686
687
    /** Adds support for an encoding by the type (when using new codec handling),
      * if the type can have that encoding.
      * @param name name of the encoding as it appears in the 'encode' attribute;
      * this may be the name of a built-in or a user-defined encoding */
688
    void add_coding(const string& name, Ttcn::attribute_modifier_t modifier, bool silent);
689
690
691
692
693
694
    
    /** Sets the encoder or decoder function for the user-defined encoding with
      * the specified name (when using new codec handling). */
    void set_coding_function(const char* coding_name, boolean encode,
      Assignment* function_def);
    
695
696
697
698
    /** Returns the custom encoder or decoder function at the specified index in
      * the coding table related to this type (when using the new codec handling). */
    coder_function_t* get_coding_function(size_t index, boolean encode);
    
699
700
701
    /** Returns the type that contains this type's coding table (since types
      * with no 'encode' attributes of their own inherit the 'encode' attributes
      * of a referenced type or a parent type).
702
703
      * @param ignore_local indicates whether to ignore attributes with the
      * '@local' modifier
704
      * Only used with new codec handling. */
705
    Type* get_type_w_coding_table(bool ignore_local = false);
706
    
707
708
    const vector<coding_t>& get_coding_table() const { return coding_table; }
    
709
    /** Returns whether this type can have the specified encoding.
710
711
      * (Returns 'unknown' if the type is part of an ASN.1 structure that
      * hasn't been fully checked yet.)
712
      * Only used with new codec handling. */
713
    tribool can_have_coding(MessageEncodingType_t coding);
714
    
715
716
717
718
    /** Checks whether the type itself or one of its fields/elements is a
      * component or default type. Recursive. */
    void chk_map_param(Location* usage);
    
Elemer Lelik's avatar
Elemer Lelik committed
719
720
721
    /** Return whether the two typetypes are compatible.  Sometimes, this is
     *  just a question of \p p_tt1 == \p p_tt2.  When there are multiple
     *  typetypes for a type (e.g. T_ENUM_A and T_ENUM_T) then all
BenceJanosSzabo's avatar
BenceJanosSzabo committed
722
723
     *  combinations of those are compatible. In case of anytype the
     *  module has to be the same  */
Elemer Lelik's avatar
Elemer Lelik committed
724
    static bool is_compatible_tt_tt(typetype_t p_tt1, typetype_t p_tt2,
BenceJanosSzabo's avatar
BenceJanosSzabo committed
725
726
                                    bool p_is_asn11, bool p_is_asn12,
                                    bool same_module);
Elemer Lelik's avatar
Elemer Lelik committed
727
728
729
730
731
    /** Returns whether the type is compatible with \a p_tt.  Used if the
     *  other value is unfoldable, but we can determine its expr_typetype.
     *  Note: The compatibility relation is asymmetric.  The function returns
     *  true if the set of possible values in \a p_type is a subset of
     *  possible values in \a this.  */
BenceJanosSzabo's avatar
BenceJanosSzabo committed
732
    bool is_compatible_tt(typetype_t p_tt, bool p_is_asn1, Type* p_type = 0);
Elemer Lelik's avatar
Elemer Lelik committed
733
734
735
736
737
738
739
740
741
742
743
    /** Returns whether this type is compatible with \a p_type.  Note: The
     *  compatibility relation is asymmetric.  The function returns true if
     *  the set of possible values in \a p_type is a subset of possible values
     *  in \a this.  It returns false if the two types cannot be compatible
     *  ever.  If the two types are compatible, but they need additional
     *  "type" conversion code generated with run-time checks \p p_info will
     *  provide more information.  \p p_info is used to collect type
     *  information to report more precise errors.  \p p_left_chain and
     *  \p p_right_chain are there to prevent infinite recursion.
     *  \p p_left_chain contains the type chain of the left operand from the
     *  "root" type to this point in the type's structure.  \p p_right_chain
Elemer Lelik's avatar
Elemer Lelik committed
744
745
746
     *  is the same for the right operand.
     * \p p_is_inline_template indicates that the conversion is requested for an
     * inline template. Type conversion code is not needed in this case. */
Elemer Lelik's avatar
Elemer Lelik committed
747
    bool is_compatible(Type *p_type, TypeCompatInfo *p_info,
748
                       Location* p_loc,
Elemer Lelik's avatar
Elemer Lelik committed
749
                       TypeChain *p_left_chain = NULL,
Elemer Lelik's avatar
Elemer Lelik committed
750
751
                       TypeChain *p_right_chain = NULL,
                       bool p_is_inline_template = false);
752
753
754
    /** Check if the port definitions of the component types are the same
     */
    bool is_compatible_component_by_port(Type *p_type);
Elemer Lelik's avatar
Elemer Lelik committed
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
    /** Check if the restrictions of a T_SEQOF/T_SETOF are "compatible" with
     *  the given type \a p_type.  Can be called only as a T_SEQOF/T_SETOF.
     *  Currently, used for structured types only.  \a p_type can be any kind
     *  of structured type.  */
    bool is_subtype_length_compatible(Type *p_type);
    /** Check if it's a structured type.  Return true if the current type is a
     *  structured type, false otherwise.  */
    bool is_structured_type() const;
    /** returns the type as a string */
    virtual const char* asString() const;
    static const char* asString(typetype_t type);

  private:
    /** Helper functions for is_compatible().  These functions can be called
     *  only for a Type that the name suggests.  \p p_type is the Type we're
     *  checking compatibility against.  \p p_info is used to collect type
     *  information to report more precise errors.  \p p_left_chain and
     *  \p p_right_chain are there to prevent infinite recursion.
     *  \p p_left_chain contains the type chain of the left operand from the
     *  "root" type to this point in the type's structure.  \p p_right_chain
Elemer Lelik's avatar
Elemer Lelik committed
775
776
777
     *  is the same for the right operand. 
     *  \p p_is_inline_template indicates that the conversion is requested for an
     *  inline template. Type conversion code is not needed in this case. */
Elemer Lelik's avatar
Elemer Lelik committed
778
    bool is_compatible_record(Type *p_type, TypeCompatInfo *p_info,
779
                              Location* p_loc,
Elemer Lelik's avatar
Elemer Lelik committed
780
                              TypeChain *p_left_chain = NULL,
Elemer Lelik's avatar
Elemer Lelik committed
781
782
                              TypeChain *p_right_chain = NULL,
                              bool p_is_inline_template = false);
Elemer Lelik's avatar
Elemer Lelik committed
783
    bool is_compatible_record_of(Type *p_type, TypeCompatInfo *p_info,
784
                                 Location* p_loc,
Elemer Lelik's avatar
Elemer Lelik committed
785
                                 TypeChain *p_left_chain = NULL,
Elemer Lelik's avatar
Elemer Lelik committed
786
787
                                 TypeChain *p_right_chain = NULL,
                                 bool p_is_inline_template = false);
Elemer Lelik's avatar
Elemer Lelik committed
788
    bool is_compatible_set(Type *p_type, TypeCompatInfo *p_info,
789
                           Location* p_loc,
Elemer Lelik's avatar
Elemer Lelik committed
790
                           TypeChain *p_left_chain = NULL,
Elemer Lelik's avatar
Elemer Lelik committed
791
792
                           TypeChain *p_right_chain = NULL,
                           bool p_is_inline_template = false);
Elemer Lelik's avatar
Elemer Lelik committed
793
    bool is_compatible_set_of(Type *p_type, TypeCompatInfo *p_info,
794
                              Location* p_loc,
Elemer Lelik's avatar
Elemer Lelik committed
795
                              TypeChain *p_left_chain = NULL,
Elemer Lelik's avatar
Elemer Lelik committed
796
797
                              TypeChain *p_right_chain = NULL,
                              bool p_is_inline_template = false);
Elemer Lelik's avatar
Elemer Lelik committed
798
    bool is_compatible_array(Type *p_type, TypeCompatInfo *p_info,
799
                             Location* p_loc,
Elemer Lelik's avatar
Elemer Lelik committed
800
                             TypeChain *p_left_chain = NULL,
Elemer Lelik's avatar
Elemer Lelik committed
801
802
                             TypeChain *p_right_chain = NULL,
                             bool p_is_inline_template = false);
Elemer Lelik's avatar
Elemer Lelik committed
803
    bool is_compatible_choice_anytype(Type *p_type, TypeCompatInfo *p_info,
804
                                      Location* p_loc,
Elemer Lelik's avatar
Elemer Lelik committed
805
                                      TypeChain *p_left_chain = NULL,
Elemer Lelik's avatar
Elemer Lelik committed
806
807
                                      TypeChain *p_right_chain = NULL,
                                      bool p_is_inline_template = false);
Elemer Lelik's avatar
Elemer Lelik committed
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
  public:
    /** Returns whether this type is identical to \a p_type from TTCN-3 point
     *  of view.  Note: This relation is symmetric.  The function returns true
     *  only if the sets of possible values are the same in both types.  */
    bool is_identical(Type *p_type);
    /** Tasks: Decides whether the type needs automatic tagging, performs the
     *  COMPONENTS OF transformations (recursively) and adds the automatic
     *  tags. */
    void tr_compsof(ReferenceChain *refch = 0);
    /** Returns whether the T_FUNCTION is startable.
     *  @pre typetype is T_FUNCTION, or else FATAL_ERROR occurs.  */
    bool is_startable();

    /** Returns true if this is a list type (string, rec.of, set.of or array */
    bool is_list_type(bool allow_array);

Elemer Lelik's avatar
Elemer Lelik committed
824
    /** Sets the encoding or decoding function for the type (in case of custom
825
826
      * or PER encoding). Only used with legacy codec handling. */
    void set_legacy_coding_function(bool encode, Assignment* function_def);
827
    
828
829
    /** Sets the codec to use when encoding or decoding the ASN.1 type.
      * Only used with legacy codec handling. */
830
    void set_asn_coding(bool encode, MessageEncodingType_t new_coding);
831
832
833
834
835
836
837
838
839
    
    /** Determines the method of encoding or decoding for values of this type
      * based on its attributes and on encoder or decoder function definitions
      * with this type as their input or output. An error is displayed if the
      * coding method cannot be determined.
      *
      * @note Because this check depends on the checks of other AST elements
      * (external functions), it is sometimes delayed to the end of the semantic
      * analysis. */
840
    void chk_coding(bool encode, Module* usage_mod, bool delayed = false);
841
842
843
    
    /** Indicates whether the type is encoded/decoded by a function or by a
      * built-in codec. */
844
    bool is_coding_by_function(bool encode) const;
845
846
847
848
849
850
851
    
    /** Returns the string representation of the type's default codec.
      * Used during code generation for types encoded/decoded by a built-in
      * codec. */
    string get_coding(bool encode) const;
    
    /** Returns the function definition of the type's encoder/decoder function.
852
853
854
      * Used during code generation for types encoded/decoded by functions.
      * Only used with legacy codec handling. */
    Assignment* get_legacy_coding_function(bool encode) const;
855
    
856
857
    static MessageEncodingType_t get_enc_type(const string& enc);
    
Elemer Lelik's avatar
Elemer Lelik committed
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
  private:
    void chk_Int_A();
    void chk_Enum_A();
    void chk_Enum_item(EnumItem *ei, bool after_ellipsis,
                       map<Int, EnumItem>& value_map);
    void chk_Enum_T();
    void chk_BStr_A();
    void chk_SeCho_T();
    void chk_Choice_A();
    void chk_Se_A();
    void chk_SeOf();
    void chk_refd();
    void chk_seltype();
    void chk_Array();
    void chk_Signature();
    void chk_Fat();
  public:
    /** Checks whether the type can be the TTCN-3 address type. Not allowed:
     * the default type, references pointing to port types, component types
     * and signatures */
    void chk_address();
    /** Checks whether the type can be a component of another type definition
     *  (e.g. field of a structured type, parameter/return type/exception of a
     *  signature).
     *  Not allowed types: ports, signatures.
     *  Default type is allowed only within structured types.
     *  The text for the end of the error message is passed as parameter.
     */
    void chk_embedded(bool default_allowed, const char *error_msg);
    /** Checks for circular references within embedded types */
    void chk_recursions(ReferenceChain& refch);
    /** Checks that the structured type does not have fields
     * with the name of its definition.
     */
    void chk_constructor_name(const Identifier& p_id);
893
    bool chk_startability(Location* caller_location);
Elemer Lelik's avatar
Elemer Lelik committed
894
895
896
897
898
899
900
901
902
903
904
905
906
    /** Checks if it can be a return type */
    void chk_as_return_type(bool as_value, const char* what);
  private:
    void parse_block_Int();
    void parse_block_Enum();
    void parse_block_BStr();
    void parse_block_Choice();
    void parse_block_Se();
    int get_length_multiplier();
    void parse_attributes();
    void chk_raw();
    /** If the type does not have a rawattrib, create one. */
    void force_raw();
907
    int get_default_raw_fieldlength();
Elemer Lelik's avatar
Elemer Lelik committed
908
909
910
911
912
913
914
915
    void chk_text();
    void chk_text_matching_values(textAST_matching_values *matching_values,
      const char *attrib_name);
    /** If the type does not have a textattrib, create one. */
    void force_text();
    
    void chk_json();
    void chk_json_default();
916
    void chk_json_tag_list();
Elemer Lelik's avatar
Elemer Lelik committed
917
918
919
920
921
922
923
924
    /** If the type does not have a jsonattrib, create one. */
    void force_json();

    void chk_xer();
    void chk_xer_any_attributes();
    void chk_xer_any_element();
    void chk_xer_attribute();
    void chk_xer_dfe();
925
    Value *new_value_for_dfe(Type *last, const char *dfe_str, Common::Reference* ref = NULL, bool is_ref_dfe = false);
Elemer Lelik's avatar
Elemer Lelik committed
926
927
928
929
930
931
932
933
    void target_of_text(string& text);
    void chk_xer_embed_values(int num_attributes);
    void chk_xer_text();
    void chk_xer_untagged();
    void chk_xer_use_nil();
    void chk_xer_use_order(int num_attributes);
    void chk_xer_use_type();
    void chk_xer_use_union();
934
935
    
    void chk_oer();
Elemer Lelik's avatar
Elemer Lelik committed
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979

    bool is_root_basic();
    int get_raw_length();
  public:
    void set_parent_type(Type *p_parent_type) {parent_type=p_parent_type;}
    Type* get_parent_type() const {return parent_type;}
    void set_has_opentypes() {has_opentypes=true;}
    bool get_has_opentypes() const {return has_opentypes;}
    void set_opentype_outermost() {opentype_outermost=true;}
    bool get_is_opentype_outermost() const {return opentype_outermost;}
    /** If \a value is an undef lowerid, then this member decides
     * whether it is a reference or a lowerid value (e.g., enum, named
     * number). */
    void chk_this_value_ref(Value *value);
    bool chk_this_value(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool incomplete_allowed,
      namedbool omit_allowed, namedbool sub_chk,
      namedbool implicit_omit = NOT_IMPLICIT_OMIT,
      namedbool str_elem = NOT_STR_ELEM);
    /** Checks the given referenced value */
    bool chk_this_refd_value(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, ReferenceChain *refch=0,
      namedbool str_elem = NOT_STR_ELEM);
    /** Checks the given invocation */
    void chk_this_invoked_value(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value);
  private:
    void chk_this_value_Null(Value *value);
    void chk_this_value_Bool(Value *value);
    void chk_this_value_Int(Value *value);
    void chk_this_value_Int_A(Value *value);
    void chk_this_value_Real(Value *value);
    void chk_this_value_Enum(Value *value);
    void chk_this_value_BStr(Value *value);
    void chk_this_value_namedbits(Value *value);
    void chk_this_value_BStr_A(Value *value);
    void chk_this_value_HStr(Value *value);
    void chk_this_value_OStr(Value *value);
    void chk_this_value_CStr(Value *value);
    void chk_this_value_OID(Value *value);
    void chk_this_value_ROID(Value *value);
    void chk_this_value_Any(Value *value);
    bool chk_this_value_Choice(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool incomplete_allowed,
980
981
982
      namedbool omit_allowed, namedbool sub_chk,
      namedbool implicit_omit = NOT_IMPLICIT_OMIT,
      namedbool str_elem = NOT_STR_ELEM);
Elemer Lelik's avatar
Elemer Lelik committed
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
    bool chk_this_value_Se(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool incomplete_allowed,
      namedbool implicit_omit = NOT_IMPLICIT_OMIT);
    bool chk_this_value_Se_T(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool incomplete_allowed,
      namedbool implicit_omit = NOT_IMPLICIT_OMIT);
    bool chk_this_value_Seq_T(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool incomplete_allowed,
      namedbool implicit_omit = NOT_IMPLICIT_OMIT);
    bool chk_this_value_Set_T(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool incomplete_allowed,
      namedbool implicit_omit = NOT_IMPLICIT_OMIT);
    bool chk_this_value_Se_A(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool implicit_omit);
    bool chk_this_value_Seq_A(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool implicit_omit);
    bool chk_this_value_Set_A(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool implicit_omit);
    bool chk_this_value_SeOf(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool incomplete_allowed,
      namedbool implicit_omit = NOT_IMPLICIT_OMIT);
    void chk_this_value_Verdict(Value *value);
    void chk_this_value_Default(Value *value);
    bool chk_this_value_Array(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool incomplete_allowed,
      namedbool implicit_omit);
    bool chk_this_value_Signature(Value *value, Common::Assignment *lhs,
      expected_value_t expected_value, namedbool incomplete_allowed);
    void chk_this_value_Component(Value *value);
    void chk_this_value_FAT(Value *value);
1013
    void chk_this_value_class(Value* value);
Elemer Lelik's avatar
Elemer Lelik committed
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
  public:
    /** Checks whether template \a t is a specific value and the embedded value
     * is a referenced one. If the reference in the value points to a
     * template-like entity then it sets the template type to TEMPLATE_REFD,
     * otherwise it leaves everything as is. */
    void chk_this_template_ref(Template *t);
    /** Checks for self references in functions returning templates (external or otherwise)
      * and in parametrised templates. Returns true if the reference in assignment \a lhs 
      * is found. 
      * Recursive: calls itself incase of multiple embedded functions / parametrised templates.*/
1024
    bool chk_this_template_ref_pard(Ttcn::Reference* ref_pard, Common::Assignment* lhs);
Elemer Lelik's avatar
Elemer Lelik committed
1025
1026
1027
    bool chk_this_template_generic(Template *t, namedbool incomplete_allowed,
     namedbool allow_omit, namedbool allow_any_or_omit, namedbool sub_chk,
     namedbool implicit_omit, Common::Assignment *lhs);
1028
1029
    /** Checks if a template's type contains default or port field somehow.*/
    void chk_this_template_incorrect_field();
Elemer Lelik's avatar
Elemer Lelik committed
1030
1031
1032
  private:
    bool chk_this_refd_template(Template *t, Common::Assignment *lhs);
    void chk_this_template_length_restriction(Template *t);
1033
1034
    bool chk_this_template_concat_operand(Template* t, namedbool implicit_omit,
      Common::Assignment *lhs);
1035
1036
1037
    bool chk_this_template(Template *t, namedbool incomplete_allowed,
      namedbool allow_omit, namedbool allow_any_or_omit, namedbool sub_chk,
      namedbool implicit_omit, Common::Assignment *lhs);
1038
1039
    bool chk_this_template_Str(Template *t, namedbool implicit_omit,
      Common::Assignment *lhs);
Elemer Lelik's avatar
Elemer Lelik committed
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
    /** Checks whether \a v is a correct range boundary for this type.
     * Applicable to the following types: integer, float, charstring,
     * universal charstring.
     * Argument \a v might be NULL in case of + or - infinity.
     * Argument \a which shall contain the word "lower" or "upper".
     * Argument \a loc is used for error reporting if \a v is NULL (it points
     * to the surrounding template).
     * If \a v is correct and it is or refers to a constant the constant value
     * is returned for further checking. Otherwise the return value is NULL. */
    Value *chk_range_boundary(Value *v, const char *which, const Location& loc);
Elemer Lelik's avatar
Elemer Lelik committed
1050
    void chk_range_boundary_infinity(Value *v, bool is_upper);
Elemer Lelik's avatar
Elemer Lelik committed
1051
1052
1053
    void chk_this_template_builtin(Template *t);
    void chk_this_template_Int_Real(Template *t);
    void chk_this_template_Enum(Template *t);
1054
    bool chk_this_template_Choice(Template *t, namedbool incomplete_allowed,
1055
      namedbool allow_omit, namedbool allow_any_or_omit, namedbool sub_chk,
Elemer Lelik's avatar
Elemer Lelik committed
1056
      namedbool implicit_omit, Common::Assignment *lhs);
1057
    bool chk_this_template_Seq(Template *t, namedbool incomplete_allowed,
Elemer Lelik's avatar
Elemer Lelik committed
1058
      namedbool implicit_omit, Common::Assignment *lhs);
1059
    bool chk_this_template_Set(Template *t, namedbool incomplete_allowed,
Elemer Lelik's avatar
Elemer Lelik committed
1060
      namedbool implicit_omit, Common::Assignment *lhs);
1061
    bool chk_this_template_SeqOf(Template *t, namedbool incomplete_allowed,
Elemer Lelik's avatar
Elemer Lelik committed
1062
      namedbool implicit_omit, Common::Assignment *lhs);
1063
    bool chk_this_template_SetOf(Template *t, namedbool incomplete_allowed,
Elemer Lelik's avatar
Elemer Lelik committed
1064
      namedbool implicit_omit, Common::Assignment *lhs);
1065
    bool chk_this_template_array(Template *t, namedbool incomplete_allowed,
Elemer Lelik's avatar
Elemer Lelik committed
1066
1067
      namedbool implicit_omit, Common::Assignment *lhs);
    void chk_this_template_Fat(Template *t);
1068
    void chk_this_template_Signature(Template *t, namedbool incomplete_allowed);
Elemer Lelik's avatar
Elemer Lelik committed
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
  public:
    /** Check whether there is an enum item with the given name.
     *
     * @pre typetype is T_ENUM_T or T_ENUM_A */
    bool has_ei_withName(const Identifier& p_id) const;

    /** Return the enum item with the given name.
     *
     * @pre typetype is T_ENUM_T or T_ENUM_A */
    EnumItem *get_ei_byName(const Identifier& p_id) const;

    /** Return the enum item with the given index.
     *
     * @pre typetype is T_ENUM_T or T_ENUM_A */
    EnumItem *get_ei_byIndex(size_t i) const;

    /** Get the number of components.
     *
     * @return the number of components from the appropriate alternative
     * depending on the \a typetype.
     *
     * @pre \a typetype is one of T_CHOICE_T, T_SEQ_T, T_SET_T, T_OPENTYPE,
     * T_SEQ_A, T_SET_A, T_CHOICE_A,  T_ARRAY, T_SIGNATURE, T_ANYTYPE */
    size_t get_nof_comps();

    /** Get the name (id) of the component with the given index.
     *
     * @pre \a typetype is one of T_CHOICE_T, T_SEQ_T, T_SET_T, T_OPENTYPE,
     * T_SEQ_A, T_SET_A, T_CHOICE_A, T_SIGNATURE, T_ANYTYPE
     *
     * @note Not valid for T_ARRAY */
    const Identifier& get_comp_id_byIndex(size_t n);

    /** Get the component with the given index.
     *
     * @pre \a typetype is one of T_CHOICE_T, T_SEQ_T, T_SET_T, T_OPENTYPE,
     * T_SEQ_A, T_SET_A, T_CHOICE_A, T_ANYTYPE
     *
     * @note Not valid for T_ARRAY or T_SIGNATURE */
    CompField* get_comp_byIndex(size_t n);

    /** Get the index of the component with the given name
     *
     * @pre \a typetype of the last referenced type is one of
     * T_CHOICE_T, T_SEQ_T, T_SET_T, T_OPENTYPE,
     * T_SEQ_A, T_SET_A, T_CHOICE_A, T_ANYTYPE */
    size_t get_comp_index_byName(const Identifier& p_name);
1116
1117
    
    CompField* get_default_alternative();
Elemer Lelik's avatar
Elemer Lelik committed
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182

    /** Get the index of the enum item with the given name
     *
     * @pre typetype is T_ENUM_T or T_ENUM_A */
    size_t get_eis_index_byName(const Identifier& p_name);

    const Int& get_enum_val_byId(const Identifier& p_name);

    size_t get_nof_root_comps();
    CompField* get_root_comp_byIndex(size_t n);

    /** Get the name (id) of the component with the given index.
     *
     * @pre \a typetype is one of T_CHOICE_T, T_SEQ_T, T_SET_T, T_OPENTYPE,
     * T_SEQ_A, T_SET_A, T_CHOICE_A, T_SIGNATURE, T_ANYTYPE
     *
     * @note Not valid for T_ARRAY */
    bool has_comp_withName(const Identifier& p_name);
    CompField* get_comp_byName(const Identifier& p_name);
    void add_comp(CompField *p_cf);

    /** Returns the embedded type of 'sequence/record of', 'set of' or array
     * types. */
    Type *get_ofType();

    OC_defn* get_my_oc();
    const Identifier& get_oc_fieldname();
    void set_my_tableconstraint(const TableConstraint *p_tc);
    const TableConstraint* get_my_tableconstraint();

    /** Returns the array dimension. Applicable only if typetype == T_ARRAY. */
    Ttcn::ArrayDimension *get_dimension() const;

    /** Returns the PortTypeBody if typetype == T_PORT */
    Ttcn::PortTypeBody *get_PortBody() const;

    /** Returns the ComponentTypeBody if typetype == T_COMPONENT */
    ComponentTypeBody *get_CompBody() const;

    /** Returns the parameters of a signature.
     * Applicable only if typetype == T_SIGNATURE. */
    SignatureParamList *get_signature_parameters() const;
    /** Returns the parameters of a signature.
     * Applicable only if typetype == T_SIGNATURE. */
    SignatureExceptions *get_signature_exceptions() const;
    /** Returns the return type of a signature.
     * Applicable only if typetype == T_SIGNATURE. */
    Type *get_signature_return_type() const;
    /** Returns whether the type is a non-blocking signature.
     * Applicable only if typetype == T_SIGNATURE. */
    bool is_nonblocking_signature() const;
    /** Returns the parameters of a functionreference
     * Applicable only if typetype == T_FUNCTION or T_ALTSTEP or T_TESTCASE */
    Ttcn::FormalParList *get_fat_parameters();
    /** Returns the return type of a functionreference
     * Applicable only if typetype == T_FUNCTION */
    Type *get_function_return_type();
    /** Returns the runs on type of a functionreference
     * Appliacable only if typetype == T_FUNCTION or T_ALTSTEP or T_TESTCASE */
    Type *get_fat_runs_on_type();
    /** Returns if a functionreference 'runs on self'
     * Appliacable only if typetype == T_FUNCTION or T_ALTSTEP or T_TESTCASE */
    bool get_fat_runs_on_self();
    /** Applicable only if typetype == T_FUNCTION */
    bool get_returns_template();
1183
1184
    /** Applicably only if typetype == T_CLASS */
    Ttcn::ClassTypeBody* get_class_type_body();
Elemer Lelik's avatar
Elemer Lelik committed
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223

    /** Retruns true if it is a tagged type.*/
    bool is_tagged() const {return tags!=0;}
    void add_tag(Tag *p_tag);
    bool is_constrained() const {return constraints!=0;}
    void add_constraints(Constraints *p_constraints);
    Constraints* get_constraints() const {return constraints;}
    Reference * get_Reference();
  private:
    void chk_table_constraints();
  public:
    /** Returns true if the type has multiple alternative tags
      * (i.e. it is a non-tagged CHOICE type). */
    bool has_multiple_tags();
    /** Returns the tag of type. If this type is tagged, then the
     * outermost tag is returned. */
    Tag *get_tag();
    void get_tags(TagCollection& coll, map<Type*, void>& chain);
    /** Returns the smallest possible tag. If !has_multiple_tags()
     * then returns get_tag(). Used is SET CER encoding, see X.690
     * 9.3... */
    Tag *get_smallest_tag();
    /** Returns whether the type needs explicit tagging. */
    bool needs_explicit_tag();
    /** Removes the tag(s) from the type that was added during
     * automatic tagging transformation. Needed for the implementation
     * of COMPONENTS OF transformation. */
    void cut_auto_tags();
    Tags* build_tags_joined(Tags *p_tags=0);
    void set_with_attr(Ttcn::MultiWithAttrib* p_attrib);
    void set_parent_path(Ttcn::WithAttribPath* p_path);
    Ttcn::WithAttribPath* get_attrib_path() const;
    bool hasRawAttrs();
    bool hasNeedofRawAttrs();
    bool hasNeedofTextAttrs();
    bool hasNeedofJsonAttrs();
    bool hasNeedofXerAttrs();
    bool hasVariantAttrs();
    /** Returns whether the type has the encoding attribute specified by
1224
1225
1226
      * the parameter. The function also checks the qualified attributes of
      * parent types. Always returns true for ASN.1 types, when checking for a
      * JSON encoding attribute. */
Elemer Lelik's avatar
Elemer Lelik committed
1227
    bool hasEncodeAttr(const char* encoding_name);
1228
1229
1230
1231
1232
1233
    /** Helper function for hasEncodeAttr. Checks this type's qualified encoding
      * attributes that refer to the specified type (target_type) and returns
      * true if any of them match the specified encoding (encoding_name).
      * Recursive function (calls the parent type's hasEncodeAttrForType function
      * if no matching attributes are found). */
    bool hasEncodeAttrForType(Type* target_type, const char* encoding_name);
Elemer Lelik's avatar
Elemer Lelik committed
1234
1235
1236
1237
1238
    /** Returns whether \a this can be encoded according to rules
     * \a p_encoding.
     * @note Should be called only during code generation, after the entire
     * AST has been checked, or else the compiler might choke on code like:
     * type MyRecordOfType[-] ElementTypeAlias; */
Elemer Lelik's avatar
Elemer Lelik committed
1239
    bool has_encoding(const MessageEncodingType_t encoding_type, const string* custom_encoding = NULL);
Elemer Lelik's avatar
Elemer Lelik committed
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
    /** Generates the C++ equivalent class(es) of the type. */
    void generate_code(output_struct *target);
    size_t get_codegen_index(size_t index);
  private:
     /** Generates code for the case when the C++ classes are implemented by
      * hand, includes the header file with name sourcefile and extension hh
      */
     void generate_code_include(const string& sourcefile, output_struct *target);
     /** Generates code for the embedded types the C++ classes of which must be
     * placed before the classes of this type (e.g. the types of mandatory
     * record/set fields). */
    void generate_code_embedded_before(output_struct *target);
    /** Generates code for the embedded types the C++ classes of which can be
     * placed after the classes of this type (e.g. the types of union fields
     * and optional record/set fields). */
    void generate_code_embedded_after(output_struct *target);
    void generate_code_typedescriptor(output_struct *target);
    void generate_code_berdescriptor(output_struct *target);
    void generate_code_rawdescriptor(output_struct *target);
    void generate_code_textdescriptor(output_struct *target);
    void generate_code_xerdescriptor(output_struct *target);
1261
1262
    void generate_code_jsondescriptor(output_struct *target);
    void generate_code_oerdescriptor(output_struct *target);
Elemer Lelik's avatar
Elemer Lelik committed
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
    void generate_code_alias(output_struct *target);
    void generate_code_Enum(output_struct *target);
    void generate_code_Choice(output_struct *target);
    Opentype_t *generate_code_ot(stringpool& pool);
    void free_code_ot(Opentype_t* p_ot);
    void generate_code_Se(output_struct *target);
    void generate_code_SeOf(output_struct *target);
    void generate_code_Array(output_struct *target);
    void generate_code_Fat(output_struct *target);
    void generate_code_Signature(output_struct *target);
1273
    void generate_code_coding_handlers(output_struct *target);
Elemer Lelik's avatar
Elemer Lelik committed
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
    /** Returns whether the type needs an explicit C++ typedef alias and/or
     * an alias to a type descriptor of another type. It returns true for those
     * types that are defined in module-level type definitions hence are
     * directly accessible by the users of C++ API (in test ports, external
     * functions). */
    bool needs_alias();
    /** Returns whether this is a pure referenced type that has no tags or
     * encoding attributes. */
    bool is_pure_refd();
    void generate_code_done(output_struct *target);

    /** Helper function used in generate_code_ispresentbound() for the
        ispresent() function in case of template parameter. Returns true
        if the referenced field which is embedded into a "?" is always present,
        otherwise returns false.  **/
    bool ispresent_anyvalue_embedded_field(Type* t,
      Ttcn::FieldOrArrayRefs *subrefs, size_t begin_index);
Elemer Lelik's avatar
Elemer Lelik committed
1291
1292
1293
1294
    
    /** Returns true if the C++ class for this type has already been pre-generated
      * or false if it still needs to be generated */
    bool is_pregenerated();
Elemer Lelik's avatar
Elemer Lelik committed
1295
  public:
1296
1297
1298
1299
1300
    
    /** Returns true if the type supports at least one built-in encoding.
      * Only used with new codec handling. */
    bool has_built_in_encoding();
    
1301
    /** Generates type specific call for the reference used in isbound/ispresent/ischosen call
Elemer Lelik's avatar
Elemer Lelik committed
1302
1303
1304
1305
     * into argument \a expr. Argument \a subrefs holds the reference path
     * that needs to be checked. Argument \a module is the actual module of
     * the reference and is used to gain access to temporal identifiers.
     * Argument \a global_id is the name of the bool variable where the result
1306
     * of the isbound/ispresent/ischosen check is calculated. Argument \a external_id is the name
Elemer Lelik's avatar
Elemer Lelik committed
1307
1308
     * of the assignment where the call chain starts.
     * Argument \a is_template tells if the assignment is a template or not.
1309
1310
     * Argument \a optype tells if the function is isbound or ispresent or ischosen.
     * Argument \a field contains the inspected field of the union when the optype is ischosen.
Elemer Lelik's avatar
Elemer Lelik committed
1311
     */
1312
    void generate_code_ispresentboundchosen(expression_struct *expr,
Elemer Lelik's avatar
Elemer Lelik committed
1313
1314
      Ttcn::FieldOrArrayRefs *subrefs, Common::Module* module,
      const string& global_id, const string& external_id,
1315
      bool is_template, const namedbool optype, const char* field);
Elemer Lelik's avatar
Elemer Lelik committed
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338

    /** Extension attribute for optimized code generation of structured types:
     *    with { extension "optimize:xxx" }
     * xxx tells what to optimize for (e.g.: memory, performance, etc.)
     * returns empty if none given
     */
    string get_optimize_attribute();
    /** Extension attribute for hand written TTCN-3 types:
     *    with { extension "sourcefile:xxx" }
     * filename is xxx, source files: xxx.hh and xxx.cc
     * returns empty if none given
     */
    string get_sourcefile_attribute();
    bool has_done_attribute();
    /** Generates the declaration and definition of a C++ value or template
     * object governed by \a this into \a cdef. Argument \a p_scope points to
     * the scope of the object to be generated. Argument \a name contains the
     * identifier of the target C++ object. If argument \a prefix is not NULL
     * the real object will be generated as static, its name will be
     * prefixed with \a prefix and a const (read-only) reference will be
     * exported with name \a name. This function shall be used when there is no
     * Value or Template object in the AST (e.g. in case of variables). */
    void generate_code_object(const_def *cdef, Scope* p_scope,
1339
      const string& name, const char *prefix, bool is_template,
1340
      bool has_err_descr, bool in_class);
Elemer Lelik's avatar
Elemer Lelik committed
1341
1342
1343
    /** Generates the declaration and definition of a C++ value or template
     * object governed by \a this into \a cdef based on the attributes of
     * \a p_setting. */
1344
    void generate_code_object(const_def *cdef, GovernedSimple *p_setting, bool in_class);
Elemer Lelik's avatar
Elemer Lelik committed
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
  private:
    virtual string create_stringRepr();
  public:
    /** If this type is added to an opentype, then this name is used
     *  as the name of the alternative. */
    Identifier get_otaltname(bool& is_strange);
    /** Returns the name of the C++ value class that represents \a this at
     * runtime. The class is either pre-defined (written manually in the Base
     * Library) or generated by the compiler. The reference is valid in the
     * module that \a p_scope belongs to. */
    string get_genname_value(Scope *p_scope);
    /** Returns the name of the C++ class that represents \a this template at
     * runtime. The class is either pre-defined (written manually in the Base
     * Library) or generated by the compiler. The reference is valid in the
     * module that \a p_scope belongs to. */
    string get_genname_template(Scope *p_scope);
    /** Returns a C++ identifier that can be used to distinguish the type in
     * the union that carries signature exceptions. */
    string get_genname_altname();
    /** User visible (not code generator) type name */
    string get_typename();
    /** User visible type name for built-in types */
    static const char * get_typename_builtin(typetype_t tt);
    string get_genname_typedescriptor(Scope *p_scope);
1369
    string get_genname_coder(Scope* p_scope);
1370
    string get_genname_default_coding(Scope* p_scope);
1371
    string get_exception_name();
Elemer Lelik's avatar
Elemer Lelik committed
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
  private:
    /** Returns the name prefix of type descriptors, etc. that belong to the
     * equivalent C++ class referenced from the module of scope \a p_scope.
     * It differs from \a get_genname() only in case of special ASN.1 types
     * like RELATIVE-OID or various string types. */
    string get_genname_typename(Scope *p_scope);
    /** Return the name of the BER descriptor structure.
     * It is either the name of the type itself;
     * one of "ENUMERATED", "CHOICE", "SEQUENCE", "SET";
     * or one of the core classes e.g. ASN_ROID, UTF8String, etc.
     * The _ber_ suffix needs to be appended by the caller. */
    string get_genname_berdescriptor();
    string get_genname_rawdescriptor();
    string get_genname_textdescriptor();
    string get_genname_xerdescriptor();
    string get_genname_jsondescriptor();
1388
    string get_genname_oerdescriptor();
Elemer Lelik's avatar
Elemer Lelik committed
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
    /** Return the ASN base type to be written into the type descriptor */
    const char* get_genname_typedescr_asnbasetype();
    /** parse subtype information and add parent's subtype information to
        create the effective/aggregate subtype of this type */
    void check_subtype_constraints();
  public:
    /** Return the type of subtype that is associated with this type */
    SubtypeConstraint::subtype_t get_subtype_type();
    virtual void dump(unsigned level) const;
    void set_parsed_restrictions(vector<SubTypeParse> *stp);
    /** Returns true if the values of this type can be used only in 'self'.
     * Some types (default, function reference with 'runs on self') are
     * invalid outside of the component they were created in, they should not
     * be sent/received in ports or used in compref.start(). All structured
     * types that may contain such internal types are also internal. */
    bool is_component_internal();
    /** Prints error messages for types that cannot leave the component.
     * Should be called only if is_component_internal() returned true.
     * \a type_chain is used to escape infinite recursion by maintaining a
     * chain of structured types that call this function recursively,
     * \a p_what tells what is the reason of the error. */
    void chk_component_internal(map<Type*,void>& type_chain,
      const char* p_what);
    /** Prints error messages for type that cannot be a type of given ones (parameter: array of typetype_t)
     * \a type_chain is used to escape infinite recursion by maintaining a
     * chain of structured types that call this function recursively,
     * \returns the original type or a not allowed one */
    typetype_t search_for_not_allowed_type(map<Type*, void>& type_chain,
                                           map<typetype_t, void>& not_allowed);
    /** Set the owner and its type type */
    void set_ownertype(TypeOwner_t ot, Node *o) { ownertype = ot; owner = o; }
1420
1421
1422
    
    TypeOwner_t get_ownertype() const { return ownertype; }
    Node* get_owner() const { return owner; }
Elemer Lelik's avatar
Elemer Lelik committed
1423
1424
1425

    bool is_untagged() const;
    
1426
    inline bool is_pard_type_instance() { return pard_type_instance; }
Elemer Lelik's avatar
Elemer Lelik committed
1427
1428
    inline void set_pard_type_instance() { pard_type_instance = true; }
    
1429
1430
    inline void set_needs_any_from_done() { needs_any_from_done = true; }
    
1431
1432
    bool get_gen_coder_functions(MessageEncodingType_t coding);
    void set_gen_coder_functions(MessageEncodingType_t coding);
1433
    
Elemer Lelik's avatar
Elemer Lelik committed
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
    /** Calculates the type's display name from the genname (replaces double
      * underscore characters with single ones) */
    string get_dispname() const;
    
    /** Generates the JSON schema segment that would validate this type and
      * inserts it into the main schema.
      * @param json JSON tokenizer containing the main JSON schema
      * @param embedded true if the type is embedded in another type's definition;
      * false if it has its own definition
      * @param as_value true if this type is a field of a union with the "as value"
      * coding instruction */
    void generate_json_schema(JSON_Tokenizer& json, bool embedded, bool as_value);
    
    /** Generates the JSON schema segment that would validate a record of, set of
      * or array type and inserts it into the main schema. */
    void generate_json_schema_array(JSON_Tokenizer& json);
    
    /** Generates the JSON schema segment that would validate a record or set type 
      * and inserts it into the main schema. */
    void generate_json_schema_record(JSON_Tokenizer& json);
    
    /** Generates the JSON schema segment that would validate a union type or 
      * an anytype and inserts it into the main schema. */
    void generate_json_schema_union(JSON_Tokenizer& json);
Elemer Lelik's avatar
Elemer Lelik committed
1458
1459
1460
1461
    
    /** Generates a reference to this type's schema segment and inserts it into
      * the given schema. */
    void generate_json_schema_ref(JSON_Tokenizer& json);
Elemer Lelik's avatar
Elemer Lelik committed
1462
1463
    
    JsonAST* get_json_attributes() const { return jsonattrib; }
Elemer Lelik's avatar
Elemer Lelik committed
1464
1465
1466
1467
    
    /** Returns true if the type is a union with the JSON "as value" attribute, or
      * if a union with this attribute is embedded in the type. */
    bool has_as_value_union();
Elemer Lelik's avatar
Elemer Lelik committed
1468
1469
1470
1471
1472
1473
1474
  };

  /** @} end of AST_Type group */

} // namespace Common

#endif // _Common_Type_HH