Commit | Line | Data |
---|---|---|
970ed795 EL |
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_ */ |