compiler2/ttcn3/AST_ttcn3.hh

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Copyright (c) 2000-2014 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 _Ttcn_AST_HH
   9 #define _Ttcn_AST_HH
  10
  11 #include "../AST.hh"
  12
  13 namespace Common {
  14 class CodeGenHelper;
  15 }
  16
  17 /**
  18  * This namespace contains classes unique to TTCN-3 and some specializations
  19  * of classes from Common.
  20  */
  21 namespace Ttcn {
  22
  23   /**
  24    * \addtogroup AST
  25    *
  26    * @{
  27    */
  28
  29   using namespace Common;
  30
  31   class Module;
  32   class Definition;
  33   class FriendMod;
  34   class Imports;
  35   class ImpMod;
  36   class ActualPar;
  37   class ActualParList;
  38   class FormalParList;
  39   class ParsedActualParameters;
  40   class Template;
  41   class TemplateInstance;
  42   class TemplateInstances;
  43   class ArrayDimensions;
  44   class Timer;
  45   class StatementBlock;
  46   class AltGuards;
  47   class ILT;
  48   class Group;
  49   class WithAttribPath;
  50   class ErrorBehaviorList;
  51   class ErroneousAttributes;
  52   class ErroneousAttributeSpec;
  53   class PrintingType;
  54
  55   /** Class to represent an actual parameter */
  56   class ActualPar : public Node {
  57   public:
  58     enum ap_selection_t {
  59       AP_ERROR,    ///< erroneous
  60       AP_VALUE,    ///< "in" value parameter
  61       AP_TEMPLATE, ///< "in" template parameter
  62       AP_REF,      ///< out/inout value or template parameter
  63       AP_DEFAULT   ///< created from the default value of a formal parameter
  64     };
  65   private:
  66     ap_selection_t selection;
  67     union {
  68       Value *val; ///< Value for AP_VALUE. Owned by ActualPar
  69       TemplateInstance *temp; ///< %Template for AP_TEMPLATE. Owned by ActualPar
  70       Ref_base  *ref; ///< %Reference for AP_REF. Owned by ActualPar
  71       ActualPar *act; ///< For AP_DEFAULT. \b Not owned by ActualPar
  72     };
  73     Scope *my_scope; ///< %Scope. Not owned
  74     /** tells what runtime template restriction check to generate,
  75      *  TR_NONE means that no check is needed because it could be determined
  76      *  in compile time */
  77     template_restriction_t gen_restriction_check;
  78     /** if this is an actual template parameter of an external function add
  79      *  runtime checks for out and inout parameters after the call */
  80     template_restriction_t gen_post_restriction_check;
  81   private:
  82     /** Copy constructor not implemented */
  83     ActualPar(const ActualPar& p);
  84     /** %Assignment disabled */
  85     ActualPar& operator=(const ActualPar& p);
  86   public:
  87     /// Constructor for an erroneous object (fallback)
  88     ActualPar()
  89     : Node(), selection(AP_ERROR), my_scope(0),
  90       gen_restriction_check(TR_NONE), gen_post_restriction_check(TR_NONE) {}
  91     /// Actual par for an in value parameter
  92     ActualPar(Value *v);
  93     /// Actual par for an in template parameter
  94     ActualPar(TemplateInstance *t);
  95     /// Actual par for an {out or inout} {value or template} parameter
  96     ActualPar(Ref_base *r);
  97     /// Created from the default value of a formal par, at the call site,
  98     ///
  99     ActualPar(ActualPar *a);
 100     virtual ~ActualPar();
 101     virtual ActualPar *clone() const;
 102     virtual void set_fullname(const string& p_fullname);
 103     virtual void set_my_scope(Scope *p_scope);
 104     bool is_erroneous() const { return selection == AP_ERROR; }
 105     ap_selection_t get_selection() const { return selection; }
 106     Value *get_Value() const;
 107     TemplateInstance *get_TemplateInstance() const;
 108     Ref_base *get_Ref() const;
 109     ActualPar *get_ActualPar() const;
 110     /** Checks the embedded recursions within the value or template instance. */
 111     void chk_recursions(ReferenceChain& refch);
 112     /** Returns whether the actual parameter can be represented by an in-line
 113      * C++ expression. */
 114     bool has_single_expr();
 115     void set_code_section(GovernedSimple::code_section_t p_code_section);
 116     /** Generates the C++ equivalent of \a this into \a expr.
 117      * Flag \a copy_needed indicates whether to add an extra copy constructor
 118      * call if \a this contains a referenced value or template to avoid
 119      * aliasing problems with other out/inout parameters. */
 120     void generate_code(expression_struct *expr, bool copy_needed, bool lazy_param=false, bool used_as_lvalue=false) const;
 121     /** Appends the initialization sequence of all (directly or indirectly)
 122      * referred non-parameterized templates to \a str and returns the resulting
 123      * string. Flag \a is_local indicates whether the respective formal
 124      * parameter is in the same module as \a this. It is considered only if
 125      * \a selection is AP_DEFAULT. */
 126     char *rearrange_init_code(char *str, bool is_local);
 127     char *rearrange_init_code_defval(char *str);
 128     /** Appends the string representation of the actual parameter to \a str. */
 129     void append_stringRepr(string& str) const;
 130     virtual void dump(unsigned level) const;
 131     void set_gen_restriction_check(template_restriction_t tr)
 132       { gen_restriction_check = tr; }
 133     template_restriction_t get_gen_restriction_check()
 134       { return gen_restriction_check; }
 135     void set_gen_post_restriction_check(
 136       template_restriction_t p_gen_post_restriction_check)
 137       { gen_post_restriction_check = p_gen_post_restriction_check; }
 138   };
 139
 140   /// A collection of actual parameters (parameter list)
 141   class ActualParList : public Node {
 142     vector<ActualPar> params;
 143   public:
 144     ActualParList(): Node(), params() { }
 145     ActualParList(const ActualParList& p);
 146     ~ActualParList();
 147     ActualParList* clone() const;
 148     virtual void set_fullname(const string& p_fullname);
 149     virtual void set_my_scope(Scope *p_scope);
 150     size_t get_nof_pars() const { return params.size(); }
 151     void add(ActualPar* p) { params.add(p); }
 152     ActualPar* get_par(size_t i) const { return params[i]; }
 153     /** Checks the embedded recursions within the values and template
 154      * instances of actual parameters. */
 155     void chk_recursions(ReferenceChain& refch);
 156     /** Generates the C++ equivalent of the actual parameter list without
 157      * considering any aliasing between variables and 'in' parameters. */
 158     void generate_code_noalias(expression_struct *expr, FormalParList *p_fpl);
 159     /** Generates the C++ equivalent of the actual parameter list considering
 160      * aliasing problems between the 'in' parameters and 'out'/'inout'
 161      * parameters as well as component variables seen by the called definition.
 162      * Argument \a p_fpl points to the formal parameter list of the referred
 163      * definition if it is known, otherwise it is NULL. Argument \a p_comptype
 164      * points to the component type identified by the 'runs on' clause of the
 165      * referred definition (if exists and relevant for alias analysis,
 166      * otherwise NULL).
 167      * When invoke() is used with FAT types: the special case of 'runs on self'
 168      * has the argument \a p_compself set to true and \a p_comptype is NULL,
 169      * but the component is 'self' or any compatible component. */
 170     void generate_code_alias(expression_struct *expr, FormalParList *p_fpl,
 171       Type *p_comptype, bool p_compself);
 172     /** Walks through the parameter list and appends the initialization
 173      * sequence of all (directly or indirectly) referred non-parameterized
 174      * templates to \a str and returns the resulting string. Flag \a is_local
 175      * indicates whether the respective formal parameter list is in the same
 176      * module as \a this. */
 177     char *rearrange_init_code(char *str, bool is_local);
 178     virtual void dump(unsigned level) const;
 179   };
 180
 181   /** Helper class for the Ttcn::Reference */
 182   class FieldOrArrayRef : public Node, public Location {
 183   public:
 184     enum reftype { FIELD_REF, ARRAY_REF };
 185   private:
 186     reftype ref_type; ///< reference type
 187     /** The stored reference. Owned and destroyed by FieldOrArrayRef */
 188     union {
 189        Identifier *id; ///< name of the field, used by FIELD_REF
 190        Value *arp; ///< value of the index, used by ARRAY_REF
 191     } u;
 192     /** Copy constructor for clone() only */
 193     FieldOrArrayRef(const FieldOrArrayRef& p);
 194     /** %Assignment disabled */
 195     FieldOrArrayRef& operator=(const FieldOrArrayRef& p);
 196   public:
 197     FieldOrArrayRef(Identifier *p_id);
 198     FieldOrArrayRef(Value *p_arp);
 199     ~FieldOrArrayRef();
 200     virtual FieldOrArrayRef* clone() const;
 201     virtual void set_fullname(const string& p_fullname);
 202     virtual void set_my_scope(Scope *p_scope);
 203     reftype get_type() const { return ref_type; }
 204     /** Return the identifier.
 205      * @pre reftype is FIELD_REF, or else FATAL_ERROR */
 206     const Identifier* get_id() const;
 207     /** Returns the value.
 208      * @pre reftype is ARRAY_REF, or else FATAL_ERROR */
 209     Value* get_val() const;
 210     /** Appends the string representation of the sub-reference to \a str. */
 211     void append_stringRepr(string& str) const;
 212   };
 213
 214   /** A vector of FieldOrArrayRef objects */
 215   class FieldOrArrayRefs : public Node {
 216     /** Element holder. This FieldOrArrayRefs object owns the elements
 217      * and will free them in the destructor. */
 218     vector<FieldOrArrayRef> refs;
 219     /** Indicates whether the last array index refers to an element of a
 220      * string value. */
 221     bool refs_str_element;
 222   public:
 223     FieldOrArrayRefs() : Node(), refs(), refs_str_element(false) { }
 224     FieldOrArrayRefs(const FieldOrArrayRefs& p);
 225     ~FieldOrArrayRefs();
 226     FieldOrArrayRefs *clone() const;
 227     virtual void set_fullname(const string& p_fullname);
 228     virtual void set_my_scope(Scope *p_scope);
 229     void add(FieldOrArrayRef *p_ref) { refs.add(p_ref); }
 230     size_t get_nof_refs() const { return refs.size(); }
 231     FieldOrArrayRef* get_ref(size_t i) const { return refs[i]; }
 232     bool has_unfoldable_index() const;
 233     /** Removes (deletes) the first \a n field references. */
 234     void remove_refs(size_t n);
 235     Identifier *remove_last_field();
 236     /** Generates the C++ sub-expression that accesses
 237      * the given sub-references of definition \a ass.
 238      * @param nof_subrefs indicates the number of sub-references
 239      * to generate code from (UINT_MAX means all of them) */
 240     void generate_code(expression_struct *expr, Common::Assignment *ass, size_t nof_subrefs = UINT_MAX);
 241     /** Appends the string representation of sub-references to \a str. */
 242     void append_stringRepr(string &str) const;
 243     bool refers_to_string_element() const { return refs_str_element; }
 244     void set_string_element_ref() { refs_str_element = true; }
 245     void clear_string_element_ref() { refs_str_element = false; }
 246   };
 247
 248   /**
 249    * Base class for all TTCN-3 references.
 250    * Includes the common functionality for parameterized and non-parameterized
 251    * references (e.g. handling of field or array subreferences).
 252    */
 253   class Ref_base : public Ref_simple {
 254   protected: // Ttcn::Reference and Ttcn::Ref_pard need access
 255     Identifier *modid;
 256     /** If id is a NULL pointer all components are stored in subrefs */
 257     Identifier *id;
 258     FieldOrArrayRefs subrefs;
 259     /** Indicates whether the consistency of formal and actual parameter lists
 260      * has been verified. */
 261     bool params_checked;
 262     bool usedInIsbound;
 263     Ref_base(const Ref_base& p);
 264   private:
 265     Ref_base& operator=(const Ref_base& p);
 266   public:
 267     /** Default constructor: sets \a modid and \a id to NULL. Used by
 268      * non-parameterized references only. It is automatically guessed whether
 269      * the first component of \a subrefs is a module id or not. */
 270     Ref_base() : Ref_simple(), modid(0), id(0), subrefs(), params_checked(0)
 271       , usedInIsbound(false) {}
 272     Ref_base(Identifier *p_modid, Identifier *p_id);
 273     ~Ref_base();
 274     virtual Ref_base *clone() const = 0;
 275     virtual void set_fullname(const string& p_fullname);
 276     virtual void set_my_scope(Scope *p_scope);
 277     /** Sets the scope of the base reference to \a p_scope.
 278      * The scope of array indices in \a subrefs remains unchanged. */
 279     void set_base_scope(Scope *p_scope) { Ref_simple::set_my_scope(p_scope); }
 280     virtual bool getUsedInIsbound() {return usedInIsbound;}
 281     virtual void setUsedInIsbound() {usedInIsbound = true;}
 282     Setting *get_refd_setting();
 283     FieldOrArrayRefs *get_subrefs();
 284     /** Appends \a p_ref to the sub-references */
 285     void add(FieldOrArrayRef *p_ref) { subrefs.add(p_ref); }
 286     virtual bool has_single_expr();
 287     virtual void set_code_section(
 288       GovernedSimple::code_section_t p_code_section);
 289     /** Generates the C++ equivalent of the reference (including the parameter
 290      * list and sub-references) as an access to a constant resource.
 291      */
 292     virtual void generate_code_const_ref(expression_struct_t *expr);
 293   };
 294
 295   /**
 296    * TTCN-3 reference without parameters.
 297    * Implements the automatic detection whether the first identifier is a
 298    * module name or not.
 299    */
 300   class Reference : public Ref_base {
 301     ActualParList *parlist;
 302   public:
 303     Reference(Identifier *p_id);
 304     Reference(Identifier *p_modid, Identifier *p_id)
 305       : Ref_base(p_modid, p_id), parlist(0) { }
 306     ~Reference();
 307     virtual Reference *clone() const;
 308     virtual string get_dispname();
 309     virtual Common::Assignment *get_refd_assignment(bool check_parlist = true);
 310     virtual const Identifier* get_modid();
 311     virtual const Identifier* get_id();
 312     /** Checks whether \a this points to a variable or value parameter.
 313      * Returns the type of the respective variable or variable field or NULL
 314      * in case of error. */
 315     Type *chk_variable_ref();
 316     /** Checks if \a this points to a component.
 317      *  Returns the type of the component if so or NULL in case of error. */
 318     Type *chk_comptype_ref();
 319     virtual bool has_single_expr();
 320     virtual void generate_code(expression_struct_t *expr);
 321     /** Generates the C++ equivalent of port references within
 322      * connect/disconnect/map/unmap statements into \a expr.
 323      * Argument \a p_scope shall point to the scope of the statement. */
 324     void generate_code_portref(expression_struct_t *expr, Scope *p_scope);
 325     virtual void generate_code_const_ref(expression_struct_t *expr);
 326     /**
 327      * Generates code for checking if the reference
 328      * and the referred objects are bound or not.*/
 329     void generate_code_ispresentbound(expression_struct_t *expr,
 330       bool is_template, const bool isbound);
 331   private:
 332     /** Detects whether the first identifier in subrefs is a module id */
 333     void detect_modid();
 334   };
 335
 336   /**
 337    * Parameterized TTCN-3 reference
 338    */
 339   class Ref_pard : public Ref_base {
 340     /** "Processed" parameter list, after the semantic check. */
 341     ActualParList parlist;
 342     /** "Raw" parameter list, before the semantic check. */
 343     Ttcn::ParsedActualParameters *params;
 344     /** Used by generate_code_cached(). Stores the generated expression string,
 345       * so it doesn't get regenerated every time. */
 346     char* expr_cache;
 347     /** Copy constructor. Private, used by Ref_pard::clone() only */
 348     Ref_pard(const Ref_pard& p);
 349     /// %Assignment disabled
 350     Ref_pard& operator=(const Ref_pard& p);
 351   public:
 352     /** Constructor
 353      * \param p_modid the module in which it resides
 354      * \param p_id the identifier
 355      * \param p_params parameters. For a function, this is the list constructed
 356      * for the actual parameters.
 357      * */
 358     Ref_pard(Identifier *p_modid, Identifier *p_id,
 359              ParsedActualParameters *p_params);
 360     ~Ref_pard();
 361     virtual Ref_pard *clone() const;
 362     virtual void set_fullname(const string& p_fullname);
 363     virtual void set_my_scope(Scope *p_scope);
 364     string get_dispname();
 365     virtual Common::Assignment *get_refd_assignment(bool check_parlist = true);
 366     virtual const Identifier *get_modid();
 367     virtual const Identifier *get_id();
 368     virtual ActualParList *get_parlist();
 369     /** Checks whether \a this is a correct argument of an activate operation
 370      * or statement. The reference shall point to an altstep with proper
 371      * `runs on' clause and the actual parameters that are passed by reference
 372      * shall not point to local definitions. The function returns true if the
 373      * altstep reference is correct and false in case of any error. */
 374     bool chk_activate_argument();
 375     virtual bool has_single_expr();
 376     virtual void set_code_section(
 377       GovernedSimple::code_section_t p_code_section);
 378     virtual void generate_code          (expression_struct_t *expr);
 379     virtual void generate_code_const_ref(expression_struct_t *expr);
 380
 381     /** Used when an 'all from' is called on a function or parametrised template,
 382       * generate_code would generate new temporaries for the function's parameters
 383       * each call. This method makes sure the same temporaries are used every time
 384       * the function is called in the generated code.
 385       * On the first run calls generate_code and stores its result (only expr.expr
 386       * is cached, since the preamble is only needed after the first call).
 387       * On further runs the cached expression is returned.*/
 388     virtual void generate_code_cached (expression_struct_t *expr);
 389   };
 390
 391   /**
 392   * Class Ttcn::NameBridgingScope.
 393   * This scope unit is NOT A REAL SCOPE UNIT,
 394   * its only purpose is to serve as a bridge with a name between two real scope
 395   * units. All operations are transfered automatically.
 396   */
 397   class NameBridgingScope : public Scope {
 398     virtual string get_scopeMacro_name() const;
 399     virtual NameBridgingScope* clone() const;
 400     virtual Common::Assignment* get_ass_bySRef(Ref_simple *p_ref);
 401   };
 402
 403   /**
 404    * Class Ttcn::RunsOnScope.
 405    * Implements the scoping rules for functions, altsteps and testcases that
 406    * have a 'runs on' clause. First looks for the definitions in the given
 407    * component type first then it searches in its parent scope.
 408    * Note: This scope unit cannot access the parent scope of the component type
 409    * (which is a module Definitions) unless the component type and the
 410    * 'runs on' clause is defined in the same module.
 411    */
 412   class RunsOnScope : public Scope {
 413     /** Points to the component type. */
 414     Type *component_type;
 415     /** Shortcut to the definitions within \a component_type. */
 416     ComponentTypeBody *component_defs;
 417
 418     /** Not implemented. Causes \a FATAL_ERROR. */
 419     RunsOnScope(const RunsOnScope& p);
 420     /** %Assignment not implemented */
 421     RunsOnScope& operator=(const RunsOnScope& p);
 422   public:
 423     RunsOnScope(Type *p_comptype);
 424     virtual RunsOnScope *clone() const;
 425
 426     Type *get_component_type() const { return component_type; }
 427     /** Checks the uniqueness of definitions within \a component_defs and
 428      * reports warnings in case of hiding. */
 429     void chk_uniq();
 430
 431     virtual RunsOnScope *get_scope_runs_on();
 432     virtual Common::Assignment *get_ass_bySRef(Ref_simple *p_ref);
 433     virtual bool has_ass_withId(const Identifier& p_id);
 434   };
 435
 436   /**
 437    * Class Ttcn::Definitions.
 438    *
 439    * Owns the contained Definition objects.
 440    */
 441   class Definitions : public Common::Assignments {
 442   protected:
 443     /** Searchable map of definitions. Used after chk_uniq. */
 444     map<string, Definition> ass_m;
 445     /** Indicates whether the uniqueness of identifiers has been checked. */
 446     bool checked;
 447     /** Vector containing all definitions. Used for building. */
 448     vector<Definition> ass_v;
 449
 450     Definitions(const Definitions& p);
 451   public:
 452
 453     Definitions() : Common::Assignments(), ass_m(), checked(false), ass_v() {}
 454     ~Definitions();
 455     Definitions *clone() const;
 456     virtual void set_fullname(const string& p_fullname);
 457     /** Adds the assignment p_ass and becomes the owner of it.
 458      *  The uniqueness of the identifier is not checked. */
 459     void add_ass(Definition *p_ass);
 460     virtual bool has_local_ass_withId(const Identifier& p_id);
 461     virtual Common::Assignment* get_local_ass_byId(const Identifier& p_id);
 462     virtual size_t get_nof_asss();
 463     virtual Common::Assignment* get_ass_byIndex(size_t p_i);
 464     size_t get_nof_raw_asss();
 465     Definition *get_raw_ass_byIndex(size_t p_i);
 466     /** Checks the uniqueness of identifiers. */
 467     void chk_uniq();
 468     /** Checks all definitions. */
 469     void chk();
 470     /** Checks the definitions within the header of a for loop. */
 471     void chk_for();
 472     /** Sets the genname of embedded definitions using \a prefix. */
 473     void set_genname(const string& prefix);
 474     /** Generates code for all assignments into \a target. */
 475     void generate_code(output_struct *target);
 476     void generate_code(CodeGenHelper& cgh);
 477     char* generate_code_str(char *str);
 478     void ilt_generate_code(ILT *ilt);
 479     /** Prints the contents of all assignments. */
 480     virtual void dump(unsigned level) const;
 481   };
 482
 483   /**
 484    * Class Ttcn::Definitions.
 485    *
 486    * Owns the contained Definition objects.
 487    */
 488 /*  class Definitions : public OtherDefinitions {
 489   public:
 490     Definitions() : OtherDefinitions() {}
 491     ~Definitions();
 492     Definitions *clone() const;
 493     void add_ass(Definition *p_ass);
 494   };*/
 495
 496   /** Represents a TTCN-3 group
 497    *
 498    *  @note a Group is not a Scope */
 499   class Group : public Node, public Location {
 500   private:
 501     Group* parent_group;
 502     WithAttribPath* w_attrib_path;
 503     /// Definitions that belong to this group (directly)
 504     vector<Definition> ass_v;
 505     /// Map the name to the definition (filled in chk_uniq)
 506     map<string,Definition> ass_m;
 507     /// Subgroups
 508     vector<Group> group_v;
 509     /// Map the name to the subgroup
 510     map<string,Group> group_m;
 511     vector<ImpMod> impmods_v;
 512     vector<FriendMod> friendmods_v;
 513     Identifier *id;
 514     bool checked;
 515   private:
 516     /** Copy constructor not implemented */
 517     Group(const Group& p);
 518     /** %Assignment not implemented */
 519     Group& operator=(const Group& p);
 520   public:
 521     Group(Identifier *p_id);
 522     ~Group();
 523     virtual Group* clone() const;
 524     virtual void set_fullname(const string& p_fullname);
 525     void add_ass(Definition* p_ass);
 526     void add_group(Group* p_group);
 527     void set_parent_group(Group* p_parent_group);
 528     Group* get_parent_group() const { return parent_group; }
 529     void set_attrib_path(WithAttribPath* p_path);
 530     const Identifier& get_id() const { return *id; }
 531     void chk_uniq();
 532     virtual void chk();
 533     void add_impmod(ImpMod *p_impmod);
 534     void add_friendmod(FriendMod *p_friendmod);
 535     virtual void dump(unsigned level) const;
 536     void set_with_attr(MultiWithAttrib* p_attrib);
 537     WithAttribPath* get_attrib_path();
 538     void set_parent_path(WithAttribPath* p_path);
 539   };
 540
 541   class ControlPart : public Node, public Location {
 542   private:
 543     StatementBlock* block;
 544     WithAttribPath* w_attrib_path;
 545
 546     NameBridgingScope bridgeScope;
 547
 548     /// Copy constructor disabled
 549     ControlPart(const ControlPart& p);
 550     /// %Assignment disabled
 551     ControlPart& operator=(const ControlPart& p);
 552   public:
 553     ControlPart(StatementBlock* p_block);
 554     ~ControlPart();
 555     virtual ControlPart* clone() const;
 556     virtual void set_fullname(const string& p_fullname);
 557     virtual void set_my_scope(Scope *p_scope);
 558     void chk();
 559     void generate_code(output_struct *target, Module *my_module);
 560     void set_with_attr(MultiWithAttrib* p_attrib);
 561     WithAttribPath* get_attrib_path();
 562     void set_parent_path(WithAttribPath* p_path);
 563     void dump(unsigned level) const;
 564   };
 565
 566   /** A TTCN-3 module */
 567   class Module : public Common::Module {
 568   private:
 569     string *language_spec;
 570     Definitions *asss;
 571     vector<Group> group_v;
 572     map<string, Group> group_m;
 573     WithAttribPath* w_attrib_path;
 574     Imports *imp;
 575     ControlPart* controlpart;
 576     /** For caching the scope objects that are created in
 577      * \a get_runs_on_scope(). */
 578     vector<RunsOnScope> runs_on_scopes;
 579   private:
 580     /** Copy constructor not implemented */
 581     Module(const Module& p);
 582     /** %Assignment not implemented */
 583     Module& operator=(const Module& p);
 584   public:
 585     vector<FriendMod> friendmods_v;
 586     Module(Identifier *p_modid);
 587     ~Module();
 588     void add_group(Group* p_group);
 589     void add_friendmod(FriendMod *p_friendmod);
 590     virtual Module* clone() const;
 591     virtual Common::Assignment* importAssignment(
 592       const Identifier& p_source_modid, const Identifier& p_id) const;
 593     virtual void set_fullname(const string& p_fullname);
 594     virtual Common::Assignments* get_scope_asss();
 595     virtual bool has_imported_ass_withId(const Identifier& p_id);
 596     virtual Common::Assignment* get_ass_bySRef(Ref_simple *p_ref);
 597     virtual bool is_valid_moduleid(const Identifier& p_id);
 598     virtual Common::Assignments *get_asss();
 599     virtual bool exports_sym(const Identifier& p_id);
 600     virtual Type *get_address_type();
 601     virtual void chk_imp(ReferenceChain& refch, vector<Common::Module>& moduleStack);
 602     virtual void chk();
 603   private:
 604     void chk_friends();
 605     void chk_groups();
 606     virtual void get_imported_mods(module_set_t& p_imported_mods);
 607     virtual void generate_code_internal(CodeGenHelper& cgh);
 608   public:
 609     /** Returns a scope that can access the definitions within component type
 610      * \a comptype (which is imported from another module) and its parent scope
 611      * is \a asss. Note that this scope cannot see the scope of \a comptype.
 612      * The function uses \a runs_on_scopes for caching the scope objects: if an
 613      * object has been created for a component type it will be returned later
 614      * instead of creating a new one. */
 615     RunsOnScope *get_runs_on_scope(Type *comptype);
 616     virtual void dump(unsigned level) const;
 617     void set_language_spec(const char *p_language_spec);
 618     void add_ass(Definition* p_ass);
 619     void add_impmod(ImpMod *p_impmod);
 620     void add_controlpart(ControlPart* p_controlpart);
 621     void set_with_attr(MultiWithAttrib* p_attrib);
 622     WithAttribPath* get_attrib_path();
 623     void set_parent_path(WithAttribPath* p_path);
 624     const Imports& get_imports() const { return *imp; }
 625
 626     bool is_visible(const Identifier& id, visibility_t visibility);
 627
 628     /** Generates JSON schema segments for the types defined in the module
 629       * and adds them to the JSON schema parameter. */
 630     void add_types_to_json_schema(JSON_Tokenizer& json);
 631
 632     /** Generates JSON schemas containing references to the types that have JSON
 633       * encoding and/or decoding functions declared in the module. Information
 634       * related to these functions is also inserted after the references. */
 635     void add_func_to_json_schema(map<Type*, JSON_Tokenizer>& json_refs);
 636   };
 637
 638   /**
 639   * Module friendship declaration.
 640   */
 641   class FriendMod : public Node, public Location {
 642   private:
 643     Module *my_mod;
 644     Identifier *modid;
 645     WithAttribPath* w_attrib_path;
 646     Group* parentgroup;
 647     /** Indicates whether this friend module declaration was checked */
 648     bool checked;
 649   private:
 650     /** Copy constructor not implemented. */
 651     FriendMod(const FriendMod&);
 652     /** %Assignment not implemented. */
 653     FriendMod& operator=(const FriendMod&);
 654   public:
 655     FriendMod(Identifier *p_modid);
 656     ~FriendMod();
 657     virtual FriendMod* clone() const;
 658     virtual void set_fullname(const string& p_fullname);
 659     virtual void chk();
 660     void set_my_mod(Module *p_mod) { my_mod = p_mod; }
 661     const Identifier& get_modid() const {return *modid;}
 662     void set_with_attr(MultiWithAttrib* p_attrib);
 663     WithAttribPath* get_attrib_path();
 664     void set_parent_path(WithAttribPath* p_path);
 665     void set_parent_group(Group* p_group);
 666   };
 667
 668
 669   /**
 670    * Imported module. Represents an import statement.
 671    */
 672   class ImpMod : public Node, public Location {
 673   public:
 674     enum imptype_t {
 675       I_UNDEF,
 676       I_ERROR,
 677       I_ALL,
 678       I_IMPORTSPEC,
 679       I_IMPORTIMPORT
 680     };
 681   private:
 682     /** Points to the target (imported) module. This is initially NULL;
 683      *  set during semantic analysis by Ttcn::Imports::chk_uniq() */
 684     Common::Module *mod;
 685     /** The importing module (indirectly our owner) */
 686     Module *my_mod;
 687     /** Import type: "import all", selective import, import of import, etc. */
 688     imptype_t imptype;
 689     /** The name given in the import statement;
 690      *  hopefully an actual module name */
 691     Identifier *modid;
 692     /** The text after "import from name language" */
 693     string *language_spec;
 694     /** Recursive import (already deprecated in v3.2.1) */
 695     bool is_recursive;
 696     WithAttribPath* w_attrib_path;
 697     /** Group in which the import statement is located, if any */
 698     Group* parentgroup;
 699     visibility_t visibility;
 700   private:
 701     /** Copy constructor not implemented. */
 702     ImpMod(const ImpMod&);
 703     /** %Assignment not implemented */
 704     ImpMod& operator=(const ImpMod&);
 705   public:
 706     ImpMod(Identifier *p_modid);
 707     ~ImpMod();
 708     virtual ImpMod* clone() const;
 709     virtual void set_fullname(const string& p_fullname);
 710     virtual void chk();
 711     /** Checks the existence of imported symbols and checks import definitions
 712      * in the imported modules recursively. */
 713     void chk_imp(ReferenceChain& refch, vector<Common::Module>& moduleStack);
 714     void set_my_mod(Module *p_mod) { my_mod = p_mod; }
 715     const Identifier& get_modid() const {return *modid;}
 716     void set_mod(Common::Module *p_mod) { mod = p_mod; }
 717     Common::Module *get_mod() const { return mod; }
 718     /** Returns the imported definition with name \a p_id if it is imported or
 719      * NULL otherwise.
 720      * \a loc is used to report an error if it is needed */
 721     Common::Assignment *get_imported_def(const Identifier& p_source_modid,
 722         const Identifier& p_id, const Location *loc,
 723         ReferenceChain* refch, vector<ImpMod>& usedImpMods) const;
 724     bool has_imported_def(const Identifier& p_source_modid,
 725             const Identifier& p_id, const Location *loc) const;
 726     void set_imptype(imptype_t p_imptype) { imptype = p_imptype; }
 727     void set_language_spec(const char *p_language_spec);
 728     void set_recursive() { is_recursive = true; }
 729     void generate_code(output_struct *target);
 730     virtual void dump(unsigned level) const;
 731     void set_with_attr(MultiWithAttrib* p_attrib);
 732     WithAttribPath* get_attrib_path();
 733     void set_parent_path(WithAttribPath* p_path);
 734     void set_parent_group(Group* p_group);
 735     imptype_t get_imptype() {
 736       return imptype;
 737     }
 738     void set_visibility(visibility_t p_visibility){
 739       visibility = p_visibility;
 740     }
 741     visibility_t get_visibility() const{
 742       return visibility;
 743     }
 744   };
 745
 746   /**
 747    * Class Imports.
 748    */
 749   class Imports : public Node {
 750   private:
 751     /** my module */
 752     Module *my_mod;
 753     /** imported modules */
 754     vector<ImpMod> impmods_v;
 755     /** Indicates whether the import list has been checked. */
 756     bool checked;
 757
 758     friend class ImpMod;
 759   private:
 760     /** Copy constructor not implemented. */
 761     Imports(const Imports&);
 762     /** %Assignment not implemented */
 763     Imports& operator=(const Imports&);
 764   public:
 765     Imports() : Node(), my_mod(0), impmods_v(), checked(false) {}
 766     virtual ~Imports();
 767     virtual Imports* clone() const;
 768     void add_impmod(ImpMod *p_impmod);
 769     void set_my_mod(Module *p_mod);
 770     int get_imports_size() const {return impmods_v.size();}
 771     ImpMod* get_impmod(int index) const {return impmods_v[index];}
 772     /** Checks the existence of imported modules and detects duplicated imports
 773      * from the same module. Initializes \a impmods_m. */
 774     void chk_uniq();
 775     /** Checks the existence of imported symbols and checks import definitions
 776      * in the imported modules recursively. */
 777     void chk_imp(ReferenceChain& refch, vector<Common::Module>& moduleStack);
 778     /** Returns \p true if an imported module with the given name exists,
 779      *  else returns \p false. */
 780     bool has_impmod_withId(const Identifier& p_id) const;
 781     /** Returns whether a definition with identifier \a p_id is imported
 782      * from one or more modules */
 783     bool has_imported_def(const Identifier& p_id, const Location *loc) const;
 784     /** Returns the imported definition with name \a p_id if it is
 785      * unambiguous or NULL otherwise.
 786      * \a loc is used to report an error if it is needed */
 787     Common::Assignment *get_imported_def(const Identifier& p_source_modid,
 788         const Identifier& p_id, const Location *loc, ReferenceChain* refch);
 789     void get_imported_mods(Module::module_set_t& p_imported_mods) const;
 790     void generate_code(output_struct *target);
 791     void generate_code(CodeGenHelper& cgh);
 792     virtual void dump(unsigned level) const;
 793   };
 794
 795   class Definition : public Common::Assignment {
 796   protected: // many derived classes
 797     /** Contains the C++ identifier of the definition. If empty the C++
 798      * identifier is generated from \a id. */
 799     string genname;
 800     /** The group it's in, if any */
 801     Group *parentgroup;
 802     WithAttribPath* w_attrib_path;
 803     ErroneousAttributes* erroneous_attrs; // set by chk_erroneous_attr() or NULL
 804     /** True if function/altstep/default scope, not module scope */
 805     bool local_scope;
 806
 807     Definition(const Definition& p)
 808       : Common::Assignment(p), genname(), parentgroup(0),
 809         w_attrib_path(0), erroneous_attrs(0), local_scope(false)
 810       { }
 811     virtual string get_genname() const;
 812
 813     namedbool has_implicit_omit_attr() const;
 814   private:
 815     /// %Assignment disabled
 816     Definition& operator=(const Definition& p);
 817   public:
 818     Definition(asstype_t p_asstype, Identifier *p_id)
 819       : Common::Assignment(p_asstype, p_id), genname(), parentgroup(0),
 820         w_attrib_path(0), erroneous_attrs(0), local_scope(false)
 821       { }
 822     virtual ~Definition();
 823     virtual Definition* clone() const = 0;
 824     virtual void set_fullname(const string& p_fullname);
 825     virtual bool is_local() const;
 826     /** Sets the visibility type of the definition */
 827     void set_visibility(const visibility_t p_visibility)
 828       { visibilitytype = p_visibility; }
 829     /** Marks the (template) definition as local to a func/altstep/default */
 830     inline void set_local() { local_scope = true; }
 831
 832     void set_genname(const string& p_genname) { genname = p_genname; }
 833     /** Check if two definitions are (almost) identical, the type and dimensions
 834      * must always be identical, the initial values can be different depending
 835      * on the definition type. If error was reported the return value is false.
 836      * The initial values (if applicable) may be present/absent, different or
 837      * unfoldable. The function must be overridden to be used.
 838      */
 839     virtual bool chk_identical(Definition *p_def);
 840     /** Parse and check the erroneous attribute data,
 841       * sets erroneous_attrs member */
 842     void chk_erroneous_attr();
 843     /** This code generation is used when this definition is embedded
 844      * in a statement block. */
 845     virtual char* generate_code_str(char *str);
 846     virtual void ilt_generate_code(ILT *ilt);
 847     /** Generates the C++ initializer sequence for a definition of a component
 848      * type, appends to \a str and returns the resulting string. The function
 849      * is used when \a this is realized using the C++ objects of definition
 850      * \a base_defn inherited from another component type. The function is
 851      * implemented only for those definitions that can appear within component
 852      * types, the generic version causes \a FATAL_ERROR. */
 853     virtual char *generate_code_init_comp(char *str, Definition *base_defn);
 854     virtual void dump_internal(unsigned level) const;
 855     virtual void dump(unsigned level) const;
 856     virtual void set_with_attr(MultiWithAttrib* p_attrib);
 857     virtual WithAttribPath* get_attrib_path();
 858     virtual void set_parent_path(WithAttribPath* p_path);
 859     virtual void set_parent_group(Group* p_group);
 860     virtual Group* get_parent_group();
 861   };
 862
 863   /**
 864    * TTCN-3 type definition (including signatures and port types).
 865    */
 866   class Def_Type : public Definition {
 867   private:
 868     Type *type;
 869
 870     NameBridgingScope bridgeScope;
 871
 872     /** Copy constructor not implemented */
 873     Def_Type(const Def_Type& p);
 874     /** %Assignment disabled */
 875     Def_Type& operator=(const Def_Type& p);
 876   public:
 877     Def_Type(Identifier *p_id, Type *p_type);
 878     virtual ~Def_Type();
 879     virtual Def_Type* clone() const;
 880     virtual void set_fullname(const string& p_fullname);
 881     virtual void set_my_scope(Scope *p_scope);
 882     virtual Setting *get_Setting();
 883     virtual Type *get_Type();
 884     virtual void chk();
 885     virtual void generate_code(output_struct *target, bool clean_up = false);
 886     virtual void generate_code(CodeGenHelper& cgh);
 887     virtual void dump_internal(unsigned level) const;
 888     virtual void set_with_attr(MultiWithAttrib* p_attrib);
 889     virtual WithAttribPath* get_attrib_path();
 890     virtual void set_parent_path(WithAttribPath* p_path);
 891
 892     /** Generates a JSON schema segment for the defined type and inserts it into
 893       * the JSON schema parameter. */
 894     void generate_json_schema(JSON_Tokenizer& json);
 895   };
 896
 897   /**
 898    * TTCN-3 constant definition.
 899    */
 900   class Def_Const : public Definition {
 901   private:
 902     Type *type;
 903     Value *value;
 904     bool value_under_check;
 905
 906     /// Copy constructor disabled
 907     Def_Const(const Def_Const& p);
 908     /// %Assignment disabled
 909     Def_Const& operator=(const Def_Const& p);
 910   public:
 911     Def_Const(Identifier *p_id, Type *p_type, Value *p_value);
 912     virtual ~Def_Const();
 913     virtual Def_Const *clone() const;
 914     virtual void set_fullname(const string& p_fullname);
 915     virtual void set_my_scope(Scope *p_scope);
 916     virtual Setting *get_Setting();
 917     virtual Type *get_Type();
 918     virtual Value *get_Value();
 919     virtual void chk();
 920     virtual bool chk_identical(Definition *p_def);
 921     virtual void generate_code(output_struct *target, bool clean_up = false);
 922     virtual void generate_code(CodeGenHelper& cgh);
 923     virtual char* generate_code_str(char *str);
 924     virtual void ilt_generate_code(ILT *ilt);
 925     virtual char *generate_code_init_comp(char *str, Definition *base_defn);
 926     virtual void dump_internal(unsigned level) const;
 927   };
 928
 929   /**
 930    * TTCN-3 external constant definition.
 931    */
 932   class Def_ExtConst : public Definition {
 933   private:
 934     Type *type;
 935
 936     /// Copy constructor disabled
 937     Def_ExtConst(const Def_ExtConst& p);
 938     /// %Assignment disabled
 939     Def_ExtConst& operator=(const Def_ExtConst& p);
 940   public:
 941     Def_ExtConst(Identifier *p_id, Type *p_type);
 942     virtual ~Def_ExtConst();
 943     virtual Def_ExtConst *clone() const;
 944     virtual void set_fullname(const string& p_fullname);
 945     virtual void set_my_scope(Scope *p_scope);
 946     virtual Type *get_Type();
 947     virtual void chk();
 948     virtual void generate_code(output_struct *target, bool clean_up = false);
 949     virtual void generate_code(CodeGenHelper& cgh);
 950     virtual void dump_internal(unsigned level) const;
 951   };
 952
 953   /**
 954    * TTCN-3 module parameter definition.
 955    */
 956   class Def_Modulepar : public Definition {
 957   private:
 958     Type *type;
 959     Value*    def_value;
 960     /// Copy constructor disabled
 961     Def_Modulepar(const Def_Modulepar& p);
 962     /// %Assignment disabled
 963     Def_Modulepar& operator=(const Def_Modulepar& p);
 964   public:
 965     Def_Modulepar(Identifier *p_id, Type *p_type, Value *p_defval);
 966     virtual ~Def_Modulepar();
 967     virtual Def_Modulepar* clone() const;
 968     virtual void set_fullname(const string& p_fullname);
 969     virtual void set_my_scope(Scope *p_scope);
 970     virtual Type *get_Type();
 971     virtual void chk();
 972     virtual void generate_code(output_struct *target, bool clean_up = false);
 973     virtual void generate_code(CodeGenHelper& cgh);
 974     virtual void dump_internal(unsigned level) const;
 975   };
 976
 977   /**
 978    * TTCN-3 template module parameter definition.
 979    */
 980   class Def_Modulepar_Template : public Definition {
 981   private:
 982     Type *type;
 983     Template* def_template;
 984     /// Copy constructor disabled
 985     Def_Modulepar_Template(const Def_Modulepar_Template& p);
 986     /// %Assignment disabled
 987     Def_Modulepar_Template& operator=(const Def_Modulepar_Template& p);
 988   public:
 989     Def_Modulepar_Template(Identifier *p_id, Type *p_type, Template *p_defval);
 990     virtual ~Def_Modulepar_Template();
 991     virtual Def_Modulepar_Template* clone() const;
 992     virtual void set_fullname(const string& p_fullname);
 993     virtual void set_my_scope(Scope *p_scope);
 994     virtual Type *get_Type();
 995     virtual void chk();
 996     virtual void generate_code(output_struct *target, bool clean_up = false);
 997     virtual void generate_code(CodeGenHelper& cgh);
 998     virtual void dump_internal(unsigned level) const;
 999   };
1000
1001   /**
1002    * Def_Template class represents a template definition.
1003    */
1004   class Def_Template : public Definition {
1005   private:
1006     /* the type of the template */
1007     Type *type;
1008     /** The formal parameter list of the template. It is NULL in case of
1009      * non-parameterized templates. */
1010     FormalParList *fp_list;
1011     /** points to the base template reference in case of modified templates,
1012      * otherwise it is NULL */
1013     Reference *derived_ref;
1014     /** shortcut to the base template in case of modified templates,
1015      * otherwise it is NULL */
1016     Def_Template *base_template;
1017     /** Indicates whether the circular recursion chain of modified templates
1018      * has been checked. */
1019     bool recurs_deriv_checked;
1020     /** the body of the template */
1021     Template *body;
1022     /** template definition level restriction */
1023     template_restriction_t template_restriction;
1024     /** set in chk(), used by code generation,
1025      *  valid if template_restriction!=TR_NONE */
1026     bool gen_restriction_check;
1027
1028     NameBridgingScope bridgeScope;
1029
1030     /// Copy constructor for Def_Template::clone() only
1031     Def_Template(const Def_Template& p);
1032     /// %Assignment disabled
1033     Def_Template& operator=(const Def_Template& p);
1034   public:
1035     Def_Template(template_restriction_t p_template_restriction,
1036       Identifier *p_id, Type *p_type, FormalParList *p_fpl,
1037       Reference *p_derived_ref, Template *p_body);
1038     virtual ~Def_Template();
1039     virtual Def_Template *clone() const;
1040     virtual void set_fullname(const string& p_fullname);
1041     virtual void set_my_scope(Scope *p_scope);
1042     virtual Setting *get_Setting();
1043     virtual Type *get_Type();
1044     virtual Template *get_Template();
1045     virtual FormalParList *get_FormalParList();
1046     virtual void chk();
1047   private:
1048     void chk_modified();
1049     void chk_default() const;
1050     void chk_recursive_derivation();
1051   public:
1052     virtual void generate_code(output_struct *target, bool clean_up = false);
1053     virtual void generate_code(CodeGenHelper& cgh);
1054     virtual char* generate_code_str(char *str);
1055     virtual void ilt_generate_code(ILT *ilt);
1056     virtual void dump_internal(unsigned level) const;
1057     template_restriction_t get_template_restriction()
1058       { return template_restriction; }
1059   };
1060
1061   /**
1062    * Def_Var class represents a variable definition.
1063    */
1064   class Def_Var : public Definition {
1065   private:
1066     Type *type;
1067     /** the initial value: optional and maybe incomplete */
1068     Value *initial_value;
1069
1070     /// Copy constructor disabled
1071     Def_Var(const Def_Var& p);
1072     /// %Assignment disabled
1073     Def_Var& operator=(const Def_Var& p);
1074   public:
1075     Def_Var(Identifier *p_id, Type *p_type, Value *p_initial_value);
1076     virtual ~Def_Var();
1077     virtual Def_Var *clone() const;
1078     virtual void set_fullname(const string& p_fullname);
1079     virtual void set_my_scope(Scope *p_scope);
1080     virtual Type *get_Type();
1081     virtual void chk();
1082     virtual bool chk_identical(Definition *p_def);
1083     virtual void generate_code(output_struct *target, bool clean_up = false);
1084     virtual void generate_code(CodeGenHelper& cgh);
1085     virtual char* generate_code_str(char *str);
1086     virtual void ilt_generate_code(ILT *ilt);
1087     virtual char *generate_code_init_comp(char *str, Definition *base_defn);
1088     virtual void dump_internal(unsigned level) const;
1089   };
1090
1091   /**
1092    * Def_Var_Template class represents a template variable (dynamic template)
1093    * definition.
1094    */
1095   class Def_Var_Template : public Definition {
1096   private:
1097     Type *type;
1098     /** the initial value: optional and maybe incomplete */
1099     Template *initial_value;
1100     /** optional restriction on this variable */
1101     template_restriction_t template_restriction;
1102     /** set in chk(), used by code generation,
1103      *  valid if template_restriction!=TR_NONE */
1104     bool gen_restriction_check;
1105
1106     /// Copy constructor disabled
1107     Def_Var_Template(const Def_Var_Template& p);
1108     /// %Assignment disabled
1109     Def_Var_Template& operator=(const Def_Var_Template& p);
1110   public:
1111     Def_Var_Template(Identifier *p_id, Type *p_type, Template *p_initial_value,
1112                      template_restriction_t p_template_restriction);
1113     virtual ~Def_Var_Template();
1114     virtual Def_Var_Template *clone() const;
1115     virtual void set_fullname(const string& p_fullname);
1116     virtual void set_my_scope(Scope *p_scope);
1117     virtual Type *get_Type();
1118     virtual void chk();
1119     virtual bool chk_identical(Definition *p_def);
1120     virtual void generate_code(output_struct *target, bool clean_up = false);
1121     virtual void generate_code(CodeGenHelper& cgh);
1122     virtual char* generate_code_str(char *str);
1123     virtual void ilt_generate_code(ILT *ilt);
1124     virtual char *generate_code_init_comp(char *str, Definition *base_defn);
1125     virtual void dump_internal(unsigned level) const;
1126     template_restriction_t get_template_restriction()
1127       { return template_restriction; }
1128   };
1129
1130   /**
1131    * Def_Timer class represents a single timer declaration (e.g. in a
1132    * TTCN component type).
1133    */
1134   class Def_Timer : public Definition {
1135   private:
1136     /** Describes the dimensions of a timer array. It is NULL in case
1137      * of single timer instance. */
1138     ArrayDimensions *dimensions;
1139     /** Default duration of the timers. It can be either a single
1140      * float value or an array of floats. If it is NULL the timer(s)
1141      * has no default duration. */
1142     Value *default_duration;
1143
1144     /// Copy constructor disabled
1145     Def_Timer(const Def_Timer& p);
1146     /// %Assignment disabled
1147     Def_Timer& operator=(const Def_Timer& p);
1148   public:
1149     Def_Timer(Identifier *p_id, ArrayDimensions *p_dims, Value *p_dur)
1150       : Definition(A_TIMER, p_id), dimensions(p_dims),
1151       default_duration(p_dur) { }
1152     virtual ~Def_Timer();
1153     virtual Def_Timer *clone() const;
1154     virtual void set_fullname(const string& p_fullname);
1155     virtual void set_my_scope(Scope *p_scope);
1156     virtual ArrayDimensions *get_Dimensions();
1157     virtual void chk();
1158     virtual bool chk_identical(Definition *p_def);
1159     /** Returns false if it is sure that the timer referred by array
1160      * indices \a p_subrefs does not have a default
1161      * duration. Otherwise it returns true. Argument \a p_subrefs
1162      * might be NULL when examining a single timer. */
1163     bool has_default_duration(FieldOrArrayRefs *p_subrefs);
1164   private:
1165     /** Checks if the value \a dur is suitable as duration for a single
1166      * timer. */
1167     void chk_single_duration(Value *dur);
1168     /** Checks if the value \a dur is suitable as duration for a timer
1169      * array.  The function calls itself recursively, argument \a
1170      * start_dim shall be zero when called from outside. */
1171     void chk_array_duration(Value *dur, size_t start_dim = 0);
1172   public:
1173     virtual void generate_code(output_struct *target, bool clean_up = false);
1174     virtual void generate_code(CodeGenHelper& cgh);
1175   private:
1176     /** Generates a C++ code fragment that sets the default duration
1177      * of a timer array. The generated code is appended to \a str and
1178      * the resulting string is returned. The equivalent C++ object of
1179      * timer array is named \a object_name, the array value containing
1180      * the default durations is \a dur. The function calls itself
1181      * recursively, argument \a start_dim shall be zero when called
1182      * from outside. */
1183     char *generate_code_array_duration(char *str, const char *object_name,
1184       Value *dur, size_t start_dim = 0);
1185   public:
1186     virtual char* generate_code_str(char *str);
1187     virtual void ilt_generate_code(ILT *ilt);
1188     virtual char *generate_code_init_comp(char *str, Definition *base_defn);
1189     virtual void dump_internal(unsigned level) const;
1190   };
1191
1192   /**
1193    * Def_Port class represents a port declaration (in a component type).
1194    */
1195   class Def_Port : public Definition {
1196   private:
1197     /** Contains a reference to a TTCN-3 port type */
1198     Reference *type_ref;
1199     /** Points to the object describing the port type.
1200      *
1201      * Derived from \a type_ref during Def_Port::chk().
1202      * It can be NULL in case of any error (e.g. the reference points to a
1203      * non-existent port type or the referenced entity is not a port type. */
1204     Type *port_type;
1205     /** Describes the dimensions of a port array.
1206      * It is NULL in case of single port instance. */
1207     ArrayDimensions *dimensions;
1208
1209     /// Copy constructor disabled
1210     Def_Port(const Def_Port& p);
1211     /// %Assignment disabled
1212     Def_Port& operator=(const Def_Port& p);
1213   public:
1214     /** Constructor
1215      *
1216      * @param p_id identifier (must not be NULL), the name of the port
1217      * @param p_tref type reference (must not be NULL)
1218      * @param p_dims array dimensions (NULL for a single port instance)
1219      */
1220     Def_Port(Identifier *p_id, Reference *p_tref, ArrayDimensions *p_dims);
1221     virtual ~Def_Port();
1222     virtual Def_Port *clone() const;
1223     virtual void set_fullname(const string& p_fullname);
1224     virtual void set_my_scope(Scope *p_scope);
1225     /** Get the \a port_type
1226      *
1227      * @pre chk() has been called (because it computes \a port_type)
1228      */
1229     virtual Type *get_Type();
1230     virtual ArrayDimensions *get_Dimensions();
1231     virtual void chk();
1232     virtual bool chk_identical(Definition *p_def);
1233     virtual void generate_code(output_struct *target, bool clean_up = false);
1234     virtual void generate_code(CodeGenHelper& cgh);
1235     virtual char *generate_code_init_comp(char *str, Definition *base_defn);
1236     virtual void dump_internal(unsigned level) const;
1237   };
1238
1239   /**
1240    * Common base class for function and external function definitions.
1241    */
1242   class Def_Function_Base : public Definition {
1243   public:
1244     enum prototype_t {
1245       PROTOTYPE_NONE, /**< no prototype(...) attribute */
1246       PROTOTYPE_CONVERT, /**< attribute prototype(convert) */
1247       PROTOTYPE_FAST, /**< attribute prototype(fast) */
1248       PROTOTYPE_BACKTRACK, /**< attribute prototype(backtrack) */
1249       PROTOTYPE_SLIDING /**< attribute prototype(sliding) */
1250     };
1251   protected: // Def_Function and Def_ExtFunction need access
1252     /** The formal parameter list of the function. It is never NULL even if
1253      * the function has empty parameter list. Owned. */
1254     FormalParList *fp_list;
1255     /** The return type of the function or NULL in case of no return type.
1256      *  Owned. */
1257     Type *return_type;
1258     /** Identifier of the enc/dec API implemented by the function */
1259     prototype_t prototype;
1260     /** Shortcut to the input type if the function implements one of the
1261      * enc/dec APIs or NULL otherwise. Not owned. */
1262     Type *input_type;
1263     /** Shortcut to the output type if the function implements one of the
1264      * enc/dec APIs or NULL otherwise. Not owned */
1265     Type *output_type;
1266     /** optional template restriction on return template value */
1267     template_restriction_t template_restriction;
1268
1269     static asstype_t determine_asstype(bool is_external, bool has_return_type,
1270       bool returns_template);
1271     /// Copy constructor disabled
1272     Def_Function_Base(const Def_Function_Base& p);
1273     /// %Assignment disabled
1274     Def_Function_Base& operator=(const Def_Function_Base& p);
1275   public:
1276     /** Constructor.
1277      *
1278      * @param is_external true if external function (the derived type is
1279      *        Def_ExtFunction), false if a TTCN-3 function (Def_Function)
1280      * @param p_id the name of the function
1281      * @param p_fpl formal parameter list
1282      * @param p_return_type return type (may be NULL)
1283      * @param returns_template true if the return is a template
1284      * @param p_template_restriction restriction type
1285      */
1286     Def_Function_Base(bool is_external, Identifier *p_id,
1287       FormalParList *p_fpl, Type *p_return_type, bool returns_template,
1288       template_restriction_t p_template_restriction);
1289     virtual ~Def_Function_Base();
1290     virtual void set_fullname(const string& p_fullname);
1291     virtual void set_my_scope(Scope *p_scope);
1292     virtual Type *get_Type();
1293     virtual FormalParList *get_FormalParList();
1294     prototype_t get_prototype() const { return prototype; }
1295     void set_prototype(prototype_t p_prototype) { prototype = p_prototype; }
1296     const char *get_prototype_name() const;
1297     void chk_prototype();
1298     Type *get_input_type();
1299     Type *get_output_type();
1300     template_restriction_t get_template_restriction()
1301       { return template_restriction; }
1302   };
1303
1304   /**
1305    * Def_Function class represents a function definition.
1306    */
1307   class Def_Function : public Def_Function_Base {
1308   private:
1309     /** The 'runs on' clause (i.e. a reference to a TTCN-3 component type)
1310      * It is NULL if the function has no 'runs on' clause. */
1311     Reference *runs_on_ref;
1312     /** Points to the object describing the component type referred by
1313      * 'runs on' clause.
1314      * It is NULL if the function has no 'runs on' clause or \a runs_on_ref is
1315      * erroneous. */
1316     Type *runs_on_type;
1317     /** The body of the function */
1318     StatementBlock *block;
1319     /** Indicates whether the function is startable. That is, it can be
1320      * launched as PTC behaviour as argument of a start test component
1321      * statement. */
1322     bool is_startable;
1323     /** Opts out from location information */
1324     bool transparent;
1325
1326     NameBridgingScope bridgeScope;
1327
1328     /// Copy constructor disabled
1329     Def_Function(const Def_Function& p);
1330     /// %Assignment disabled
1331     Def_Function& operator=(const Def_Function& p);
1332   public:
1333     /** Constructor for a TTCN-3 function definition
1334      *
1335      * Called from a single location in compiler.y
1336      *
1337      * @param p_id function name
1338      * @param p_fpl formal parameter list
1339      * @param p_runs_on_ref "runs on", else NULL
1340      * @param p_return_type return type, may be NULL
1341      * @param returns_template true if the return value is a template
1342      * @param p_template_restriction restriction type
1343      * @param p_block the body of the function
1344      */
1345     Def_Function(Identifier *p_id, FormalParList *p_fpl,
1346                  Reference *p_runs_on_ref, Type *p_return_type,
1347                  bool returns_template,
1348                  template_restriction_t p_template_restriction,
1349                  StatementBlock *p_block);
1350     virtual ~Def_Function();
1351     virtual Def_Function *clone() const;
1352     virtual void set_fullname(const string& p_fullname);
1353     virtual void set_my_scope(Scope *p_scope);
1354     virtual Type *get_RunsOnType();
1355     /** Returns a scope that can access the definitions within component type
1356      * \a comptype and its parent is \a parent_scope.*/
1357     RunsOnScope *get_runs_on_scope(Type *comptype);
1358     virtual void chk();
1359     /** Checks and returns whether the function is startable.
1360      * Reports the appropriate error message(s) if not. */
1361     bool chk_startable();
1362
1363     bool is_transparent() const { return transparent; }
1364
1365     virtual void generate_code(output_struct *target, bool clean_up = false);
1366     virtual void generate_code(CodeGenHelper& cgh);
1367     virtual void dump_internal(unsigned level) const;
1368
1369     virtual void set_parent_path(WithAttribPath* p_path);
1370   };
1371
1372   /** RAII class for transparent functions.
1373    *
1374    *  Calls to TTCN_Location::update_lineno are written by Ttcn::Statement
1375    *  by calling Common::Location::update_location_object. These calls
1376    *  need to be removed inside transparent functions.
1377    *
1378    *  It is difficult (impossible) for a Statement to navigate up in the AST
1379    *  to the function/altstep/testcase/control part that contains it;
1380    *  instead, the Def_Function sets a static flag inside Common::Location
1381    *  that says "you are inside a transparent function" while
1382    *  Def_Function::generate_code function runs.
1383    */
1384   class transparency_holder {
1385     bool old_transparency;
1386   public:
1387     /** Sets Common::Location::transparency (but remembers its old vaue)
1388      *
1389      * @param df the function definition
1390      */
1391     transparency_holder(const Def_Function &df)
1392     : old_transparency(Common::Location::transparency)
1393     { Common::Location::transparency = df.is_transparent(); }
1394
1395     /** Restores the value of Common::Location::transparency */
1396     ~transparency_holder()
1397     { Common::Location::transparency = old_transparency; }
1398   };
1399
1400   /**
1401    * Def_ExtFunction class represents an external function definition.
1402    */
1403   class Def_ExtFunction : public Def_Function_Base {
1404   public:
1405     enum ExternalFunctionType_t {
1406       EXTFUNC_MANUAL, /**< written manually by the user */
1407       EXTFUNC_ENCODE, /**< automatically generated encoder function */
1408       EXTFUNC_DECODE /**< automatically generated decoder function */
1409     };
1410   private:
1411     ExternalFunctionType_t function_type;
1412     Type::MessageEncodingType_t encoding_type;
1413     string *encoding_options;
1414     Ttcn::ErrorBehaviorList *eb_list;
1415     Ttcn::PrintingType *json_printing;
1416     /// Copy constructor disabled
1417     Def_ExtFunction(const Def_ExtFunction& p);
1418     /// %Assignment disabled
1419     Def_ExtFunction& operator=(const Def_ExtFunction& p);
1420   public:
1421     /** Constructor for an external function definition
1422      *
1423      * Called from a single location in compiler.y
1424      *
1425      * @param p_id the name
1426      * @param p_fpl formal parameters
1427      * @param p_return_type the return type
1428      * @param returns_template true if it returns a template
1429      * @param p_template_restriction restriction type
1430      */
1431     Def_ExtFunction(Identifier *p_id, FormalParList *p_fpl,
1432       Type *p_return_type, bool returns_template,
1433       template_restriction_t p_template_restriction)
1434       : Def_Function_Base(true, p_id, p_fpl, p_return_type, returns_template,
1435           p_template_restriction),
1436       function_type(EXTFUNC_MANUAL), encoding_type(Type::CT_UNDEF),
1437       encoding_options(0), eb_list(0), json_printing(0) { }
1438     ~Def_ExtFunction();
1439     virtual Def_ExtFunction *clone() const;
1440     virtual void set_fullname(const string& p_fullname);
1441     void set_encode_parameters(Type::MessageEncodingType_t p_encoding_type,
1442       string *p_encoding_options);
1443     void set_decode_parameters(Type::MessageEncodingType_t p_encoding_type,
1444       string *p_encoding_options);
1445     void add_eb_list(Ttcn::ErrorBehaviorList *p_eb_list);
1446     ExternalFunctionType_t get_function_type() const { return function_type; }
1447   private:
1448     void chk_function_type();
1449     void chk_allowed_encode();
1450   public:
1451     virtual void chk();
1452   private:
1453     char *generate_code_encode(char *str);
1454     char *generate_code_decode(char *str);
1455   public:
1456     virtual void generate_code(output_struct *target, bool clean_up = false);
1457     /// Just a shim for code splitting
1458     virtual void generate_code(CodeGenHelper& cgh);
1459     virtual void dump_internal(unsigned level) const;
1460
1461     /** For JSON encoding and decoding functions only
1462       * Generates a JSON schema segment containing a reference to the encoded
1463       * type's schema and any information required to recreate this function.
1464       * If the schema with the reference already exists, the function's info is
1465       * inserted in the schema. */
1466     void generate_json_schema_ref(map<Type*, JSON_Tokenizer>& json_refs);
1467   };
1468
1469   /**
1470    * Represents an altstep definition.
1471    */
1472   class Def_Altstep : public Definition {
1473   private:
1474     /** The formal parameter list of the altstep. It is never NULL even if
1475      * the altstep has no parameters. */
1476     FormalParList *fp_list;
1477     /** The 'runs on' clause (i.e. a reference to a TTCN-3 component type)
1478      * It is NULL if the altstep has no 'runs on' clause. */
1479     Reference *runs_on_ref;
1480     /** Points to the object describing the component type referred by
1481      * 'runs on' clause.
1482      * It is NULL if the altstep has no 'runs on' clause or \a runs_on_ref is
1483      * erroneous. */
1484     Type *runs_on_type;
1485     StatementBlock *sb; /**< contains the local definitions */
1486     AltGuards *ags;
1487
1488     NameBridgingScope bridgeScope;
1489
1490     /// Copy constructor disabled
1491     Def_Altstep(const Def_Altstep& p);
1492     /// %Assignment disabled
1493     Def_Altstep& operator=(const Def_Altstep& p);
1494   public:
1495     Def_Altstep(Identifier *p_id, FormalParList *p_fpl,
1496                 Reference *p_runs_on_ref, StatementBlock *p_sb,
1497                 AltGuards *p_ags);
1498     virtual ~Def_Altstep();
1499     virtual Def_Altstep *clone() const;
1500     virtual void set_fullname(const string& p_fullname);
1501     virtual void set_my_scope(Scope *p_scope);
1502     virtual Type *get_RunsOnType();
1503     virtual FormalParList *get_FormalParList();
1504     /** Returns a scope that can access the definitions within component type
1505      * \a comptype and its parent is \a parent_scope.*/
1506     RunsOnScope *get_runs_on_scope(Type *comptype);
1507     virtual void chk();
1508     virtual void generate_code(output_struct *target, bool clean_up = false);
1509     virtual void generate_code(CodeGenHelper& cgh);
1510     virtual void dump_internal(unsigned level) const;
1511
1512     virtual void set_parent_path(WithAttribPath* p_path);
1513   };
1514
1515   /**
1516    * Represents an testcase definition.
1517    */
1518   class Def_Testcase : public Definition {
1519   private:
1520     /** The formal parameter list of the testcase. It is never NULL even if
1521      * the testcase has no parameters. */
1522     FormalParList *fp_list;
1523     /** The 'runs on' clause (i.e. a reference to a TTCN-3 component type)
1524      *  It is never NULL. */
1525     Reference *runs_on_ref;
1526     /** Points to the object describing the component type referred by
1527      * 'runs on' clause. It is NULL only if \a runs_on_ref is erroneous. */
1528     Type *runs_on_type;
1529     /** The 'system' clause (i.e. a reference to a TTCN-3 component type)
1530      *  It is NULL if the testcase has no 'system' clause. */
1531     Reference *system_ref;
1532     /** Points to the object describing the component type referred by
1533      * 'system' clause. It is NULL if the testcase has no 'system' clause or
1534      * \a system_ref is erroneous. */
1535     Type *system_type;
1536     StatementBlock *block;
1537
1538     NameBridgingScope bridgeScope;
1539
1540     /// Copy constructor disabled
1541     Def_Testcase(const Def_Testcase& p);
1542     /// %Assignment disabled
1543     Def_Testcase& operator=(const Def_Testcase& p);
1544   public:
1545     Def_Testcase(Identifier *p_id, FormalParList *p_fpl,
1546                  Reference *p_runs_on_ref, Reference *p_system_ref,
1547                  StatementBlock *p_block);
1548     virtual ~Def_Testcase();
1549     virtual Def_Testcase *clone() const;
1550     virtual void set_fullname(const string& p_fullname);
1551     virtual void set_my_scope(Scope *p_scope);
1552     virtual Type *get_RunsOnType();
1553     Type *get_SystemType();
1554     virtual FormalParList *get_FormalParList();
1555     /** Returns a scope that can access the definitions within component type
1556      * \a comptype and its parent is \a parent_scope.*/
1557     RunsOnScope *get_runs_on_scope(Type *comptype);
1558     virtual void chk();
1559     virtual void generate_code(output_struct *target, bool clean_up = false);
1560     virtual void generate_code(CodeGenHelper& cgh);
1561     virtual void dump_internal(unsigned level) const;
1562
1563     virtual void set_parent_path(WithAttribPath* p_path);
1564   };
1565
1566   /** General class to represent formal parameters. The inherited
1567    * attribute asstype carries the kind and direction of the
1568    * parameter. */
1569   class FormalPar : public Definition {
1570   private:
1571     Type *type;
1572     /** Default value of the parameter (optional). If \a checked flag is true
1573      *  then field \a ap is used otherwise \a ti is active. */
1574     union {
1575       TemplateInstance *ti;
1576       ActualPar *ap;
1577     } defval;
1578     /** Points to the formal parameter list that \a this belongs to. */
1579     FormalParList *my_parlist;
1580     /** Flag that indicates whether the value of the parameter is overwritten
1581      * within the function/altstep/testcase body.
1582      * Used only in case of `in' value or template parameters. */
1583     bool used_as_lvalue;
1584     /** restriction on template value */
1585     template_restriction_t template_restriction;
1586     /** normal or lazy evaluation parametrization should be used */
1587     bool lazy_eval;
1588
1589     /// Copy constructor disabled
1590     FormalPar(const FormalPar& p);
1591     /// %Assignment disabled
1592     FormalPar& operator=(const FormalPar& p);
1593   public:
1594     FormalPar(asstype_t p_asstype, Type *p_type, Identifier* p_name,
1595       TemplateInstance *p_defval, bool p_lazy_eval=false);
1596     FormalPar(asstype_t p_asstype,
1597       template_restriction_t p_template_restriction,
1598       Type *p_type, Identifier* p_name, TemplateInstance *p_defval,
1599       bool p_lazy_eval=false);
1600     FormalPar(asstype_t p_asstype, Identifier* p_name,
1601       TemplateInstance *p_defval);
1602     ~FormalPar();
1603     virtual FormalPar *clone() const;
1604     virtual void set_fullname(const string& p_fullname);
1605     virtual void set_my_scope(Scope *p_scope);
1606     /** Always true. Formal parameters are considered as local definitions
1607      * even if their scope is the module definitions. */
1608     virtual bool is_local() const;
1609     virtual Type *get_Type();
1610     virtual void chk();
1611     bool has_defval() const;
1612     bool has_notused_defval() const;
1613     /** Get the default value.
1614      * \pre chk() has been called (checked==true) */
1615     ActualPar *get_defval() const;
1616     void set_defval(ActualPar *defpar);
1617     void set_my_parlist(FormalParList *p_parlist) { my_parlist = p_parlist; }
1618     FormalParList *get_my_parlist() const { return my_parlist; }
1619     ActualPar *chk_actual_par(TemplateInstance *actual_par,
1620       Type::expected_value_t exp_val);
1621   private:
1622     ActualPar *chk_actual_par_value(TemplateInstance *actual_par,
1623       Type::expected_value_t exp_val);
1624     ActualPar *chk_actual_par_template(TemplateInstance *actual_par,
1625       Type::expected_value_t exp_val);
1626     ActualPar *chk_actual_par_by_ref(TemplateInstance *actual_par,
1627       bool is_template, Type::expected_value_t exp_val);
1628     ActualPar *chk_actual_par_timer(TemplateInstance *actual_par,
1629       Type::expected_value_t exp_val);
1630     ActualPar *chk_actual_par_port(TemplateInstance *actual_par,
1631       Type::expected_value_t exp_val);
1632   public:
1633     /** Checks whether the value of the parameter may be modified in the body
1634      * of the parameterized definition (in assignment, port redirect or passing
1635      * it further as 'out' or 'inout' parameter). Applicable to `in' value or
1636      * template parameters only. Note that formal parameters of templates cannot
1637      * be modified. If the modification is allowed a flag is set, which is
1638      * considered at C++ code generation. Argument \a p_loc is used for error
1639      * reporting. */
1640     virtual void use_as_lvalue(const Location& p_loc);
1641     bool get_used_as_lvalue() const { return used_as_lvalue; }
1642     /** Generates the C++ objects that represent the default value for the
1643      * parameter (if present). */
1644     virtual void generate_code_defval(output_struct *target, bool clean_up = false);
1645     /** Generates the C++ equivalent of the formal parameter, appends it to
1646      * \a str and returns the resulting string. */
1647     char *generate_code_fpar(char *str);
1648     /** Generates a C++ statement that defines an object (variable) for the
1649      * formal parameter, appends it to \a str and returns the resulting
1650      * string. The name of the object is constructed from \a p_prefix and the
1651      * parameter identifier.
1652      * The \a refch parameter is needed when the code for start_ptc_function is
1653      * generated, because reference is generated in case of inout parameters. */
1654     char *generate_code_object(char *str, const char *p_prefix,
1655       char refch = '&');
1656     /** Generates a C++ statement that instantiates a shadow object for the
1657      * parameter when necessary. It is used when the value of an 'in' value or
1658      * template parameter is overwritten within the function body. */
1659     char *generate_shadow_object(char *str) const;
1660    /** Generates a C++ statement that calls a function that sets the parameter unbound
1661      *  It is used when the value of an 'out' value  */
1662     char *generate_code_set_unbound(char *str) const;
1663     virtual void dump_internal(unsigned level) const;
1664     template_restriction_t get_template_restriction()
1665       { return template_restriction; }
1666     virtual bool get_lazy_eval() const { return lazy_eval; }
1667     // code generation: get the C++ string that refers to the formal parameter
1668     // adds a casting to data type if wrapped into a lazy param
1669     string get_reference_name(Scope* scope) const;
1670   };
1671
1672   /** Class to represent a list of formal parameters. Owned by a
1673    *  Def_Template, Def_Function_Base, Def_Altstep or Def_Testcase. */
1674   class FormalParList : public Scope, public Location {
1675   private:
1676     vector<FormalPar> pars_v;
1677     /** Map names to the formal parameters in pars_v. Filled by
1678      *  FormalParList::chk*/
1679     map<string, FormalPar> pars_m;
1680     /** Indicates the minimal number of actual parameters that must be present
1681      * in parameterized references. Could be less than the size of pars_v
1682      * if some parameters have default values. */
1683     size_t min_nof_pars;
1684     /** Points to the definition that the parameter list belongs to. */
1685     Definition *my_def;
1686     bool checked;
1687     bool is_startable;
1688
1689     /** Copy constructor. For FormalParList::clone() only. */
1690     FormalParList(const FormalParList& p);
1691     /** %Assignment disallowed. */
1692     FormalParList& operator=(const FormalParList& p);
1693   public:
1694     FormalParList() : Scope(), Location(), pars_v(), pars_m()
1695     , min_nof_pars(0), my_def(0), checked(false), is_startable(false) {}
1696     ~FormalParList();
1697     virtual FormalParList *clone() const;
1698     virtual void set_fullname(const string& p_fullname);
1699     /** Sets the parent scope and the scope of parameters to \a p_scope. */
1700     virtual void set_my_scope(Scope *p_scope);
1701     void set_my_def(Definition *p_def) { my_def = p_def; }
1702     Definition *get_my_def() const { return my_def; }
1703     void add_fp(FormalPar *p_fp);
1704     size_t get_nof_fps() const { return pars_v.size(); }
1705     bool has_notused_defval() const;
1706     bool has_only_default_values() const;
1707     bool has_fp_withName(const Identifier& p_name);
1708     FormalPar *get_fp_byName(const Identifier& p_name);
1709     FormalPar *get_fp_byIndex(size_t n) const { return pars_v[n]; }
1710     bool get_startability();
1711     virtual Common::Assignment *get_ass_bySRef(Common::Ref_simple *p_ref);
1712     virtual bool has_ass_withId(const Identifier& p_id);
1713     /** Checks the parameter list, which belongs to definition of type
1714      * \a deftype. */
1715     void chk(Definition::asstype_t deftype);
1716     void chk_noLazyParams();
1717     /** Checks the parameter list for startability: reports error if the owner
1718      * function cannot be started on a PTC. Used by functions and function
1719      * types. Parameter \a p_what shall contain "Function" or "Function type",
1720      * \a p_name shall contain the name of the function or function type. */
1721     void chk_startability(const char *p_what, const char *p_name);
1722     /** Checks the compatibility of two formal parameter list.
1723      *  They are compatible if every parameter is compatible, has the same
1724      *    attribute, and name */
1725     void chk_compatibility(FormalParList* p_fp_list, const char* where);
1726     /** Checks the parsed actual parameters in \a p_tis against \a this.
1727      * The actual parameters that are the result of transformation are added to
1728      * \a p_aplist (which is usually empty when this function is called).
1729      * \return true in case of any error, false after a successful check. */
1730     bool chk_actual_parlist(TemplateInstances *p_tis, ActualParList *p_aplist);
1731     /** Fold named parameters into the unnamed (order-based) param list.
1732      *
1733      * Named parameters are checked against the formal parameters.
1734      * Found ones are transferred into the unnamed param list at the
1735      * appropriate index.
1736      *
1737      * @param p_paps actual parameters from the parser (Bison); contains
1738      *        both named and unnamed parameters
1739      * @param p_aplist actual parameters
1740      * @return the result of calling chk_actual_parlist, above:
1741      *         true if error, false if the check is successful
1742      */
1743     bool fold_named_and_chk(ParsedActualParameters *p_paps, ActualParList *p_aplist);
1744     bool chk_activate_argument(ActualParList *p_aplist,
1745                                const char* p_description);
1746     void set_genname(const string& p_prefix);
1747     /** Generates the C++ equivalent of the formal parameter list, appends it
1748      * to \a str and returns the resulting string. */
1749     char *generate_code(char *str);
1750     /** Generates the C++ objects that represent the default values for the
1751      * parameters (if present). */
1752     void generate_code_defval(output_struct *target);
1753     /** Generates a C++ actual parameter list for wrapper functions, appends it
1754      * to \a str and returns the resulting string. It contains the
1755      * comma-separated list of parameter identifiers prefixed by \a p_prefix. */
1756     char *generate_code_actual_parlist(char *str, const char *p_prefix);
1757     /** Generates a C++ code sequence that defines an object (variable) for
1758      * each formal parameter (which is used in wrapper functions), appends it
1759      * to \a str and returns the resulting string. The name of each object is
1760      * constructed from \a p_prefix and the parameter identifier.
1761      * The \a refch parameter is needed when the code for start_ptc_function is
1762      * generated, because reference is generated in case of inout parameters. */
1763     char *generate_code_object(char *str, const char *p_prefix,
1764       char refch = '&');
1765     /** Generates the C++ shadow objects for all parameters. */
1766     char *generate_shadow_objects(char *str) const;
1767     char *generate_code_set_unbound(char *str) const;
1768     void dump(unsigned level) const;
1769   };
1770
1771 } // namespace Ttcn
1772
1773 #endif // _Ttcn_AST_HH