NewLang Project
Yet another programm language
Loading...
Searching...
No Matches
types.cpp
Go to the documentation of this file.
1
2#include "types.h"
3#include "term.h"
4#include "object.h"
5
6using namespace newlang;
7
8//ObjPtr newlang::ObjCreateInteger(int64_t value) {
9// return Obj::CreateValue(value);
10//}
11//
12//ObjPtr newlang::ObjCreateNumber(double value) {
13// return Obj::CreateValue(value);
14//}
15//
16//ObjPtr newlang::ObjCreateRational(const Rational &value) {
17// return Obj::CreateRational(value);
18//}
19//
20//ObjPtr newlang::ObjCreateString(const std::string_view str) {
21// return Obj::CreateString(str);
22//}
23//
24//ObjPtr newlang::ObjCreateWString(const std::wstring_view str) {
25// return Obj::CreateString(str);
26//}
27//
28//ObjPtr newlang::ObjCreatePointer(void * ptr) {
29// return Obj::CreatePointer(ptr);
30//}
32// *
33// *
34// */
35//VarGuard::VarGuard(const VarGuard *copy, const std::chrono::milliseconds & timeout_duration)
36//: m_var(copy ? copy->m_var : nullptr), m_edit_mode(copy ? copy->m_edit_mode : false) {
37// if (!m_var) {
38// LOG_RUNTIME("Fail take!");
39// }
40// if (m_var->sync) {
41// m_is_locked = m_var->sync->SyncLock(m_edit_mode, timeout_duration);
42// }
43//}
44//
45//VarGuard::VarGuard(const VarData *var, bool edit_mode, const std::chrono::milliseconds & timeout_duration)
46//: m_var(const_cast<VarData *> (var)), m_edit_mode(edit_mode) {
47// if (!m_var) {
48// LOG_RUNTIME("Fail take!");
49// }
50// if (m_var->sync) {
51// m_is_locked = m_var->sync->SyncLock(edit_mode, timeout_duration);
52// }
53//}
54//
55//VarGuard::~VarGuard() {
56// if (m_var && m_var->sync && m_is_locked) {
57// m_var->sync->SyncUnLock();
58// }
59//}
60//
62// *
63// *
64// */
65//VarData VarData::Copy(const std::chrono::milliseconds & timeout_duration) const {
66// if (owner) {
67// return VarData(owner); // copy shared_ptr
68// } else if (is_taked()) {
69// return VarData(VarGuard(std::get<std::unique_ptr < VarGuard >> (data).get(), timeout_duration));
70// } else if (std::holds_alternative<std::monostate>(data)) {
71// return VarData(std::monostate());
72// } else if (std::holds_alternative<std::shared_ptr < VarData >> (data)) {
73// return VarData(std::get<std::shared_ptr < VarData >> (data));
74// } else if (std::holds_alternative<std::weak_ptr < VarData >> (data)) {
75// return VarData(std::get<std::weak_ptr < VarData >> (data));
76// } else if (std::holds_alternative<ObjPtr>(data)) {
77// return VarData(std::get<ObjPtr>(data));
78// } else if (std::holds_alternative<int64_t>(data)) {
79// return VarData(std::get<int64_t>(data));
80// } else if (std::holds_alternative<double>(data)) {
81// return VarData(std::get<double>(data));
82// } else if (std::holds_alternative<std::string>(data)) {
83// return VarData(std::get<std::string>(data));
84// } else if (std::holds_alternative<std::wstring>(data)) {
85// return VarData(std::get<std::wstring>(data));
86// } else if (std::holds_alternative<void *>(data)) {
87// return VarData(std::get<void *>(data));
88// } else if (std::holds_alternative<Rational>(data)) {
89// return VarData(std::get<Rational>(data));
90// } else {
91// LOG_RUNTIME("Fail copy index '%zu'!", data.index());
92// }
93//}
94//
95//VarData VarData::Ref() const {
96// if (owner) {
97// return VarData(std::weak_ptr<VarData>(owner));
98// } else if (std::holds_alternative<std::shared_ptr < VarData >> (data)) {
99// return VarData(std::weak_ptr<VarData>(std::get<std::shared_ptr < VarData >> (data)));
100// } else if (std::holds_alternative<std::weak_ptr < VarData >> (data)) {
101// return VarData(std::get<std::weak_ptr < VarData >> (data));
102// } else if (is_taked()) {
103// return std::get<std::unique_ptr < VarGuard >> (data)->m_var->Ref();
104// } else {
105// LOG_RUNTIME("Fail logic Ref()!");
106// }
107//}
108//
109//std::unique_ptr<VarGuard> VarData::MakeTake(bool edit_mode, const std::chrono::milliseconds & timeout_duration) const {
110// if (owner) {
111// return std::make_unique<VarGuard>(this, edit_mode, timeout_duration);
112// } else if (std::holds_alternative<std::shared_ptr < VarData >> (data)) {
113// return std::make_unique<VarGuard>(std::get<std::shared_ptr < VarData >> (data).get(), edit_mode, timeout_duration);
114// } else if (std::holds_alternative<std::weak_ptr < VarData >> (data)) {
115// return std::make_unique<VarGuard>(std::get<std::weak_ptr < VarData >> (data).lock().get(), edit_mode, timeout_duration);
116// } else {
117// LOG_RUNTIME("Fail logic Take()!");
118// }
119//}
120//
121//void VarData::set(const ObjPtr & new_value, bool edit_mode, const std::chrono::milliseconds & timeout_duration) {
122// ASSERT(new_value);
123// std::unique_ptr<VarGuard> self_taken;
124// VarGuard * var_tacken = is_taked() ? std::get<std::unique_ptr < VarGuard >> (data).get() : nullptr;
125// if (!var_tacken) {
126// self_taken = MakeTake(edit_mode, timeout_duration);
127// var_tacken = self_taken.get();
128// }
129// if (!var_tacken || !var_tacken->m_var) {
130// LOG_RUNTIME("No data borrowed!");
131// }
132//
133// if (std::holds_alternative<ObjPtr>(var_tacken->m_var->data)) {
134// std::get<ObjPtr>(var_tacken->m_var->data)->SetValue_(new_value);
135// } else if (std::holds_alternative<int64_t>(var_tacken->m_var->data)) {
136// var_tacken->m_var->data = static_cast<int64_t> (*new_value);
137// } else if (std::holds_alternative<double>(var_tacken->m_var->data)) {
138// var_tacken->m_var->data = static_cast<double> (*new_value);
139// } else if (std::holds_alternative<std::string>(var_tacken->m_var->data)) {
140// var_tacken->m_var->data = static_cast<std::string> (*new_value);
141// } else if (std::holds_alternative<std::wstring>(var_tacken->m_var->data)) {
142// var_tacken->m_var->data = static_cast<std::wstring> (*new_value);
143// } else if (std::holds_alternative<void *>(var_tacken->m_var->data)) {
144// var_tacken->m_var->data = static_cast<void *> (*new_value);
145// } else if (std::holds_alternative<Rational>(var_tacken->m_var->data)) {
146// var_tacken->m_var->data = *new_value->GetValueAsRational();
147// } else if (std::holds_alternative<std::monostate>(var_tacken->m_var->data)) {
148// LOG_RUNTIME("Object not initialized!");
149// } else {
150// LOG_RUNTIME("Fail logic set object or incompatible data type index '%zu'!", var_tacken->m_var->data.index());
151// }
152//}
153//
154//template <typename T>
155//typename std::enable_if<!std::is_same<T, ObjPtr>::value, void>::type
156//VarData::set(const T & new_value, bool edit_mode, const std::chrono::milliseconds & timeout_duration) {
157// std::unique_ptr<VarGuard> self_taken;
158// VarGuard * var_tacken = is_taked() ? std::get<std::unique_ptr < VarGuard >> (data).get() : nullptr;
159// if (!var_tacken) {
160// self_taken = MakeTake(edit_mode, timeout_duration);
161// var_tacken = self_taken.get();
162// }
163// if (!var_tacken || !var_tacken->m_var) {
164// LOG_RUNTIME("No data borrowed!");
165// }
166// if (std::holds_alternative<T>(var_tacken->m_var->data)) {
167// var_tacken->m_var->data = new_value;
168// } else if (std::holds_alternative<ObjPtr>(var_tacken->m_var->data)) {
169// std::get<ObjPtr>(var_tacken->m_var->data)->SetValue_(new_value);
170// } else if (std::holds_alternative<std::monostate>(var_tacken->m_var->data)) {
171// LOG_RUNTIME("Object not initialized!");
172// } else {
173// LOG_RUNTIME("Fail logic set object or incompatible data type index '%zu'!", var_tacken->m_var->data.index());
174// }
175//}
176//
177//__attribute__ ((weak)) VarData & VarData::__iadd__(VarData &self, const VarData &other) {
178// std::unique_ptr<VarGuard> self_taken;
179// VarGuard * var_tacken = self.is_taked() ? std::get<std::unique_ptr < VarGuard >> (self.data).get() : nullptr;
180// if (!var_tacken) {
181// self_taken = self.MakeTake(true, Sync::SyncWithoutWait);
182// var_tacken = self_taken.get();
183// }
184// if (!var_tacken || !var_tacken->m_var) {
185// LOG_RUNTIME("No data borrowed!");
186// }
187// if (!var_tacken->m_edit_mode) {
188// LOG_RUNTIME("Take not edit mode!");
189// }
190//
191// if (std::holds_alternative<int64_t>(var_tacken->m_var->data)) {
192// var_tacken->m_var->data = (std::get<int64_t>(var_tacken->m_var->data) + other.get<int64_t>());
193// } else if (std::holds_alternative<double>(var_tacken->m_var->data)) {
194// var_tacken->m_var->data = (std::get<double>(var_tacken->m_var->data) + other.get<double>());
195// } else if (std::holds_alternative<std::string>(var_tacken->m_var->data)) {
196// std::get<std::string>(var_tacken->m_var->data) += other.get<std::string>();
197// } else if (std::holds_alternative<std::wstring>(var_tacken->m_var->data)) {
198// std::get<std::wstring>(var_tacken->m_var->data) += other.get<std::wstring>();
199// } else if (std::holds_alternative<Rational>(var_tacken->m_var->data)) {
200// std::get<Rational>(var_tacken->m_var->data) += other.get<Rational>();
201// } else if (std::holds_alternative<ObjPtr>(var_tacken->m_var->data)) {
202// *std::get<ObjPtr>(var_tacken->m_var->data) += other.get<ObjPtr>();
203// } else if (std::holds_alternative<std::monostate>(var_tacken->m_var->data)) {
204// LOG_RUNTIME("Object not initialized!");
205// } else {
206// LOG_RUNTIME("Fail logic set object or incompatible data type index '%zu'!", var_tacken->m_var->data.index());
207// }
208// return self;
209//}
210//
211//ObjPtr VarData::Object(VariableType pair) {
212// return VarData::Object(pair ? &pair->var : nullptr);
213//}
214//
215//ObjPtr VarData::Object(VarData * variable) {
216// if (!variable || std::holds_alternative<std::monostate>(variable->data)) {
217// LOG_RUNTIME("Object not initialized!");
218// } else if (std::holds_alternative<int64_t>(variable->data)) {
219// return Obj::CreateValue(std::get<int64_t>(variable->data));
220// } else if (std::holds_alternative<double>(variable->data)) {
221// return Obj::CreateValue(std::get<double>(variable->data));
222// } else if (std::holds_alternative<std::string>(variable->data)) {
223// return Obj::CreateString(std::get<std::string>(variable->data));
224// } else if (std::holds_alternative<std::wstring>(variable->data)) {
225// return Obj::CreateString(std::get<std::wstring>(variable->data));
226// } else if (std::holds_alternative<Rational>(variable->data)) {
227// return Obj::CreateRational(std::get<Rational>(variable->data));
228// } else if (std::holds_alternative<ObjPtr>(variable->data)) {
229// return std::get<ObjPtr>(variable->data);
230// }
231// LOG_RUNTIME("Fail create Object or incompatible data type index '%zu'!", variable->data.index());
232//}
233
234/*
235 *
236 *
237 */
238
239bool GlobalObjects::RegisterObject(bool only_new, const std::string_view name, TermPtr term, Variable var) {
240
241 ASSERT(term || var);
242
243 GlobalObjects::iterator found = find(name.begin());
244 VariablePair * exist = (found != end()) ? &found->second : nullptr;
245
246 if (only_new && exist && !exist->var.is_undefined()) {
247 NL_MESSAGE(LOG_LEVEL_INFO, term, "Name '%s' already exist!", name.begin());
248 return false;
249 } else {
250 if (found != end() && exist && !exist->var.is_undefined()) {
251 if (!Term::CheckTermEq(exist->term, term)) {
252 NL_MESSAGE(LOG_LEVEL_INFO, term, "The prototype '%s' differs from the first definition '%s'!",
253 name.begin(), exist->term->toString().c_str());
254 return false;
255 }
256 if (exist && exist->var.is_undefined()){
257
258 exist->var = var;
259
260 // found->second.data.data.swap(glob.var.data);
261 // found->second.data.owner.swap(glob.var.owner);
262 // found->second.data.sync.swap(glob.var.sync); //= std::move(glob.data);
263 }
264 } else {
265 insert_or_assign(name.begin(), VariablePair{term, var});
266 }
267 }
268 return true;
269}
270
271//VarData & GlobalObjects::GetObject(const std::string_view name) {
272// VarPair *glob = FindObject(name);
273// if (glob) {
274// return glob->var;
275// }
276// LOG_RUNTIME("Global name '%s' not found!", name.begin());
277//}
278//
279//TermPtr GlobalObjects::FindTerm(const std::string_view name) {
280// VarPair *glob = FindObject(name);
281// if (glob) {
282// return glob->term.lock();
283// }
284// return nullptr;
285//}
286
287VariablePair * GlobalObjects::FindObject(const std::string_view name) {
288
289 auto found = find(name.begin());
290 if (found == end()) {
291 std::string glob_name("::");
292 glob_name.append(name.begin());
293 found = find(glob_name);
294 // if (found == end()) {
295 // glob_name.append("::");
296 // found = find(glob_name);
297 // if (found == end()) {
298 // glob_name.append(":");
299 // found = find(glob_name);
300 // }
301 // }
302 }
303
304 if (found != end()) {
305 //@todo Check typename ????
306 // if (!found->second.lock()) {
307 // LOG_RUNTIME("Name '%s' not implemented!", name.begin());
308 // }
309 return &found->second;
310 }
311 return nullptr;
312}
313
314std::string GlobalObjects::Dump(const std::string_view filter, const char delim) {
315 StringMatcher mather(filter.begin(), delim);
316 std::string result;
317 for (auto &elem : * this) {
318 if (mather.MatchesName(elem.first)) {
319 if (!result.empty()) {
320 result += ", ";
321 }
322 result += elem.first;
323 if (!filter.empty()) {
324 result += "=";
325 result += elem.second.var.is_undefined() ? "undefined" : elem.second.var.GetValueAsObject()->toString();
326 }
327 result += " ";
328 }
329 }
330 if (!filter.empty()) {
331 result.insert(0, "'\n");
332 result.insert(0, filter.begin());
333 result.insert(0, "Apply filter: '");
334 }
335 if (!result.empty()) {
336 result += '\n';
337 }
338 return result;
339}
newlang::GlobalObjects::RegisterObject
bool RegisterObject(bool only_new, const std::string_view name, TermPtr term, Variable var)
Definition types.cpp:239
newlang::GlobalObjects::Dump
std::string Dump(const std::string_view filter="", const char delim=';')
Definition types.cpp:314
newlang::GlobalObjects::FindObject
VariablePair * FindObject(const std::string_view name)
Definition types.cpp:287
newlang::StringMatcher::MatchesName
bool MatchesName(const std::string &name) const
Definition logger.h:253
newlang::Term::CheckTermEq
static bool CheckTermEq(const TermPtr &term, const TermPtr &proto, bool type=false, RuntimePtr rt=nullptr)
Definition term.cpp:112
newlang::Variable::is_undefined
bool is_undefined() const
Definition variable.h:591
result
int result
Definition lexer.l:367
LOG_LEVEL_INFO
#define LOG_LEVEL_INFO
Definition logger.h:87
ASSERT
#define ASSERT(condition)
Definition logger.h:60
newlang
Definition nlc.h:59
newlang::TermPtr
std::shared_ptr< Term > TermPtr
Definition variable.h:33
NL_MESSAGE
#define NL_MESSAGE(level, term, format,...)
Definition types.h:318
Generated by doxygen 1.11.0