NewLang Project
Yet another programm language
Loading...
Searching...
No Matches
variable.cpp
Go to the documentation of this file.
1#include "runtime.h"
2#include "variable.h"
3
4using namespace newlang;
5
6/*
7 *
8 *
9 */
10std::string newlang::utf8_encode(const std::wstring wstr) {
11 std::string utf8line;
12
13 if (wstr.empty()) {
14 return utf8line;
15 }
16 utf8line = std::wstring_convert < std::codecvt_utf8<wchar_t>>().to_bytes(wstr.c_str());
17 return utf8line;
18}
19
20// Convert an UTF8 string to a wide Unicode String
21
22std::wstring newlang::utf8_decode(const std::string str) {
23 std::wstring wide_line;
24
25 if (str.empty()) {
26 return wide_line;
27 }
28 wide_line = std::wstring_convert < std::codecvt_utf8<wchar_t>>().from_bytes(str.c_str());
29 return wide_line;
30}
31
32/*
33 *
34 *
35 */
36
37std::shared_ptr<Sync> Sync::CreateSync(const TermPtr &term) {
38 if (term && term->m_ref) {
39 return CreateSync(term->m_ref->m_text);
40 }
41 return std::shared_ptr<Sync>(nullptr);
42}
43
44std::shared_ptr<Sync> Sync::CreateSync(const std::string_view ref) {
45 if (!ref.empty()) {
46 RefType ref_type = RefTypeFromString(ref);
47 if (!(ref_type == RefType::Value || ref_type == RefType::Shared || ref_type == RefType::SharedConst)) {
48 return std::make_shared<Sync>(ref_type);
49 }
50 }
51 return std::shared_ptr<Sync>(nullptr);
52}
53
54VariableTaken::VariableTaken(const Variable &var, bool edit_mode,
55 const std::chrono::milliseconds & timeout_duration,
56 const std::string_view msg, const std::source_location & loc)
57: std::runtime_error(msg.begin()), variable(const_cast<Variable *> (&var)) {
58
59 if (std::holds_alternative<VariableShared> (var) && std::get<VariableShared>(var).sync) {
60 std::get<VariableShared>(var).sync->m_data = std::get<VariableShared>(var).data;
61 variable = std::get<VariableShared>(var).sync;
62 // sync = const_cast<std::shared_ptr<Sync> *>(&std::get<VariableShared>(var).sync);
63 } else if (std::holds_alternative<VariableWeak>(var) && std::get<VariableWeak>(var).sync) {
64 variable = std::get<VariableWeak>(var).sync;
65 // sync = const_cast<std::shared_ptr<Sync> *>(&std::get<VariableWeak>(var).sync);
66 } else if (std::holds_alternative<VariableTaken> (var)) {
67 variable = std::get<VariableTaken>(var).variable;
68 // sync = std::get<VariableGuard>(var).sync;
69 }
70
71 if (std::holds_alternative<std::shared_ptr < Sync >> (variable) && !std::get<std::shared_ptr < Sync >> (variable)->SyncLock(edit_mode, timeout_duration)) {
72 // Redefine string message in std::runtime_error
73 static_cast<std::runtime_error&> (*this) = std::runtime_error(
74 MakeTimeoutMessage(var, edit_mode, timeout_duration, msg, loc));
75
76 // Throw self
77 throw *this;
78 }
79 if (std::holds_alternative<VariableWeak> (var)) {
80 std::get<std::shared_ptr < Sync >> (variable)->m_data = std::get<VariableWeak>(var).weak.lock();
81 if (!std::get<std::shared_ptr < Sync >> (variable)->m_data) {
82 throw std::bad_weak_ptr();
83 }
84 // std::bad_weak_ptr is the type of the object thrown as exceptions by the constructors of std::shared_ptr
85 // that take std::weak_ptr as the argument, when the std::weak_ptr refers to an already deleted object.
86 }
87}
88
89VariableTaken::~VariableTaken() {
90 if (std::holds_alternative<std::shared_ptr < Sync >> (variable)) {
91 std::get<std::shared_ptr < Sync >> (variable)->SyncUnLock();
92 }
93}
94
95std::string VariableTaken::MakeTimeoutMessage(const Variable & var, bool edit_mode,
96 const std::chrono::milliseconds & timeout_duration,
97 const std::string_view message, const std::source_location & location) {
98
99 std::string result(message.begin());
100
101 if (message.empty()) {
102 result += "VariableGuard error for ";
103 result += edit_mode ? "write " : "read ";
104 result += " or timeout ";
105 result += std::to_string(timeout_duration.count());
106 result += " milliseconds at: ";
107
108 result += location.file_name();
109 result += "(";
110 result += std::to_string(location.line());
111 result += ":";
112 result += std::to_string(location.column());
113 result += ") `";
114 result += location.function_name();
115 result += "` ";
116
117 result += var.toString();
118 result += "\n";
119 }
120
121 result += "Stack trace:\n";
122 int counter = 0;
123 for (const auto& entry : std::stacktrace()) {
124 result += std::to_string(counter);
125 if (entry) {
126 result += "# ";
127 if (entry.description().empty()) {
128 result += " ";
129 } else {
130 result += entry.description();
131 }
132 result += " at ";
133 if (entry.source_file().empty()) {
134 result += " ";
135 } else {
136 result += entry.source_file();
137 }
138 result += " :";
139 result += std::to_string(entry.source_line());
140 }
141 }
142 return result;
143}
144
145
146/*
147 *
148 *
149 */
150//std::unique_ptr<Sync> Variable::MakeSync(const std::string_view ref) {
151// if (ref.empty() || ref[0] == '*') {
152// return nullptr;
153// }
154// RefType ref_type = RefTypeFromString(ref);
155// ASSERT(ref_type != RefType::Value);
156// return std::make_unique<Sync>(ref_type);
157//}
158//
159//std::unique_ptr<Sync> Variable::MakeSync(const TermPtr &term) {
160// if (!isShared(term)) {
161// return nullptr;
162// }
163// return MakeSync(term->m_ref->m_text);
164//}
165
166bool Variable::isShared(const TermPtr &term) {
167 return term && term->m_ref && !term->m_ref->m_text.empty();
168}
169
170
171
172
173
174#pragma clang diagnostic push
175#pragma clang diagnostic error "-Wswitch"
176
177ObjPtr Variable::Object(VariablePair * pair) {
178 return Variable::Object(pair ? &pair->var : nullptr);
179}
180
181ObjPtr Variable::Object(Variable * variable) {
182 if (!variable || std::holds_alternative<std::monostate>(*variable)) {
183 LOG_RUNTIME("Object not initialized (%s)!", variable ? "monostate" : "nullptr");
184 } else if (std::holds_alternative<int64_t>(*variable)) {
185 return Obj::CreateValue(std::get<int64_t>(*variable));
186 } else if (std::holds_alternative<double>(*variable)) {
187 return Obj::CreateValue(std::get<double>(*variable));
188 } else if (std::holds_alternative<std::string>(*variable)) {
189 return Obj::CreateString(std::get<std::string>(*variable));
190 } else if (std::holds_alternative<std::wstring>(*variable)) {
191 return Obj::CreateString(std::get<std::wstring>(*variable));
192 } else if (std::holds_alternative<Rational>(*variable)) {
193 return Obj::CreateRational(std::get<Rational>(*variable));
194 } else if (std::holds_alternative<ObjPtr>(*variable)) {
195 return std::get<ObjPtr>(*variable);
196 }
197 LOG_RUNTIME("Fail create Object or incompatible data type index '%zu' (%s)!", variable->index(), VariableCaseToString(variable->index()));
198}
199
200Variable Variable::Ref(const std::string_view ref) const {
201// if (!is_taked()) {
202// LOG_RUNTIME("Variable not taked!");
203// }
204// switch (static_cast<VariableCase> (this->index())) {
205// case VariableCase::INTEGER:
206// case VariableCase::DOUBLE:
207// return GetValueAsInteger();
208// case VariableCase::RATIONAL:
209// return !std::get<Rational>(*this).GetAsBoolean();
210//
211// case VariableCase::SHARED:
212// return std::get<VariableShared> (*this).data->GetValueAsBoolean();
213//
214// case VariableCase::TAKEN:
215// return (*std::get<VariableTaken> (*this)).GetValueAsBoolean();
216//
217// case VariableCase::OBJECT:
218// return std::get<ObjPtr>(*this)->GetValueAsInteger();
219// // case VariableCase::POINTER:
220// // return std::get<void *>(*this);
221//
222// case VariableCase::STRING:
223// return !std::get<std::string>(*this).empty();
224// case VariableCase::WSTRING:
225// return !std::get<std::wstring>(*this).empty();
226//
227// case VariableCase::EMPTY:
228// case VariableCase::WEAK:
229// }
230 LOG_RUNTIME("Data type '%s' %d incompatible to boolean type!", VariableCaseToString(this->index()), static_cast<int> (this->index()));
231
232
233 // if (owner) {
234 // return VarData(std::weak_ptr<VarData>(owner));
235 // } else if (std::holds_alternative<std::shared_ptr < VarData >> (data)) {
236 // return VarData(std::weak_ptr<VarData>(std::get<std::shared_ptr < VarData >> (data)));
237 // } else if (std::holds_alternative<std::weak_ptr < VarData >> (data)) {
238 // return VarData(std::get<std::weak_ptr < VarData >> (data));
239 // } else if (is_taked()) {
240 // return std::get<std::unique_ptr < VarGuard >> (data)->m_var->Ref();
241 // } else {
242 // LOG_RUNTIME("Fail logic Ref()!");
243 // }
244}
245
246//VariableGuard Variable::MakeTake(bool edit_mode, const std::chrono::milliseconds & timeout_duration) const {
247// if (sync) {
248// return VariableGuard(*this, edit_mode, timeout_duration);
249// } else if (std::holds_alternative<VariableGuard> (*this)) {
250// return std::get<VariableGuard> (*this);
251// } else if (std::holds_alternative<std::shared_ptr < Variable >> (*this)) {
252// return VariableGuard(std::get<std::shared_ptr < Variable >> (*this).get(), edit_mode, timeout_duration);
253// } else if (std::holds_alternative<std::weak_ptr < Variable >> (*this)) {
254// return VariableGuard(std::get<std::weak_ptr < Variable >> (*this).lock().get(), edit_mode, timeout_duration);
255// } else {
256// LOG_RUNTIME("Fail logic Take()!");
257// }
258//}
259
260/*
261 *
262 *
263 */
264
265bool Variable::GetValueAsBoolean() const {
266 if (!is_taked()) {
267 LOG_RUNTIME("Variable not taked!");
268 }
269 switch (static_cast<VariableCase> (this->index())) {
270 case VariableCase::INTEGER:
271 case VariableCase::DOUBLE:
272 return GetValueAsInteger();
273 case VariableCase::RATIONAL:
274 return !std::get<Rational>(*this).GetAsBoolean();
275
276 case VariableCase::SHARED:
277 return std::get<VariableShared> (*this).data->GetValueAsBoolean();
278
279 case VariableCase::TAKEN:
280 return (*std::get<VariableTaken> (*this)).GetValueAsBoolean();
281
282 case VariableCase::OBJECT:
283 return std::get<ObjPtr>(*this)->GetValueAsInteger();
284 // case VariableCase::POINTER:
285 // return std::get<void *>(*this);
286
287 case VariableCase::STRING:
288 return !std::get<std::string>(*this).empty();
289 case VariableCase::WSTRING:
290 return !std::get<std::wstring>(*this).empty();
291
292 case VariableCase::EMPTY:
293 case VariableCase::WEAK:
294 }
295 LOG_RUNTIME("Data type '%s' %d incompatible to boolean type!", VariableCaseToString(this->index()), static_cast<int> (this->index()));
296}
297
298int64_t Variable::GetValueAsInteger() const {
299 if (!is_taked()) {
300 LOG_RUNTIME("Variable not taked!");
301 }
302 switch (static_cast<VariableCase> (this->index())) {
303 case VariableCase::INTEGER:
304 return std::get<int64_t>(*this);
305 case VariableCase::OBJECT:
306 return std::get<ObjPtr>(*this)->GetValueAsInteger();
307 case VariableCase::SHARED:
308 return std::get<VariableShared> (*this).data->GetValueAsInteger();
309 case VariableCase::TAKEN:
310 return (*std::get<VariableTaken> (*this)).GetValueAsInteger();
311
312
313 case VariableCase::EMPTY:
314 case VariableCase::WEAK:
315
316 case VariableCase::DOUBLE:
317 case VariableCase::RATIONAL:
318 // case VariableCase::POINTER:
319 case VariableCase::STRING:
320 case VariableCase::WSTRING:
321 }
322 LOG_RUNTIME("Data type '%s' %d incompatible to integer type!", VariableCaseToString(this->index()), static_cast<int> (this->index()));
323}
324
325double Variable::GetValueAsNumber() const {
326 if (!is_taked()) {
327 LOG_RUNTIME("Variable not taked!");
328 }
329
330 switch (static_cast<VariableCase> (this->index())) {
331 case VariableCase::DOUBLE:
332 return std::get<double>(*this);
333
334 case VariableCase::INTEGER:
335 return std::get<int64_t>(*this);
336
337 case VariableCase::OBJECT:
338 return std::get<ObjPtr>(*this)->GetValueAsNumber();
339
340 case VariableCase::RATIONAL:
341 return std::get<Rational>(*this).GetAsNumber();
342
343 case VariableCase::SHARED:
344 return std::get<VariableShared> (*this).data->GetValueAsNumber();
345
346 case VariableCase::TAKEN:
347 return (*std::get<VariableTaken> (*this)).GetValueAsNumber();
348
349
350 case VariableCase::EMPTY:
351 case VariableCase::WEAK:
352
353 // case VariableCase::POINTER:
354 case VariableCase::STRING:
355 case VariableCase::WSTRING:
356 }
357 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(this->index()), static_cast<int> (this->index()));
358}
359
360std::string & Variable::GetValueAsString() {
361
362 if (!is_taked()) {
363 LOG_RUNTIME("Variable not taked!");
364 }
365
366 switch (static_cast<VariableCase> (this->index())) {
367 case VariableCase::STRING:
368 return std::get<std::string>(*this);
369
370 case VariableCase::OBJECT:
371 // return std::get<ObjPtr>(*this)->GetValueAsString();
372
373 case VariableCase::SHARED:
374 // return std::get<std::shared_ptr<Variable>>(*this)->GetValueAsString();
375 case VariableCase::TAKEN:
376 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsString();
377
378 case VariableCase::INTEGER:
379 case VariableCase::DOUBLE:
380 case VariableCase::RATIONAL:
381 // case VariableCase::POINTER:
382 case VariableCase::WSTRING:
383
384 case VariableCase::EMPTY:
385 case VariableCase::WEAK:
386 }
387 LOG_RUNTIME("Data type '%s' %d incompatible to string!", VariableCaseToString(this->index()), static_cast<int> (this->index()));
388}
389
390std::wstring & Variable::GetValueAsStringWide() {
391
392 if (!is_taked()) {
393 LOG_RUNTIME("Variable not taked!");
394 }
395
396 switch (static_cast<VariableCase> (this->index())) {
397 case VariableCase::WSTRING:
398 return std::get<std::wstring>(*this);
399
400 case VariableCase::OBJECT:
401 // return std::get<ObjPtr>(*this)->GetValueAsStringWide();
402
403 case VariableCase::SHARED:
404 // return std::get<std::shared_ptr<Variable>>(*this)->GetValueAsStringWide();
405
406 case VariableCase::TAKEN:
407 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsStringWide();
408
409 case VariableCase::INTEGER:
410 case VariableCase::DOUBLE:
411 case VariableCase::RATIONAL:
412 // case VariableCase::POINTER:
413 case VariableCase::STRING:
414
415 case VariableCase::EMPTY:
416 case VariableCase::WEAK:
417 }
418 LOG_RUNTIME("Data type '%s' %d incompatible to wstring!", VariableCaseToString(this->index()), static_cast<int> (this->index()));
419}
420
421Rational Variable::GetValueAsRational() const {
422 if (!is_taked()) {
423 LOG_RUNTIME("Variable not taked!");
424 }
425
426 switch (static_cast<VariableCase> (this->index())) {
427 // case VariableCase::DOUBLE:
428 // return std::get<double>(*this);
429 //
430 // case VariableCase::INTEGER:
431 // return std::get<int64_t>(*this);
432
433 case VariableCase::OBJECT:
434 return *std::get<ObjPtr>(*this)->GetValueAsRational();
435
436 case VariableCase::RATIONAL:
437 return std::get<Rational>(*this);
438
439 case VariableCase::SHARED:
440 return std::get<VariableShared> (*this).data->GetValueAsRational();
441
442 case VariableCase::TAKEN:
443 return (*std::get<VariableTaken> (*this)).GetValueAsRational();
444
445 case VariableCase::DOUBLE:
446 case VariableCase::INTEGER:
447
448 case VariableCase::EMPTY:
449 case VariableCase::WEAK:
450
451 // case VariableCase::POINTER:
452 case VariableCase::STRING:
453 case VariableCase::WSTRING:
454 }
455 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(this->index()), static_cast<int> (this->index()));
456}
457
458ObjPtr Variable::GetValueAsObject() const {
459 if (!is_taked()) {
460 LOG_RUNTIME("Variable not taked!");
461 }
462
463 switch (static_cast<VariableCase> (this->index())) {
464 // case VariableCase::DOUBLE:
465 // return std::get<double>(*this);
466 //
467 // case VariableCase::INTEGER:
468 // return std::get<int64_t>(*this);
469
470 case VariableCase::OBJECT:
471 return std::get<ObjPtr>(*this);
472
473 // case VariableCase::RATIONAL:
474 // return std::get<Rational>(*this);
475
476 case VariableCase::SHARED:
477 return std::get<VariableShared> (*this).data->GetValueAsObject();
478
479 case VariableCase::TAKEN:
480 return (*std::get<VariableTaken> (*this)).GetValueAsObject();
481
482 case VariableCase::RATIONAL:
483 return Obj::CreateRational(std::get<Rational>(*this));
484
485 case VariableCase::DOUBLE:
486 return Obj::CreateValue(std::get<double>(*this));
487
488 case VariableCase::INTEGER:
489 return Obj::CreateValue(std::get<int64_t>(*this));
490
491 case VariableCase::EMPTY:
492 return Obj::CreateNone();
493
494 case VariableCase::STRING:
495 return Obj::CreateString(std::get<std::string>(*this));
496
497 case VariableCase::WSTRING:
498 return Obj::CreateString(std::get<std::wstring>(*this));
499
500 case VariableCase::WEAK:
501
502 // case VariableCase::POINTER:
503 }
504 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(this->index()), static_cast<int> (this->index()));
505}
506
507void * Variable::GetValueAsPointer() const {
508 if (!is_taked()) {
509 LOG_RUNTIME("Variable not taked!");
510 }
511
512 switch (static_cast<VariableCase> (this->index())) {
513 // case VariableCase::POINTER:
514 // return std::get<void *>(*this);
515
516 case VariableCase::SHARED:
517 return std::get<VariableShared> (*this).data->GetValueAsPointer();
518
519 case VariableCase::TAKEN:
520 return (*std::get<VariableTaken> (*this)).GetValueAsPointer();
521
522 case VariableCase::DOUBLE:
523 // return std::get<double>(*this);
524
525 case VariableCase::INTEGER:
526 // return std::get<int64_t>(*this);
527
528 case VariableCase::OBJECT:
529 // return std::get<ObjPtr>(*this)->GetValueAsNumber();
530
531 case VariableCase::RATIONAL:
532 // return std::get<Rational>(*this).GetAsNumber();
533
534 case VariableCase::EMPTY:
535 case VariableCase::WEAK:
536
537 case VariableCase::STRING:
538 case VariableCase::WSTRING:
539 }
540 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(this->index()), static_cast<int> (this->index()));
541}
542
543std::string Variable::toString() const {
544
545 std::string result(is_taked() ? "" : " Not taked!");
546
547 switch (static_cast<VariableCase> (this->index())) {
548 case VariableCase::EMPTY:
549 result.insert(0, "Empty");
550 break;
551
552 // case VariableCase::POINTER:
553 // {
554 // result.insert(0, std::to_string(reinterpret_cast<uintptr_t> (std::get<void *>(*this))));
555 // // std::stringstream ss;
556 // // ss << std::get<void *>(*this);
557 // // result.insert(0, ss.str());
558 // break;
559 // }
560
561 case VariableCase::SHARED:
562 result.insert(0, std::get<VariableShared> (*this).data->toString());
563 result.insert(0, "Shared: ");
564 break;
565
566 case VariableCase::TAKEN:
567 result.insert(0, (*std::get<VariableTaken> (*this)).toString());
568 result.insert(0, "Guard: ");
569 break;
570
571 case VariableCase::DOUBLE:
572 result.insert(0, std::to_string(std::get<double>(*this)));
573 break;
574
575 case VariableCase::INTEGER:
576 result.insert(0, std::to_string(std::get<int64_t>(*this)));
577 break;
578
579 case VariableCase::OBJECT:
580 result.insert(0, std::get<ObjPtr> (*this)->toString());
581 result.insert(0, "Object: ");
582 break;
583
584 case VariableCase::RATIONAL:
585 result.insert(0, std::get<Rational> (*this).GetAsString());
586 break;
587
588 case VariableCase::STRING:
589 result.insert(0, "\"");
590 result.insert(0, std::get<std::string> (*this));
591 result.insert(0, "\"");
592 break;
593
594 case VariableCase::WSTRING:
595 result.insert(0, "'");
596 result.insert(0, std::get<std::string> (*this));
597 result.insert(0, "'");
598 break;
599
600 case VariableCase::WEAK:
601 result.insert(0, "link to:");
602 break;
603
604 }
605 return result;
606}
607
608
609VirtualFuncImpl<Variable, const Variable &> VariableOp::copy = {&VariableOp::__copy__};
610VirtualFuncImpl<Variable, const Variable &> VariableOp::clone = {&VariableOp::__clone__};
611
612VirtualFuncImpl<int, const Variable &, const Variable &> VariableOp::eq = {VariableOp::__eq__};
613VirtualFuncImpl<bool, const Variable &, const Variable &> VariableOp::strict_eq = {VariableOp::__strict_eq__};
614
615
616VariableOp::OperatorType VariableOp::iadd = {&VariableOp::__iadd_only_numbers__, &VariableOp::__iadd__};
617VariableOp::OperatorType VariableOp::isub = {&VariableOp::__isub__};
618VariableOp::OperatorType VariableOp::imul = {&VariableOp::__imul_only_numbers__, &VariableOp::__imul__};
619VariableOp::OperatorType VariableOp::itruediv = {&VariableOp::__itruediv__};
620VariableOp::OperatorType VariableOp::ifloordiv = {&VariableOp::__ifloordiv__};
621VariableOp::OperatorType VariableOp::imod = {&VariableOp::__imod__};
622
623/*
624 *
625 *
626 */
627
628Variable VariableOp::__copy__(const Variable &var) {
629 // Variable result(this->Copy());
630
631 if (!var.is_taked()) {
632 LOG_RUNTIME("Variable not taked!");
633 }
634
635 switch (static_cast<VariableCase> (var.index())) {
636 case VariableCase::OBJECT:
637 return Variable(std::get<ObjPtr>(var)->Copy());
638
639 case VariableCase::INTEGER:
640 case VariableCase::DOUBLE:
641 case VariableCase::RATIONAL:
642 // case VariableCase::POINTER:
643 case VariableCase::STRING:
644 case VariableCase::WSTRING:
645 return Variable(var);
646
647 case VariableCase::SHARED:
648 // return std::get<std::shared_ptr < Variable >> (self)->GetValueAsPointer();
649
650 case VariableCase::TAKEN:
651 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsPointer();
652
653 case VariableCase::EMPTY:
654 case VariableCase::WEAK:
655 }
656
657 LOG_RUNTIME("Data type '%s' %d copy not implemented!", VariableCaseToString(var.index()), static_cast<int> (var.index()));
658}
659
660Variable VariableOp::__clone__(const Variable &var) {
661 // Variable result(this->Copy());
662
663 if (!var.is_taked()) {
664 LOG_RUNTIME("Variable not taked!");
665 }
666
667 switch (static_cast<VariableCase> (var.index())) {
668 case VariableCase::OBJECT:
669 return Variable(std::get<ObjPtr>(var)->Clone());
670
671 case VariableCase::INTEGER:
672 case VariableCase::DOUBLE:
673 case VariableCase::RATIONAL:
674 // case VariableCase::POINTER:
675 case VariableCase::STRING:
676 case VariableCase::WSTRING:
677 return Variable(var);
678
679 case VariableCase::SHARED:
680 // return std::get<std::shared_ptr < Variable >> (self)->GetValueAsPointer();
681
682 case VariableCase::TAKEN:
683 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsPointer();
684
685 case VariableCase::EMPTY:
686 case VariableCase::WEAK:
687 }
688
689 LOG_RUNTIME("Data type '%s' %d copy not implemented!", VariableCaseToString(var.index()), static_cast<int> (var.index()));
690}
691
692/*
693 *
694 */
695bool Variable::is_object_type() const {
696 switch (static_cast<VariableCase> (index())) {
697 case VariableCase::OBJECT:
698 return true;
699 default:
700 }
701 return false;
702}
703
704bool Variable::is_scalar_type() const {
705 switch (static_cast<VariableCase> (index())) {
706 case VariableCase::INTEGER:
707 case VariableCase::DOUBLE:
708 case VariableCase::RATIONAL:
709 return true;
710 case VariableCase::OBJECT:
711 return std::get<ObjPtr>(*this)->is_scalar();
712 default:
713 }
714 return false;
715}
716
717bool Variable::is_floating_type() const {
718 switch (static_cast<VariableCase> (index())) {
719 case VariableCase::DOUBLE:
720 return true;
721 case VariableCase::OBJECT:
722 return std::get<ObjPtr>(*this)->is_floating();
723 default:
724 }
725 return false;
726}
727
728bool Variable::is_complex_type() const {
729 switch (static_cast<VariableCase> (index())) {
730 // case VariableCase::INTEGER:
731 // case VariableCase::DOUBLE:
732 // case VariableCase::RATIONAL:
733 // return true;
734 case VariableCase::OBJECT:
735 return std::get<ObjPtr>(*this)->is_complex();
736 default:
737 }
738 return false;
739}
740
741bool Variable::is_rational_type() const {
742 switch (static_cast<VariableCase> (index())) {
743 case VariableCase::RATIONAL:
744 return true;
745 case VariableCase::OBJECT:
746 return std::get<ObjPtr>(*this)->is_rational();
747 default:
748 }
749 return false;
750}
751
752bool Variable::is_string_type() const {
753 switch (static_cast<VariableCase> (index())) {
754 case VariableCase::STRING:
755 case VariableCase::WSTRING:
756 return true;
757 case VariableCase::OBJECT:
758 return std::get<ObjPtr>(*this)->is_string_type();
759 default:
760 }
761 return false;
762}
763
764/*
765 *
766 */
767
768int VariableOp::__eq__(const Variable &self, const Variable &other) {
769 if (&self == &other) {
770 return 0;
771 }
772 if (self.is_scalar_type() && other.is_scalar_type()) {
773 if (self.is_floating_type() || other.is_floating_type()) {
774 if (self.GetValueAsNumber() < other.GetValueAsNumber()) {
775 return -1;
776 } else if (self.GetValueAsNumber() > other.GetValueAsNumber()) {
777 return 1;
778 };
779 return 0;
780 } else if (self.is_complex_type() || other.is_complex_type()) {
781 // Будет ошибка сравнения комплексных значений
782 } else {
783 if (self.GetValueAsInteger() < other.GetValueAsInteger()) {
784 return -1;
785 } else if (self.GetValueAsInteger() > other.GetValueAsInteger()) {
786 return 1;
787 };
788 return 0;
789 }
790 } else if (self.is_rational_type() && other.is_scalar_type()) {
791 return self.GetValueAsRational().op_compare(other.GetValueAsRational());
792 } else if ((self.is_string_type() && other.is_string_type())) {
793 return const_cast<Variable &> (self).GetValueAsString().compare(const_cast<Variable &> (other).GetValueAsString());
794 }
795 LOG_RUNTIME("Fail compare type %s and %s", VariableCaseToString(self.index()), VariableCaseToString(other.index()));
796}
797
798bool VariableOp::__strict_eq__(const Variable &self, const Variable &other) {
799 return VariableOp::__eq__(self, other) == 0; // temporary
800}
801
802
803/*
804 *
805 *
806 *
807 */
808
809
810
811
812#define DEFINE_OPERATOR_IMPL(name) __attribute__ ((weak)) Variable & VariableOp::__ ## name ## __(Variable &self, const Variable &other)
813
814DEFINE_OPERATOR_IMPL(iadd_only_numbers) {
815
816 if (!self.is_taked()) {
817 LOG_RUNTIME("Variable not taked!");
818 }
819
820 switch (static_cast<VariableCase> (self.index())) {
821 case VariableCase::DOUBLE:
822 std::get<double>(self) += other.GetValueAsNumber();
823 return self;
824
825 case VariableCase::INTEGER:
826 std::get<int64_t>(self) += other.GetValueAsInteger();
827 return self;
828
829 case VariableCase::OBJECT:
830 *std::get<ObjPtr>(self) += other.GetValueAsObject();
831 return self;
832
833 case VariableCase::RATIONAL:
834 std::get<Rational>(self) += other.GetValueAsRational();
835 return self;
836
837 // case VariableCase::POINTER:
838 // return std::get<void *>(self);
839
840 case VariableCase::SHARED:
841 // return std::get<std::shared_ptr < Variable >> (self)->GetValueAsPointer();
842
843 case VariableCase::TAKEN:
844 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsPointer();
845
846 case VariableCase::EMPTY:
847 case VariableCase::WEAK:
848
849 case VariableCase::STRING:
850 case VariableCase::WSTRING:
851 }
852 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(self.index()), static_cast<int> (self.index()));
853}
854
855DEFINE_OPERATOR_IMPL(iadd) {
856 switch (static_cast<VariableCase> (self.index())) {
857 case VariableCase::STRING:
858 std::get<std::string>(self) += const_cast<Variable&> (other).GetValueAsString();
859 return self;
860
861 case VariableCase::WSTRING:
862 std::get<std::wstring>(self) += const_cast<Variable&> (other).GetValueAsStringWide();
863 return self;
864 default:
865 }
866
867 ASSERT(VariableOp::iadd.parent(&VariableOp::__iadd__));
868 return (*VariableOp::iadd.parent(&VariableOp::__iadd__))(self, other);
869}
870
871/*
872 *
873 */
874
875DEFINE_OPERATOR_IMPL(isub) {
876
877 if (!self.is_taked()) {
878 LOG_RUNTIME("Variable not taked!");
879 }
880
881 switch (static_cast<VariableCase> (self.index())) {
882 case VariableCase::DOUBLE:
883 std::get<double>(self) -= other.GetValueAsNumber();
884 return self;
885
886 case VariableCase::INTEGER:
887 std::get<int64_t>(self) -= other.GetValueAsInteger();
888 return self;
889
890 case VariableCase::OBJECT:
891 *std::get<ObjPtr>(self) -= other.GetValueAsObject();
892 return self;
893
894 case VariableCase::RATIONAL:
895 std::get<Rational>(self) -= other.GetValueAsRational();
896 return self;
897
898 // case VariableCase::POINTER:
899 // return std::get<void *>(self);
900
901 case VariableCase::SHARED:
902 // return std::get<std::shared_ptr < Variable >> (self)->GetValueAsPointer();
903
904 case VariableCase::TAKEN:
905 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsPointer();
906
907 case VariableCase::EMPTY:
908 case VariableCase::WEAK:
909
910 case VariableCase::STRING:
911 case VariableCase::WSTRING:
912 }
913 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(self.index()), static_cast<int> (self.index()));
914}
915
916DEFINE_OPERATOR_IMPL(imul_only_numbers) {
917
918 if (!self.is_taked()) {
919 LOG_RUNTIME("Variable not taked!");
920 }
921
922 switch (static_cast<VariableCase> (self.index())) {
923 case VariableCase::DOUBLE:
924 std::get<double>(self) *= other.GetValueAsNumber();
925 return self;
926
927 case VariableCase::INTEGER:
928 std::get<int64_t>(self) *= other.GetValueAsInteger();
929 return self;
930
931 case VariableCase::OBJECT:
932 *std::get<ObjPtr>(self) *= other.GetValueAsObject();
933 return self;
934
935 case VariableCase::RATIONAL:
936 std::get<Rational>(self) *= other.GetValueAsRational();
937 return self;
938
939 // case VariableCase::POINTER:
940 // return std::get<void *>(self);
941
942 case VariableCase::SHARED:
943 // return std::get<std::shared_ptr < Variable >> (self)->GetValueAsPointer();
944
945 case VariableCase::TAKEN:
946 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsPointer();
947
948 case VariableCase::EMPTY:
949 case VariableCase::WEAK:
950
951 case VariableCase::STRING:
952 case VariableCase::WSTRING:
953 }
954 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(self.index()), static_cast<int> (self.index()));
955}
956
957DEFINE_OPERATOR_IMPL(imul) {
958 switch (static_cast<VariableCase> (self.index())) {
959 case VariableCase::STRING:
960 std::get<std::string>(self) = repeat(std::get<std::string>(self), other.GetValueAsInteger());
961 return self;
962
963 case VariableCase::WSTRING:
964 std::get<std::wstring>(self) = repeat(std::get<std::wstring>(self), other.GetValueAsInteger());
965 return self;
966 default:
967 }
968 ASSERT(VariableOp::imul.parent(&VariableOp::__imul__));
969 return (*VariableOp::imul.parent(&VariableOp::__imul__))(self, other);
970}
971
972/*
973 *
974 */
975
976/*
977 * x / y __truediv__(self, other) x /= y __itruediv__(self, other)
978 */
979DEFINE_OPERATOR_IMPL(itruediv) {
980
981 if (!self.is_taked()) {
982 LOG_RUNTIME("Variable not taked!");
983 }
984
985 switch (static_cast<VariableCase> (self.index())) {
986 case VariableCase::DOUBLE:
987 std::get<double>(self) /= other.GetValueAsNumber();
988 return self;
989
990 case VariableCase::INTEGER:
991 std::get<int64_t>(self) /= other.GetValueAsInteger();
992 return self;
993
994 case VariableCase::OBJECT:
995 *std::get<ObjPtr>(self) /= other.GetValueAsObject();
996 return self;
997
998 case VariableCase::RATIONAL:
999 std::get<Rational>(self) /= other.GetValueAsRational();
1000 return self;
1001
1002 // case VariableCase::POINTER:
1003 // return std::get<void *>(self);
1004
1005 case VariableCase::SHARED:
1006 // return std::get<std::shared_ptr < Variable >> (self)->GetValueAsPointer();
1007
1008 case VariableCase::TAKEN:
1009 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsPointer();
1010
1011 case VariableCase::EMPTY:
1012 case VariableCase::WEAK:
1013
1014 case VariableCase::STRING:
1015 // std::get<std::string>(self) += other.GetValueAsString();
1016 // return self;
1017
1018 case VariableCase::WSTRING:
1019 // std::get<std::wstring>(self) += other.GetValueAsStringWide();
1020 // return self;
1021 }
1022 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(self.index()), static_cast<int> (self.index()));
1023}
1024
1025/*
1026 * x // y __floordiv__(self, other) x //= y __ifloordiv__(self, other)
1027 */
1028DEFINE_OPERATOR_IMPL(ifloordiv) {
1029
1030 if (!self.is_taked()) {
1031 LOG_RUNTIME("Variable not taked!");
1032 }
1033
1034 switch (static_cast<VariableCase> (self.index())) {
1035 case VariableCase::DOUBLE:
1036 std::get<double>(self) *= other.GetValueAsNumber();
1037 return self;
1038
1039 case VariableCase::INTEGER:
1040 std::get<int64_t>(self) *= other.GetValueAsInteger();
1041 return self;
1042
1043 case VariableCase::OBJECT:
1044 // op_div_ceil
1045 // *std::get<ObjPtr>(self) *= other.GetValueAsObject();
1046 // return self;
1047
1048 case VariableCase::RATIONAL:
1049 // std::get<Rational>(self) *= other.GetValueAsRational();
1050 // return self;
1051
1052 // case VariableCase::POINTER:
1053 // return std::get<void *>(self);
1054
1055 case VariableCase::SHARED:
1056 // return std::get<std::shared_ptr < Variable >> (self)->GetValueAsPointer();
1057
1058 case VariableCase::TAKEN:
1059 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsPointer();
1060
1061 case VariableCase::EMPTY:
1062 case VariableCase::WEAK:
1063
1064 case VariableCase::STRING:
1065 // std::get<std::string>(self) += other.GetValueAsString();
1066 // return self;
1067
1068 case VariableCase::WSTRING:
1069 // std::get<std::wstring>(self) += other.GetValueAsStringWide();
1070 // return self;
1071 }
1072 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(self.index()), static_cast<int> (self.index()));
1073}
1074
1075/*
1076 * x % y __mod__(self, other) x %= y __imod__(self, other)
1077 */
1078DEFINE_OPERATOR_IMPL(imod) {
1079
1080 if (!self.is_taked()) {
1081 LOG_RUNTIME("Variable not taked!");
1082 }
1083
1084 switch (static_cast<VariableCase> (self.index())) {
1085 case VariableCase::INTEGER:
1086 std::get<int64_t>(self) %= other.GetValueAsInteger();
1087 return self;
1088
1089 case VariableCase::OBJECT:
1090 *std::get<ObjPtr>(self) %= other.GetValueAsObject();
1091 return self;
1092
1093 case VariableCase::RATIONAL:
1094 std::get<Rational>(self) %= other.GetValueAsRational();
1095 return self;
1096
1097 case VariableCase::DOUBLE:
1098 // std::get<double>(self) %= other.GetValueAsNumber();
1099 // return self;
1100
1101 // case VariableCase::POINTER:
1102 // return std::get<void *>(self);
1103
1104 case VariableCase::SHARED:
1105 // return std::get<std::shared_ptr < Variable >> (self)->GetValueAsPointer();
1106
1107 case VariableCase::TAKEN:
1108 // return std::get<std::shared_ptr < VariableGuard >> (*this)->m_var->GetValueAsPointer();
1109
1110 case VariableCase::EMPTY:
1111 case VariableCase::WEAK:
1112
1113 case VariableCase::STRING:
1114 // std::get<std::string>(self) += other.GetValueAsString();
1115 // return self;
1116
1117 case VariableCase::WSTRING:
1118 // std::get<std::wstring>(self) += other.GetValueAsStringWide();
1119 // return self;
1120 }
1121 LOG_RUNTIME("Data type '%s' %d incompatible to number type!", VariableCaseToString(self.index()), static_cast<int> (self.index()));
1122}
1123
1124#pragma clang diagnostic pop
newlang::Obj::CreateString
static ObjPtr CreateString(const std::string_view str, Sync *sync=nullptr)
Definition object.h:1596
newlang::Obj::CreateValue
static std::enable_if< std::is_same< T, std::string >::value||std::is_same< T, constchar * >::value, ObjPtr >::type CreateValue(T value, Sync *sync=nullptr)
Definition object.h:1562
newlang::Obj::CreateRational
static ObjPtr CreateRational(const Rational &val)
Definition object.h:1437
newlang::Obj::CreateNone
static ObjPtr CreateNone(Sync *sync=nullptr)
Definition object.h:1510
newlang::Rational::op_compare
int op_compare(const Rational &rational) const
Definition rational.cpp:406
newlang::Sync::CreateSync
static std::shared_ptr< Sync > CreateSync(const TermPtr &term)
Definition variable.cpp:37
newlang::VariableOp::__imul_only_numbers__
static Variable & __imul_only_numbers__(Variable &self, const Variable &other)
newlang::VariableOp::__itruediv__
static Variable & __itruediv__(Variable &self, const Variable &other)
newlang::VariableOp::ifloordiv
static OperatorType ifloordiv
Definition variable.h:365
newlang::VariableOp::copy
static VirtualFuncImpl< Variable, const Variable & > copy
Definition variable.h:336
newlang::VariableOp::__eq__
static int __eq__(const Variable &self, const Variable &other)
Definition variable.cpp:768
newlang::VariableOp::__clone__
static Variable __clone__(const Variable &clone)
Definition variable.cpp:660
newlang::VariableOp::__imul__
static Variable & __imul__(Variable &self, const Variable &other)
newlang::VariableOp::__isub__
static Variable & __isub__(Variable &self, const Variable &other)
newlang::VariableOp::__strict_eq__
static bool __strict_eq__(const Variable &self, const Variable &other)
Definition variable.cpp:798
newlang::VariableOp::itruediv
static OperatorType itruediv
Definition variable.h:364
newlang::VariableOp::__ifloordiv__
static Variable & __ifloordiv__(Variable &self, const Variable &other)
newlang::VariableOp::clone
static VirtualFuncImpl< Variable, const Variable & > clone
Definition variable.h:339
newlang::VariableOp::iadd
static OperatorType iadd
Definition variable.h:361
newlang::VariableOp::__iadd_only_numbers__
static Variable & __iadd_only_numbers__(Variable &self, const Variable &other)
newlang::VariableOp::__copy__
static Variable __copy__(const Variable &copy)
Definition variable.cpp:628
newlang::VariableOp::isub
static OperatorType isub
Definition variable.h:362
newlang::VariableOp::__imod__
static Variable & __imod__(Variable &self, const Variable &other)
newlang::VariableOp::strict_eq
static VirtualFuncImpl< bool, const Variable &, const Variable & > strict_eq
Definition variable.h:345
newlang::VariableOp::imul
static OperatorType imul
Definition variable.h:363
newlang::VariableOp::eq
static VirtualFuncImpl< int, const Variable &, const Variable & > eq
Definition variable.h:342
newlang::VariableOp::__iadd__
static Variable & __iadd__(Variable &self, const Variable &other)
newlang::VariableOp::imod
static OperatorType imod
Definition variable.h:366
newlang::VariableTaken::variable
std::variant< Variable *, std::shared_ptr< Variable >, std::shared_ptr< Sync > > variable
Definition variable.h:224
newlang::VariableTaken::MakeTimeoutMessage
static std::string MakeTimeoutMessage(const Variable &var, bool edit_mode, const std::chrono::milliseconds &timeout_duration, const std::string_view message, const std::source_location &location)
Definition variable.cpp:95
newlang::VariableTaken::VariableTaken
VariableTaken(const Variable &var, bool edit_mode, const std::chrono::milliseconds &timeout_duration=Sync::SyncTimeoutDeedlock, const std::string_view message="", const std::source_location &location=std::source_location::current())
Definition variable.cpp:54
newlang::Variable::is_floating_type
bool is_floating_type() const
Definition variable.cpp:717
newlang::Variable::is_rational_type
bool is_rational_type() const
Definition variable.cpp:741
newlang::Variable::GetValueAsInteger
int64_t GetValueAsInteger() const
Definition variable.cpp:298
newlang::Variable::GetValueAsNumber
double GetValueAsNumber() const
Definition variable.cpp:325
newlang::Variable::GetValueAsStringWide
std::wstring & GetValueAsStringWide()
Definition variable.cpp:390
newlang::Variable::GetValueAsString
std::string & GetValueAsString()
Definition variable.cpp:360
newlang::Variable::is_object_type
bool is_object_type() const
Definition variable.cpp:695
newlang::Variable::GetValueAsBoolean
bool GetValueAsBoolean() const
Definition variable.cpp:265
newlang::Variable::GetValueAsObject
ObjPtr GetValueAsObject() const
Definition variable.cpp:458
newlang::Variable::GetValueAsPointer
void * GetValueAsPointer() const
Definition variable.cpp:507
newlang::Variable::Object
static ObjPtr Object(Variable *variable)
Definition variable.cpp:181
newlang::Variable::is_complex_type
bool is_complex_type() const
Definition variable.cpp:728
newlang::Variable::toString
std::string toString() const
Definition variable.cpp:543
newlang::Variable::GetValueAsRational
Rational GetValueAsRational() const
Definition variable.cpp:421
newlang::Variable::is_taked
bool is_taked() const
Definition variable.h:595
newlang::Variable::is_scalar_type
bool is_scalar_type() const
Definition variable.cpp:704
newlang::Variable::compare
int compare(const Variable &other) const
Definition variable.h:813
newlang::Variable::isShared
static bool isShared(const TermPtr &term)
Definition variable.cpp:166
newlang::Variable::is_string_type
bool is_string_type() const
Definition variable.cpp:752
newlang::Variable::Ref
Variable Ref(const std::string_view ref) const
Definition variable.cpp:200
result
int result
Definition lexer.l:367
LOG_RUNTIME
#define LOG_RUNTIME(format,...)
Definition logger.h:26
ASSERT
#define ASSERT(condition)
Definition logger.h:60
newlang
Definition nlc.h:59
newlang::utf8_decode
std::wstring utf8_decode(const std::string str)
Definition variable.cpp:22
newlang::TermPtr
std::shared_ptr< Term > TermPtr
Definition variable.h:33
newlang::ObjPtr
std::shared_ptr< Obj > ObjPtr
Definition variable.h:28
newlang::VariableCaseToString
const char * VariableCaseToString(size_t index)
Definition variable.h:425
newlang::RefTypeFromString
constexpr RefType RefTypeFromString(const std::string_view text)
Definition variable.h:55
newlang::repeat
T repeat(T str, const std::size_t n)
Definition types.h:116
newlang::utf8_encode
std::string utf8_encode(const std::wstring wstr)
Definition variable.cpp:10
DEFINE_OPERATOR_IMPL
#define DEFINE_OPERATOR_IMPL(name)
Definition variable.cpp:812
Generated by doxygen 1.11.0