| 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 COMPTYPE_HH_ |
| 9 | #define COMPTYPE_HH_ |
| 10 | |
| 11 | #include "Setting.hh" |
| 12 | |
| 13 | struct output_struct_t; |
| 14 | |
| 15 | namespace Ttcn { |
| 16 | class Definition; |
| 17 | class WithAttribPath; |
| 18 | class Reference; |
| 19 | } |
| 20 | |
| 21 | namespace Common { |
| 22 | |
| 23 | class CompTypeRefList; |
| 24 | |
| 25 | /** Class to represent the definition of a component type */ |
| 26 | class ComponentTypeBody : public Scope, public Location { |
| 27 | public: |
| 28 | /** represents the check state of this component |
| 29 | * every check increments the value */ |
| 30 | enum check_state_t { |
| 31 | CHECK_INITIAL, /**< initial state before checks */ |
| 32 | CHECK_WITHATTRIB, /**< with attribute checked, |
| 33 | set by chk_extends_attr() */ |
| 34 | CHECK_EXTENDS, /**< component extension checked, |
| 35 | set by chk_extends() */ |
| 36 | CHECK_DEFUNIQ, /**< definitions id uniqueness checked, |
| 37 | set by chk_defs_uniq() */ |
| 38 | CHECK_OWNDEFS, /**< own definitions checked, |
| 39 | set by chk_my_defs() */ |
| 40 | CHECK_EXTDEFS, /**< definitions inherited by attribute checked, |
| 41 | set by chk_attr_ext_defs() */ |
| 42 | CHECK_FINAL /**< everything was checked, set by chk() */ |
| 43 | }; |
| 44 | private: |
| 45 | /** Identifier of this component */ |
| 46 | const Identifier *comp_id; |
| 47 | /** the Type that contains this, needed to reach w_attrib_path */ |
| 48 | Type *my_type; |
| 49 | /** tells which checks have already been performed */ |
| 50 | check_state_t check_state; |
| 51 | /** true when chk() is running */ |
| 52 | bool checking; |
| 53 | /** Vector containing own definitions. Used for building. */ |
| 54 | vector<Ttcn::Definition> def_v; |
| 55 | /** component references from the "extends" part or NULL if there were no */ |
| 56 | CompTypeRefList *extends_refs; |
| 57 | /** component references from the extends attribute or NULL */ |
| 58 | CompTypeRefList *attr_extends_refs; |
| 59 | /** map of own definitions equal to inherited by extension attribute |
| 60 | * needed to initialize the the value with own value, |
| 61 | * pointers to the defs are owned by def_v */ |
| 62 | map<string, Ttcn::Definition> orig_defs_m; |
| 63 | /** map of my and inherited definitions */ |
| 64 | map<string, Ttcn::Definition> all_defs_m; |
| 65 | /** compatibility map for is_compatible() function, filled in chk(), |
| 66 | * all components inherited along pure extends-keyword path have the value |
| 67 | * equal to the key, others have NULL value */ |
| 68 | map<ComponentTypeBody*, ComponentTypeBody> compatible_m; |
| 69 | void init_compatibility(CompTypeRefList *crl, bool is_standard_extends); |
| 70 | private: |
| 71 | /** Copy constructor not implemented */ |
| 72 | ComponentTypeBody(const ComponentTypeBody& p); |
| 73 | /** Assignment not implemented */ |
| 74 | ComponentTypeBody& operator=(const ComponentTypeBody& p); |
| 75 | public: |
| 76 | ComponentTypeBody() |
| 77 | : Scope(), comp_id(0), my_type(0), check_state(CHECK_INITIAL), |
| 78 | checking(false), def_v(), extends_refs(0), attr_extends_refs(0), |
| 79 | orig_defs_m(), all_defs_m(), compatible_m() { } |
| 80 | ~ComponentTypeBody(); |
| 81 | ComponentTypeBody *clone() const; |
| 82 | |
| 83 | void set_id(const Identifier *p_id) { comp_id = p_id; } |
| 84 | Identifier const * get_id() const { return comp_id; } |
| 85 | void set_my_type(Type *p_type) { my_type = p_type; } |
| 86 | Type* get_my_type() { return my_type; } |
| 87 | |
| 88 | virtual void set_fullname(const string& p_fullname); |
| 89 | virtual void set_my_scope(Scope *p_scope); |
| 90 | |
| 91 | bool has_local_ass_withId(const Identifier& p_id); |
| 92 | Assignment* get_local_ass_byId(const Identifier& p_id); |
| 93 | bool has_ass_withId(const Identifier& p_id); |
| 94 | bool is_own_assignment(const Assignment* p_ass); |
| 95 | size_t get_nof_asss(); |
| 96 | Assignment* get_ass_byIndex(size_t p_i); |
| 97 | virtual Assignment *get_ass_bySRef(Ref_simple *p_ref); |
| 98 | |
| 99 | void add_extends(CompTypeRefList *p_crl); |
| 100 | |
| 101 | /** Returns if this component is compatible with the given other component. |
| 102 | * This component is compatible with other component if this extends the |
| 103 | * other component (with standard extends or with extension attribute) |
| 104 | * directly or this extends a component which is compatible with other */ |
| 105 | bool is_compatible(ComponentTypeBody *other); |
| 106 | /** Adds the assignment p_ass and becomes the owner of it. |
| 107 | * The uniqueness of the identifier is not checked. */ |
| 108 | void add_ass(Ttcn::Definition *p_ass); |
| 109 | /** Prints the contents of the component. */ |
| 110 | void dump(unsigned level) const; |
| 111 | private: |
| 112 | void chk_extends_attr(); |
| 113 | public: |
| 114 | /** Check component extends recursions (extends keyword and attribute) */ |
| 115 | void chk_recursion(ReferenceChain& refch); |
| 116 | private: |
| 117 | void collect_defs_from_standard_extends(); |
| 118 | void collect_defs_from_attribute_extends(); |
| 119 | /** Checks the AST for correct component extensions. */ |
| 120 | void chk_extends(); |
| 121 | /** Checks definition id uniqueness */ |
| 122 | void chk_defs_uniq(); |
| 123 | /** Checks all own definitions */ |
| 124 | void chk_my_defs(); |
| 125 | /** Checks definitions inherited with attribute extends */ |
| 126 | void chk_attr_ext_defs(); |
| 127 | public: |
| 128 | /** perform all checks */ |
| 129 | void chk(check_state_t required_check_state = CHECK_FINAL); |
| 130 | /** Sets the genname of embedded definitions using \a prefix. */ |
| 131 | void set_genname(const string& prefix); |
| 132 | void generate_code(output_struct_t *target); |
| 133 | /** Generates a pair of C++ strings that contain the module name and name |
| 134 | * of the component type and appends them to \a str. */ |
| 135 | char *generate_code_comptype_name(char *str); |
| 136 | |
| 137 | void set_parent_path(Ttcn::WithAttribPath* p_path); |
| 138 | }; |
| 139 | |
| 140 | /** Class to represent a list of references to components */ |
| 141 | class CompTypeRefList : public Node, public Location { |
| 142 | private: |
| 143 | bool checked; |
| 144 | vector<Ttcn::Reference> comp_ref_v; |
| 145 | /** Pointers to ComponentTypeBody objects in the AST, filled by chk() */ |
| 146 | map<ComponentTypeBody*,Ttcn::Reference> comp_body_m; |
| 147 | /** Contains the keys of comp_body_m in the order determined by comp_ref_v, |
| 148 | * used to perform checks in deterministic order ( the order of keys in |
| 149 | * comp_body_m is platform dependent */ |
| 150 | vector<ComponentTypeBody> comp_body_v; |
| 151 | /** Copy constructor not implemented */ |
| 152 | CompTypeRefList(const CompTypeRefList& p); |
| 153 | /** Assignment disabled */ |
| 154 | CompTypeRefList& operator=(const CompTypeRefList& p); |
| 155 | public: |
| 156 | CompTypeRefList() |
| 157 | : checked(false), comp_ref_v(), comp_body_m(), comp_body_v() { } |
| 158 | ~CompTypeRefList(); |
| 159 | CompTypeRefList *clone() const; |
| 160 | void add_ref(Ttcn::Reference *p_ref); |
| 161 | void dump(unsigned level) const; |
| 162 | virtual void set_fullname(const string& p_fullname); |
| 163 | void chk_uniq(); |
| 164 | void chk(ComponentTypeBody::check_state_t required_check_state); |
| 165 | void chk_recursion(ReferenceChain& refch); |
| 166 | virtual void set_my_scope(Scope *p_scope); |
| 167 | |
| 168 | /** utility functions to access comp_body_m */ |
| 169 | size_t get_nof_comps(); |
| 170 | ComponentTypeBody *get_nth_comp_body(size_t i); |
| 171 | Ttcn::Reference *get_nth_comp_ref(size_t i); |
| 172 | bool has_comp_body(ComponentTypeBody *cb); |
| 173 | }; |
| 174 | |
| 175 | } /* namespace Common */ |
| 176 | #endif /* COMPTYPE_HH_ */ |