NewLang Project
Yet another programm language
Loading...
Searching...
No Matches
alg_test.cpp
Go to the documentation of this file.
1#ifdef BUILD_UNITTEST
2
3#include "warning_push.h"
4#include <gtest/gtest.h>
5#include "warning_pop.h"
6
7#include "parser.h"
8
9#include <signal.h>
10
11#include "builtin.h"
12#include "runtime.h"
13
14using namespace newlang;
15
16TEST(Alg, Follow) {
17
18 RuntimePtr rt = RunTime::Init();
19 ASSERT_TRUE(rt);
20
21 ObjPtr result = nullptr;
22
23 ASSERT_NO_THROW(result = jit->Run("[1]-->100"));
24 ASSERT_TRUE(result);
25 ASSERT_EQ(100, result->GetValueAsInteger());
26
27 ASSERT_NO_THROW(result = jit->Run("[-1]-->99"));
28 ASSERT_TRUE(result);
29 ASSERT_EQ(99, result->GetValueAsInteger());
30
31 ASSERT_NO_THROW(result = jit->Run("[0]-->111"));
32 ASSERT_TRUE(result);
33 ASSERT_TRUE(result->is_none_type());
34
35 ASSERT_NO_THROW(result = jit->Run("[1]-->111"));
36 ASSERT_TRUE(result);
37 ASSERT_EQ(111, result->GetValueAsInteger());
38
39
40
41 ASSERT_NO_THROW(result = jit->Run("[0]-->100,[1]-->300"));
42 ASSERT_TRUE(result);
43 ASSERT_EQ(300, result->GetValueAsInteger());
44
45 ASSERT_NO_THROW(result = jit->Run("[0]-->100,[0]-->300,[99]-->99,[...]-->1000"));
46 ASSERT_TRUE(result);
47 ASSERT_EQ(99, result->GetValueAsInteger());
48
49 ASSERT_NO_THROW(result = jit->Run("[0]-->111,[...]-->1000"));
50 ASSERT_TRUE(result);
51 ASSERT_EQ(1000, result->GetValueAsInteger());
52
53 ASSERT_NO_THROW(result = jit->Run("[0]-->{100},[1]-->{10;20;30}"));
54 ASSERT_TRUE(result);
55 ASSERT_EQ(30, result->GetValueAsInteger());
56
57 ASSERT_NO_THROW(result = jit->Run("[0]-->{100},[0]-->{300},[99]-->{99},[...]-->{1000}"));
58 ASSERT_TRUE(result);
59 ASSERT_EQ(99, result->GetValueAsInteger());
60
61 ASSERT_NO_THROW(result = jit->Run("[0]-->111,[...]-->{30;50;1000}"));
62 ASSERT_TRUE(result);
63 ASSERT_EQ(1000, result->GetValueAsInteger());
64
65
66 ASSERT_NO_THROW(result = jit->Run("cond := 100; [cond]-->111,[...]-->1000"));
67 ASSERT_TRUE(result);
68 ASSERT_EQ(111, result->GetValueAsInteger());
69
70 ASSERT_NO_THROW(result = jit->Run("cond2 := 0; [cond2]-->111,[...]-->1000"));
71 ASSERT_TRUE(result);
72 ASSERT_EQ(1000, result->GetValueAsInteger());
73
74 ASSERT_NO_THROW(result = jit->Run("val := 1\\1; [val == 1]-->111,[...]-->1000"));
75 ASSERT_TRUE(result);
76 ASSERT_EQ(111, result->GetValueAsInteger());
77
78 ASSERT_NO_THROW(result = jit->Run("val := 1\\1; [val < 0]-->111,[...]-->1000"));
79 ASSERT_TRUE(result);
80 ASSERT_EQ(1000, result->GetValueAsInteger());
81
82 ASSERT_NO_THROW(result = jit->Run("val := 1\\1; [val > 0]-->{111},[...]-->1000"));
83 ASSERT_TRUE(result);
84 ASSERT_EQ(111, result->GetValueAsInteger());
85}
86
87TEST(Alg, Repeat) {
88
89 RuntimePtr rt = RunTime::Init();
90 ASSERT_TRUE(rt);
91
92 ObjPtr result = nullptr;
93
94 ASSERT_NO_THROW(result = jit->Run("result := 0"));
95 ASSERT_TRUE(result);
96 ASSERT_EQ(0, result->GetValueAsInteger());
97
98 ObjPtr cond;
99 ASSERT_NO_THROW(cond = jit->Run("result < 4"));
100 ASSERT_TRUE(cond);
101 ASSERT_TRUE(cond->GetValueAsBoolean());
102
103 ASSERT_NO_THROW(result = jit->Run("result += 1"));
104 ASSERT_TRUE(result);
105 ASSERT_EQ(1, result->GetValueAsInteger());
106
107 ASSERT_NO_THROW(cond = jit->Run("result < 4"));
108 ASSERT_TRUE(cond);
109 ASSERT_TRUE(cond->GetValueAsBoolean());
110
111 ASSERT_NO_THROW(result = jit->Run("result += 3"));
112 ASSERT_TRUE(result);
113 ASSERT_EQ(4, result->GetValueAsInteger());
114
115 ASSERT_NO_THROW(cond = jit->Run("result < 4"));
116 ASSERT_TRUE(cond);
117 ASSERT_FALSE(cond->GetValueAsBoolean());
118
119
120 ObjPtr counter;
121 ASSERT_NO_THROW(counter = jit->Run("counter := 0"));
122 ASSERT_EQ(0, counter->GetValueAsInteger());
123
124 ASSERT_EQ(4, result->GetValueAsInteger());
125 ASSERT_NO_THROW(result = jit->Run("result -= 1"));
126 ASSERT_EQ(3, result->GetValueAsInteger());
127
128 ASSERT_NO_THROW(counter = jit->Run("[result -= 1] <-> {counter += 1}"));
129 ASSERT_TRUE(counter);
130 ASSERT_EQ(0, counter->GetValueAsInteger());
131
132 ASSERT_NO_THROW(counter = jit->Run("counter"));
133 ASSERT_EQ(2, counter->GetValueAsInteger());
134
135
136
137 ASSERT_NO_THROW(counter = jit->Run("{result += 1; counter += 1} <-> [result < 10]"));
138 ASSERT_EQ(10, result->GetValueAsInteger());
139
140 ASSERT_TRUE(counter);
141 ASSERT_EQ(0, counter->GetValueAsInteger());
142
143 ASSERT_NO_THROW(counter = jit->Run("counter"));
144 ASSERT_EQ(12, counter->GetValueAsInteger());
145
146 ASSERT_NO_THROW(counter = jit->Run("result"));
147 ASSERT_EQ(10, counter->GetValueAsInteger());
148
149}
150
151TEST(Alg, Foreach) {
152
153 RuntimePtr rt = RunTime::Init();
154 ASSERT_TRUE(rt);
155
156 ObjPtr test = Obj::CreateDict();
157
158 test->push_back(Obj::Arg(10));
159 test->push_back(Obj::Arg(11));
160 test->push_back(Obj::Arg(12));
161 test->push_back(Obj::Arg(13));
162 ASSERT_EQ(4, test->size());
163 ASSERT_EQ(10, (*test)[0].second->GetValueAsInteger());
164 ASSERT_EQ(13, (*test)[3].second->GetValueAsInteger());
165
166 ASSERT_EQ(test->resize_(4, nullptr), test->size());
167 ASSERT_EQ(4, test->size());
168 ASSERT_EQ(10, (*test)[0].second->GetValueAsInteger());
169 ASSERT_EQ(13, (*test)[3].second->GetValueAsInteger());
170
171 test->resize_(-3, nullptr);
172 ASSERT_EQ(3, test->size());
173 ASSERT_EQ(11, (*test)[0].second->GetValueAsInteger());
174 ASSERT_EQ(13, (*test)[2].second->GetValueAsInteger());
175
176 test->resize_(-1, nullptr);
177 ASSERT_EQ(1, test->size());
178 ASSERT_EQ(13, (*test)[0].second->GetValueAsInteger());
179
180 test->resize_(0, nullptr);
181 ASSERT_EQ(0, test->size());
182
183 ObjPtr counter;
184 ASSERT_NO_THROW(counter = jit->Run("counter := 100"));
185 ASSERT_EQ(100, counter->GetValueAsInteger());
186
187 ObjPtr dict;
188 ASSERT_NO_THROW(dict = jit->Run("dict := (0,1,2,)"));
189 ASSERT_TRUE(dict);
190 ASSERT_TRUE(dict->is_dictionary_type());
191 ASSERT_EQ(3, dict->size());
192 ASSERT_EQ(0, (*dict)[0].second->GetValueAsInteger());
193 ASSERT_EQ(1, (*dict)[1].second->GetValueAsInteger());
194 ASSERT_EQ(2, (*dict)[2].second->GetValueAsInteger());
195
196
197 ASSERT_NO_THROW(counter = jit->Run("counter"));
198 ASSERT_EQ(100, counter->GetValueAsInteger());
199
200 ObjPtr temp;
201 ASSERT_NO_THROW(temp = jit->Run("counter, dict := ... dict"));
202 ASSERT_TRUE(temp);
203 ASSERT_TRUE(temp->is_dictionary_type()) << temp->toString();
204 ASSERT_EQ(2, temp->size());
205
206 ASSERT_NO_THROW(counter = jit->Run("counter"));
207 ASSERT_EQ(0, counter->GetValueAsInteger());
208
209 ASSERT_TRUE(dict->is_dictionary_type());
210 ASSERT_EQ(2, dict->size());
211 ASSERT_EQ(1, (*dict)[0].second->GetValueAsInteger());
212 ASSERT_EQ(2, (*dict)[1].second->GetValueAsInteger());
213
214 ASSERT_NO_THROW(temp = jit->Run("counter, dict := ... dict"));
215 ASSERT_TRUE(temp);
216 ASSERT_TRUE(temp->is_dictionary_type());
217 ASSERT_EQ(1, temp->size());
218
219 ASSERT_NO_THROW(counter = jit->Run("counter"));
220 ASSERT_TRUE(counter);
221 ASSERT_EQ(1, counter->GetValueAsInteger());
222
223 ASSERT_TRUE(dict->is_dictionary_type());
224 ASSERT_EQ(1, dict->size());
225 ASSERT_EQ(2, (*dict)[0].second->GetValueAsInteger());
226
227 ASSERT_NO_THROW(temp = jit->Run("counter += 1"));
228 ASSERT_TRUE(temp);
229 ASSERT_EQ(2, temp->GetValueAsInteger());
230
231 ASSERT_NO_THROW(temp = jit->Run("counter += counter"));
232 ASSERT_TRUE(temp);
233 ASSERT_EQ(4, temp->GetValueAsInteger());
234
235
236 ASSERT_NO_THROW(temp = jit->Run("counter, dict := ... dict"));
237 ASSERT_TRUE(temp);
238 ASSERT_TRUE(temp->is_dictionary_type()) << temp->toString();
239 ASSERT_EQ(0, temp->size());
240
241 ASSERT_NO_THROW(counter = jit->Run("counter"));
242 ASSERT_TRUE(counter);
243 ASSERT_EQ(2, counter->GetValueAsInteger());
244
245 ASSERT_TRUE(dict->is_dictionary_type());
246 ASSERT_EQ(0, dict->size());
247
248 ASSERT_NO_THROW(temp = jit->Run("counter, dict := ... dict"));
249 ASSERT_TRUE(temp);
250 ASSERT_TRUE(temp->is_dictionary_type());
251 ASSERT_TRUE(dict->is_dictionary_type());
252 ASSERT_EQ(0, dict->size());
253
254 ASSERT_NO_THROW(counter = jit->Run("counter"));
255 ASSERT_TRUE(counter);
256 ASSERT_TRUE(counter->is_none_type());
257
258
259 dict->push_back(Obj::Arg(10));
260 dict->push_back(Obj::Arg(20));
261 dict->push_back(Obj::Arg(30));
262 dict->push_back(Obj::Arg(40));
263 dict->push_back(Obj::Arg(50));
264 ASSERT_EQ(5, dict->size());
265
266 ASSERT_NO_THROW(temp = jit->Run("dict"));
267 ASSERT_TRUE(temp);
268 ASSERT_TRUE(temp->is_dictionary_type());
269 ASSERT_FALSE(temp->is_scalar());
270 ASSERT_TRUE(temp->GetValueAsBoolean());
271 ASSERT_EQ(5, temp->size());
272
273 ASSERT_NO_THROW(temp = jit->Run(":Bool[...](dict)"));
274 ASSERT_TRUE(temp);
275 ASSERT_TRUE(temp->is_bool_type());
276 ASSERT_FALSE(temp->is_scalar());
277 ASSERT_TRUE(temp->GetValueAsBoolean());
278 ASSERT_EQ(5, temp->size());
279
280 ASSERT_NO_THROW(temp = jit->Run(":Bool[_](dict)"));
281 ASSERT_TRUE(temp);
282 ASSERT_TRUE(temp->is_bool_type());
283 ASSERT_FALSE(temp->is_scalar());
284 ASSERT_TRUE(temp->GetValueAsBoolean());
285 ASSERT_EQ(5, temp->size());
286
287 ASSERT_NO_THROW(temp = jit->Run(":Bool[0](dict)"));
288 ASSERT_TRUE(temp);
289 ASSERT_TRUE(temp->is_bool_type());
290 ASSERT_TRUE(temp->is_scalar());
291 ASSERT_TRUE(temp->GetValueAsBoolean());
292 ASSERT_EQ(0, temp->size());
293
294 ASSERT_NO_THROW(temp = jit->Run(":Bool(dict)"));
295 ASSERT_TRUE(temp);
296 ASSERT_TRUE(temp->is_bool_type());
297 ASSERT_TRUE(temp->is_scalar());
298 ASSERT_TRUE(temp->GetValueAsBoolean());
299 ASSERT_EQ(0, temp->size());
300
301 ASSERT_NO_THROW(temp = jit->Run("@not(dict)"));
302 ASSERT_TRUE(temp);
303 ASSERT_TRUE(temp->is_bool_type());
304 ASSERT_FALSE(temp->GetValueAsBoolean());
305
306 ASSERT_NO_THROW(temp = jit->Run("dict"));
307 ASSERT_TRUE(temp);
308 ASSERT_STREQ("(10, 20, 30, 40, 50,)", temp->toString().c_str());
309
310 ObjPtr summa;
311 ASSERT_NO_THROW(summa = jit->Run("summa := 0"));
312 ASSERT_STREQ("0", summa->toString().c_str());
313 ASSERT_NO_THROW(summa = jit->Run("summa += 100"));
314 ASSERT_STREQ("100", summa->toString().c_str());
315
316 ASSERT_NO_THROW(temp = jit->Run(":Bool[...]( (1,) )"));
317 ASSERT_STREQ("[1,]:Bool", temp->toString().c_str());
318 ASSERT_NO_THROW(temp = jit->Run(":Bool( (1,) )"));
319 ASSERT_STREQ("1", temp->toString().c_str());
320
321 ASSERT_NO_THROW(temp = jit->Run(":Bool[...]( (1,) )"));
322 ASSERT_STREQ("[1,]:Bool", temp->toString().c_str());
323 ASSERT_NO_THROW(temp = jit->Run(":Bool( (1,) )"));
324 ASSERT_STREQ("1", temp->toString().c_str());
325
326 ASSERT_NO_THROW(temp = jit->Run(":Bool[...]( (0,) )"));
327 ASSERT_STREQ("[0,]:Bool", temp->toString().c_str());
328 ASSERT_NO_THROW(temp = jit->Run(":Bool( (0,) )"));
329 ASSERT_STREQ("1", temp->toString().c_str());
330
331 ASSERT_ANY_THROW(temp = jit->Run(":Bool[...]( (,) )"));
332 ASSERT_ANY_THROW(temp = jit->Run(":Bool[_]( (,) )"));
333 ASSERT_NO_THROW(temp = jit->Run(":Bool( (,) )"));
334 ASSERT_STREQ("0", temp->toString().c_str());
335
336
337 ASSERT_NO_THROW(temp = jit->Run("counter = 0; [dict] <-> {counter, dict := ... dict; summa += counter}"));
338
339 ASSERT_NO_THROW(summa = jit->Run("summa"));
340 ASSERT_STREQ("250", summa->toString().c_str());
341
342 ASSERT_NO_THROW(temp = jit->Run("counter"));
343 ASSERT_TRUE(temp);
344 ASSERT_TRUE(temp->is_integer());
345 ASSERT_STREQ("50", temp->toString().c_str());
346
347 ASSERT_TRUE(dict->is_dictionary_type());
348 ASSERT_EQ(0, dict->size());
349
350
351 ASSERT_NO_THROW(dict = jit->Run("dict := (0,1,2,3,4,)"));
352 ObjPtr item;
353 ASSERT_NO_THROW(item = jit->Run("item := 0"));
354 ASSERT_EQ(0, item->GetValueAsInteger());
355 ASSERT_NO_THROW(item = jit->Run("item, dict := ... dict; item"));
356 ASSERT_EQ(0, item->GetValueAsInteger());
357 ASSERT_NO_THROW(item = jit->Run("item, dict := ... dict; item"));
358 ASSERT_EQ(1, item->GetValueAsInteger());
359 ASSERT_NO_THROW(item = jit->Run("item, dict := ... dict; item"));
360 ASSERT_EQ(2, item->GetValueAsInteger());
361
362
363 ASSERT_NO_THROW(summa = jit->Run("sum := 0"));
364 ASSERT_TRUE(summa);
365 ASSERT_STREQ("0", summa->toString().c_str());
366 ASSERT_NO_THROW(summa = jit->Run("sum += 1"));
367 ASSERT_TRUE(summa);
368 ASSERT_STREQ("1", summa->toString().c_str());
369 ASSERT_NO_THROW(summa = jit->Run("sum += 2"));
370 ASSERT_TRUE(summa);
371 ASSERT_STREQ("3", summa->toString().c_str());
372
373 ObjPtr cnt;
374 ASSERT_NO_THROW(dict = jit->Run("dict := (0,1,2,3,4,)"));
375
376 LOG_DEBUG("\n\n\n");
377
378 ASSERT_NO_THROW(temp = jit->Run("val::=1; item := 0; [dict] <-> {item, dict := ... dict; print('Sum: %s, Item: %s\\n', :StrChar(sum), :StrChar(item)); sum += item}"));
379 ASSERT_TRUE(temp);
380 ASSERT_STREQ("(,)", temp->GetValueAsString().c_str());
381
382 ASSERT_NO_THROW(summa = jit->Run("item"));
383 ASSERT_EQ(4, summa->GetValueAsInteger());
384
385 ASSERT_NO_THROW(summa = jit->Run("sum"));
386 ASSERT_EQ(13, summa->GetValueAsInteger());
387
388
389
390
391
392 ASSERT_NO_THROW(counter = jit->Run("counter := 55"));
393 ASSERT_EQ(55, counter->GetValueAsInteger());
394
395 ObjPtr tensor;
396 ASSERT_NO_THROW(tensor = jit->Run("tensor := [10,11,12,]"));
397 ASSERT_TRUE(tensor);
398 ASSERT_TRUE(tensor->is_tensor_type());
399 ASSERT_TRUE(tensor->GetValueAsBoolean());
400 ASSERT_EQ(3, tensor->size());
401 ASSERT_EQ(10, (*tensor)[0].second->GetValueAsInteger());
402 ASSERT_EQ(11, (*tensor)[1].second->GetValueAsInteger());
403 ASSERT_EQ(12, (*tensor)[2].second->GetValueAsInteger());
404
405 ASSERT_NO_THROW(temp = jit->Run("counter, tensor := ... tensor "));
406 ASSERT_TRUE(temp);
407 ASSERT_TRUE(temp->is_tensor_type());
408 ASSERT_EQ(2, temp->size());
409
410 ASSERT_NO_THROW(counter = jit->Run("counter"));
411 ASSERT_EQ(10, counter->GetValueAsInteger());
412
413 ASSERT_TRUE(tensor->is_tensor_type());
414 ASSERT_TRUE(tensor->GetValueAsBoolean());
415 ASSERT_EQ(2, tensor ->size());
416 ASSERT_EQ(11, (*tensor)[0].second->GetValueAsInteger());
417 ASSERT_EQ(12, (*tensor)[1].second->GetValueAsInteger());
418
419 ASSERT_NO_THROW(temp = jit->Run("counter, tensor := ... tensor "));
420 ASSERT_TRUE(temp);
421 ASSERT_TRUE(temp->is_tensor_type());
422 ASSERT_EQ(1, temp->size());
423
424 ASSERT_NO_THROW(counter = jit->Run("counter"));
425 ASSERT_EQ(11, counter->GetValueAsInteger());
426
427 ASSERT_TRUE(tensor->is_tensor_type());
428 ASSERT_TRUE(tensor->GetValueAsBoolean());
429 ASSERT_EQ(1, tensor ->size());
430 ASSERT_EQ(12, (*tensor)[0].second->GetValueAsInteger());
431
432 ASSERT_NO_THROW(temp = jit->Run("counter, tensor := ... tensor "));
433 ASSERT_TRUE(temp);
434 ASSERT_TRUE(temp->is_none_type());
435
436 ASSERT_NO_THROW(counter = jit->Run("counter"));
437 ASSERT_EQ(12, counter->GetValueAsInteger());
438
439 ASSERT_TRUE(tensor->is_none_type());
440 ASSERT_FALSE(tensor->GetValueAsBoolean());
441
442 ASSERT_ANY_THROW(temp = jit->Run("counter, tensor := ... tensor"));
443 // ASSERT_TRUE(temp);
444 // ASSERT_TRUE(temp->is_tensor_type());
445 // ASSERT_TRUE(temp->empty());
446 // ASSERT_FALSE(tensor->GetValueAsBoolean());
447 // ASSERT_TRUE(tensor->is_tensor_type());
448 // ASSERT_TRUE(tensor->empty());
449
450 ASSERT_NO_THROW(counter = jit->Run("counter"));
451 ASSERT_TRUE(counter);
452 ASSERT_TRUE(counter->empty());
453
454
455 ObjPtr summa2;
456 ObjPtr tensor2;
457 ObjPtr temp2;
458
459 ASSERT_NO_THROW(jit->Run("item2 := 0"));
460 ASSERT_NO_THROW(summa2 = jit->Run("summa := 0"));
461 ASSERT_NO_THROW(tensor2 = jit->Run("tensor := [10,20,30,40,50,60,]"));
462 ASSERT_NO_THROW(temp2 = jit->Run("[tensor] <-> {item2, tensor := ... tensor; summa += item2}"));
463 ASSERT_TRUE(temp2);
464 ASSERT_TRUE(temp2->is_none_type());
465
466 ASSERT_NO_THROW(summa2 = jit->Run("summa"));
467 ASSERT_EQ(210, summa2->GetValueAsInteger());
468
469 ASSERT_NO_THROW(temp2 = jit->Run("item2"));
470 ASSERT_EQ(60, temp2->GetValueAsInteger());
471
472 ASSERT_NO_THROW(tensor2 = jit->Run("tensor"));
473 ASSERT_TRUE(tensor2->is_none_type());
474 ASSERT_FALSE(tensor2->GetValueAsBoolean());
475
476 ObjPtr tensor_size;
477 ASSERT_NO_THROW(tensor_size = jit->Run("tensor_size := [10,20,30,40,]"));
478 ASSERT_EQ(4, tensor_size->size());
479 ASSERT_EQ(10, (*tensor_size)[0].second->GetValueAsInteger());
480 ASSERT_EQ(40, (*tensor_size)[3].second->GetValueAsInteger());
481
482 tensor_size->resize_(-10, nullptr);
483 ASSERT_EQ(10, tensor_size->size());
484 ASSERT_EQ(0, (*tensor_size)[0].second->GetValueAsInteger());
485 ASSERT_EQ(0, (*tensor_size)[5].second->GetValueAsInteger());
486 ASSERT_EQ(10, (*tensor_size)[6].second->GetValueAsInteger());
487 ASSERT_EQ(40, (*tensor_size)[9].second->GetValueAsInteger());
488
489}
490
491TEST(Alg, DISABLED_BreakContinue) {
492 RuntimePtr rt = RunTime::Init();
493 ASSERT_TRUE(rt);
494
495 const char * run_raw = ""
496 "count:=5;"
497 "[count<10]<->{+"
498 " [count>5]-->"
499 " ++100++;"
500 " ; "
501 " count+=1;"
502 "+};"
503 ;
504
505 ObjPtr count;
506 ObjPtr result;
507 ASSERT_NO_THROW(result = jit->Run(run_raw));
508 ASSERT_NO_THROW(count = jit->Run("count"));
509 ASSERT_TRUE(result);
510 ASSERT_TRUE(result->is_integer());
511 ASSERT_EQ(6, count->GetValueAsInteger());
512 ASSERT_EQ(100, result->GetValueAsInteger());
513
514 const char * run_macro = ""
515 "count:=5;"
516 "@while(count<10){+"
517 " @if(count>5){"
518 " @return(42);"
519 " };"
520 " count+=1;"
521 "+};"
522 "";
523
524 ASSERT_NO_THROW(result = jit->Run(run_macro));
525 ASSERT_NO_THROW(count = jit->Run("count"));
526 ASSERT_TRUE(result);
527 ASSERT_TRUE(result->is_integer());
528 ASSERT_EQ(6, count->GetValueAsInteger());
529 ASSERT_EQ(42, result->GetValueAsInteger());
530}
531
532TEST(Alg, Else) {
533
534 RuntimePtr rt = RunTime::Init();
535 ASSERT_TRUE(rt);
536
537 ObjPtr result = nullptr;
538
539 ASSERT_NO_THROW(result = jit->Run("42"));
540 ASSERT_TRUE(result);
541 ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
542 ASSERT_EQ(42, result->GetValueAsInteger()) << result->toString().c_str();
543
544 ASSERT_NO_THROW(result = jit->Run("[0]<->{ 43 },[...]-->{44}"));
545 ASSERT_TRUE(result);
546 ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
547 ASSERT_EQ(44, result->GetValueAsInteger()) << result->toString().c_str();
548
549 ASSERT_NO_THROW(result = jit->Run("{- --100-- -}"));
550 ASSERT_TRUE(result);
551 ASSERT_TRUE(result->is_return()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
552 ASSERT_STREQ(":RetMinus(100)", result->toString().c_str());
553
554 ASSERT_NO_THROW(result = jit->Run("**{- --100-- -}"));
555 ASSERT_TRUE(result);
556 ASSERT_STREQ("100", result->toString().c_str());
557
558 // ASSERT_NO_THROW(result = jit->Run("{- 100 -},[...]-->{200}"));
559 // ASSERT_TRUE(result);
560 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
561 // ASSERT_EQ(200, result->GetValueAsInteger()) << result->toString().c_str();
562 //
563 // ASSERT_NO_THROW(result = jit->Run("{+ 100 +},[...]-->{201}"));
564 // ASSERT_TRUE(result);
565 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
566 // ASSERT_EQ(201, result->GetValueAsInteger()) << result->toString().c_str();
567 //
568 // ASSERT_NO_THROW(result = jit->Run("{* 100 *},[...]-->{202}"));
569 // ASSERT_TRUE(result);
570 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
571 // ASSERT_EQ(202, result->GetValueAsInteger()) << result->toString().c_str();
572 //
573 // ASSERT_NO_THROW(result = jit->Run("{- 100 -},[...]-->{- 204 -}"));
574 // ASSERT_TRUE(result);
575 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
576 // ASSERT_EQ(204, result->GetValueAsInteger()) << result->toString().c_str();
577 //
578 // ASSERT_NO_THROW(result = jit->Run("{- 100 -},[...]-->{+ 205 +}"));
579 // ASSERT_TRUE(result);
580 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
581 // ASSERT_EQ(205, result->GetValueAsInteger()) << result->toString().c_str();
582 //
583 // ASSERT_NO_THROW(result = jit->Run("{* 100 *},[...]-->{* 206 *}"));
584 // ASSERT_TRUE(result);
585 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
586 // ASSERT_EQ(206, result->GetValueAsInteger()) << result->toString().c_str();
587 //
588 // ASSERT_NO_THROW(result = jit->Run("{* 100 *}:Test, [...]-->{* 207 *}"));
589 // ASSERT_TRUE(result);
590 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
591 // ASSERT_EQ(207, result->GetValueAsInteger()) << result->toString().c_str();
592 //
593 // ASSERT_NO_THROW(result = jit->Run("[1] --> 1, [1] --> 2, [...] -->3"));
594 // ASSERT_TRUE(result);
595 // ASSERT_TRUE(result->is_integral()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
596 // ASSERT_EQ(1, result->GetValueAsInteger()) << result->toString().c_str();
597 //
598 // ASSERT_NO_THROW(result = jit->Run("[0] --> 1, [1] --> 2, [...] -->3"));
599 // ASSERT_TRUE(result);
600 // ASSERT_TRUE(result->is_integral()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
601 // ASSERT_EQ(2, result->GetValueAsInteger()) << result->toString().c_str();
602 //
603 // ASSERT_NO_THROW(result = jit->Run("[0] --> 1, [0] --> 2, [...] -->3"));
604 // ASSERT_TRUE(result);
605 // ASSERT_TRUE(result->is_integral()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
606 // ASSERT_EQ(3, result->GetValueAsInteger()) << result->toString().c_str();
607}
608
609TEST(Alg, Return) {
610
611 RuntimePtr rt = RunTime::Init();
612 ASSERT_TRUE(rt);
613
614 ObjPtr result = nullptr;
615 ObjPtr value = nullptr;
616
617 try {
618 ASSERT_ANY_THROW(result = jit->Run("--"));
619 } catch (IntMinus &except) {
620 ASSERT_TRUE(except);
621 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(except.getType());
622 ASSERT_TRUE(except.m_return_obj);
623 ASSERT_TRUE(except.m_return_obj->is_none_type());
624 }
625 ASSERT_FALSE(result);
626
627 try {
628 ASSERT_ANY_THROW(result = jit->Run(":: --"));
629 } catch (IntAny &except) {
630 ASSERT_TRUE(except);
631 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(result->getType());
632 ASSERT_STREQ("::", except.m_value.c_str());
633 ASSERT_TRUE(except.m_return_obj);
634 ASSERT_TRUE(except.m_return_obj->is_none_type());
635 }
636 result = nullptr;
637
638 try {
639 ASSERT_ANY_THROW(result = jit->Run("--100--"));
640 } catch (IntMinus &except) {
641 ASSERT_TRUE(except);
642 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(except.getType());
643 ASSERT_TRUE(except.m_return_obj);
644 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
645 }
646 ASSERT_FALSE(result);
647
648 try {
649 ASSERT_ANY_THROW(result = jit->Run(":: --100--"));
650 } catch (IntAny &except) {
651 ASSERT_TRUE(except);
652 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
653 ASSERT_STREQ("::", except.m_value.c_str());
654 ASSERT_TRUE(except.m_return_obj);
655 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
656 }
657 result = nullptr;
658
659
660
661 try {
662 ASSERT_ANY_THROW(result = jit->Run("++"));
663 } catch (IntPlus &except) {
664 ASSERT_TRUE(except);
665 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
666 ASSERT_STREQ("::", except.m_value.c_str());
667 ASSERT_TRUE(except.m_return_obj);
668 ASSERT_TRUE(except.m_return_obj->is_none_type());
669 }
670 ASSERT_FALSE(result);
671
672 try {
673 ASSERT_ANY_THROW(result = jit->Run(":: ++"));
674 } catch (IntAny &except) {
675 ASSERT_TRUE(except);
676 ASSERT_STREQ("::", except.m_value.c_str());
677 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
678 ASSERT_TRUE(except.m_return_obj);
679 ASSERT_TRUE(except.m_return_obj->is_none_type());
680 }
681 result = nullptr;
682
683 try {
684 ASSERT_ANY_THROW(result = jit->Run("++100++"));
685 } catch (IntPlus &except) {
686 ASSERT_TRUE(except);
687 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
688 ASSERT_TRUE(except.m_return_obj);
689 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
690 }
691 ASSERT_FALSE(result);
692
693 try {
694 ASSERT_ANY_THROW(result = jit->Run(":: ++100++"));
695 } catch (IntAny &except) {
696 ASSERT_TRUE(except);
697 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
698 ASSERT_TRUE(except.m_return_obj);
699 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
700 }
701 result = nullptr;
702
703
704
705
706
707 try {
708 ASSERT_ANY_THROW(result = jit->Run("{ -- }"));
709 } catch (IntMinus &except) {
710 ASSERT_TRUE(except);
711 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(except.getType());
712 ASSERT_TRUE(except.m_return_obj);
713 ASSERT_TRUE(except.m_return_obj->is_none_type());
714 }
715 ASSERT_FALSE(result);
716
717 try {
718 ASSERT_NO_THROW(result = jit->Run("ns{ ns ++ }"));
719 ASSERT_TRUE(result);
720 ASSERT_TRUE(result->is_none_type());
721 } catch (IntAny &except) {
722 ASSERT_TRUE(0);
723 }
724 result = nullptr;
725
726 try {
727 ASSERT_NO_THROW(result = jit->Run("ns{ { ns ++ } }"));
728 ASSERT_TRUE(result);
729 ASSERT_TRUE(result->is_none_type());
730 } catch (IntAny &except) {
731 ASSERT_TRUE(0);
732 }
733 result = nullptr;
734
735
736 try {
737 ASSERT_ANY_THROW(result = jit->Run("{ ++100++; 200 }"));
738 } catch (IntPlus &except) {
739 ASSERT_TRUE(except);
740 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(except.getType());
741 ASSERT_TRUE(except.m_return_obj);
742 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
743 }
744 ASSERT_FALSE(result);
745
746 try {
747 ASSERT_NO_THROW(result = jit->Run("ns { ns ++100++; 200}"));
748 ASSERT_TRUE(result);
749 ASSERT_STREQ("100", result->toString().c_str());
750 } catch (IntAny &except) {
751 ASSERT_TRUE(0);
752 }
753 result = nullptr;
754
755 try {
756 ASSERT_NO_THROW(result = jit->Run("br:= 5; ns { br+=1; [br>10]--> ns:: ++ br ++; ns:: --br--; 200 }"));
757 ASSERT_TRUE(result);
758 ASSERT_STREQ("11", result->toString().c_str());
759 } catch (IntAny &except) {
760 ASSERT_TRUE(0);
761 }
762 result = nullptr;
763
764
765
766
767
768 // try {
769 // ASSERT_NO_THROW(result = jit->Run("{ ++100++ }"));
770 // } catch (Return &except) {
771 // ASSERT_TRUE(except);
772 // ASSERT_EQ(ObjType::RetPlus, except.getType());
773 // ASSERT_TRUE(except.m_return_obj);
774 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
775 // }
776 // ASSERT_FALSE(result);
777 //
778 // try {
779 // ASSERT_NO_THROW(result = jit->Run("{- ++100++ -}"));
780 // } catch (Return &except) {
781 // ASSERT_TRUE(except);
782 // ASSERT_EQ(ObjType::RetPlus, except.getType());
783 // ASSERT_TRUE(except.m_return_obj);
784 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
785 // }
786 // ASSERT_FALSE(result);
787 //
788 // try {
789 // ASSERT_NO_THROW(result = jit->Run("--'Тест'--"));
790 // } catch (Return &except) {
791 // ASSERT_TRUE(except);
792 // ASSERT_EQ(ObjType::RetMinus, except.getType());
793 // ASSERT_TRUE(except.m_return_obj);
794 // ASSERT_STREQ("'Тест'", except.m_return_obj->toString().c_str());
795 // }
796 // ASSERT_FALSE(result);
797 //
798 // try {
799 // ASSERT_NO_THROW(result = jit->Run("--:Int32--"));
800 // } catch (Return &except) {
801 // ASSERT_TRUE(except);
802 // ASSERT_EQ(ObjType::RetMinus, except.getType());
803 // ASSERT_TRUE(except.m_return_obj);
804 // ASSERT_EQ(ObjType::Type, except.m_return_obj->getType()) << toString(except.m_return_obj->getType());
805 // ASSERT_EQ(ObjType::Int32, except.m_return_obj->m_var_type_fixed) << toString(except.m_return_obj->m_var_type_fixed);
806 // }
807 // ASSERT_FALSE(result);
808 //
809 // try {
810 // ASSERT_NO_THROW(result = jit->Run("{ --:Int32-- }"));
811 // } catch (Return &except) {
812 // ASSERT_TRUE(except);
813 // ASSERT_EQ(ObjType::RetMinus, except.getType());
814 // ASSERT_TRUE(except.m_return_obj);
815 // ASSERT_EQ(ObjType::Type, except.m_return_obj->getType()) << toString(except.m_return_obj->getType());
816 // ASSERT_EQ(ObjType::Int32, except.m_return_obj->m_var_type_fixed) << toString(except.m_return_obj->m_var_type_fixed);
817 // }
818 // ASSERT_FALSE(result);
819 //
820 // try {
821 // ASSERT_NO_THROW(result = jit->Run("{+ --:Int32-- +}"));
822 // } catch (Return &except) {
823 // ASSERT_TRUE(except);
824 // ASSERT_EQ(ObjType::RetMinus, except.getType());
825 // ASSERT_TRUE(except.m_return_obj);
826 // ASSERT_EQ(ObjType::Type, except.m_return_obj->getType()) << toString(except.m_return_obj->getType());
827 // ASSERT_EQ(ObjType::Int32, except.m_return_obj->m_var_type_fixed) << toString(except.m_return_obj->m_var_type_fixed);
828 // }
829 // ASSERT_FALSE(result);
830 //
831 // try {
832 // ASSERT_NO_THROW(result = jit->Run("--:Error()--"));
833 // } catch (Return &except) {
834 // ASSERT_TRUE(except);
835 // ASSERT_EQ(ObjType::RetMinus, except.getType());
836 // ASSERT_TRUE(except.m_return_obj);
837 // ASSERT_EQ(ObjType::Error, except.m_return_obj->getType());
838 // ASSERT_STREQ(":Error()", except.m_return_obj->toString().c_str()) << except.m_return_obj->toString();
839 // }
840 // ASSERT_FALSE(result);
841 //
842 //
843 // try {
844 // ASSERT_NO_THROW(result = jit->Run("--:Error('ТЕКСТ')--"));
845 // } catch (Return &except) {
846 // ASSERT_TRUE(except);
847 // ASSERT_EQ(ObjType::RetMinus, except.getType());
848 // ASSERT_TRUE(except.m_return_obj);
849 // ASSERT_STREQ(":RetMinus(:Error('ТЕКСТ'))", except.toString().c_str());
850 // ASSERT_STREQ(":Error('ТЕКСТ')", except.m_return_obj->toString().c_str());
851 // }
852 // ASSERT_FALSE(result);
853 //
854 //
855 // try {
856 // ASSERT_NO_THROW(result = jit->Run("[1]--> ++100++"));
857 // } catch (Return &except) {
858 // ASSERT_TRUE(except);
859 // ASSERT_EQ(ObjType::RetPlus, except.getType()) << toString(except.getType());
860 // ASSERT_TRUE(except.m_return_obj);
861 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
862 // }
863 // ASSERT_FALSE(result);
864 //
865 // try {
866 // ASSERT_NO_THROW(result = jit->Run("[1]-->{ ++100++ }"));
867 // } catch (Return &except) {
868 // ASSERT_TRUE(except);
869 // ASSERT_EQ(ObjType::RetPlus, except.getType());
870 // ASSERT_TRUE(except.m_return_obj);
871 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
872 // }
873 // ASSERT_FALSE(result);
874 //
875 // try {
876 // ASSERT_NO_THROW(result = jit->Run("[1]-->{- ++100++ -}"));
877 // } catch (Return &except) {
878 // ASSERT_TRUE(except);
879 // ASSERT_EQ(ObjType::RetPlus, except.getType());
880 // ASSERT_TRUE(except.m_return_obj);
881 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
882 // }
883 // ASSERT_FALSE(result);
884 //
885 //
886 // result.reset();
887 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{count := 1; count += 1; count += 1; count += 1; count += 1;};")););
888 // ASSERT_TRUE(result);
889 // ASSERT_TRUE(result->is_integer()) << toString(result->getType());
890 // ASSERT_EQ(5, result->GetValueAsInteger());
891 //
892 // result.reset();
893 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{count := 1; count += 1; count += 1; count += 1; count += 1;}; 99")););
894 // ASSERT_TRUE(result);
895 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str();
896 // ASSERT_EQ(99, result->GetValueAsInteger());
897 //
898 // result.reset();
899 // ASSERT_ANY_THROW(ASSERT_NO_THROW(result = jit->Run("{count := 1; count += 1; count += 1; --55--; count += 1; count += 1;}; 5555")););
900 // ASSERT_FALSE(result);
901 //
902 // result.reset();
903 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{- count := 1; count += 1; count += 1; --77--; count += 1; count += 1; -}", nullptr, Context::CatchType::CATCH_ALL););
904 // ASSERT_TRUE(result);
905 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str();
906 // ASSERT_EQ(77, result->GetValueAsInteger());
907 //
908 // result.reset();
909 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{-count := 1; count += 1; count += 1; --77--; count += 1; count += 1;-}; 7777")););
910 // ASSERT_TRUE(result);
911 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str();
912 // ASSERT_EQ(7777, result->GetValueAsInteger());
913 //
914 // result.reset();
915 // ASSERT_ANY_THROW(ASSERT_NO_THROW(result = jit->Run("{ {count := 1; count += 1; count += 1; --:Error(88)--; count += 1; count += 1}; 8888; }")););
916 // ASSERT_FALSE(result);
917 //
918 // result.reset();
919 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {+count := 1; count += 1; count += 1; ++:Error(99)++; count += 1; count += 1+}; 888}")););
920 // ASSERT_TRUE(result);
921 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str();
922 // ASSERT_EQ(888, result->GetValueAsInteger());
923 //
924 // result.reset();
925 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {+count := 1; count += 1; count += 1; ++:Error(99)++; count += 1; count += 1+}; }")););
926 // ASSERT_TRUE(result);
927 // ASSERT_EQ(1, result->size()) << result->toString().c_str();
928 // ASSERT_EQ(99, (*result)[0].second->GetValueAsInteger()) << result->toString().c_str();
929 //
930 // result.reset();
931 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {-count := 1; count += 1; count += 1; --:Error(33)--; count += 1; count += 1-}; }")););
932 // ASSERT_TRUE(result);
933 // ASSERT_EQ(1, result->size()) << result->toString().c_str();
934 // ASSERT_EQ(33, (*result)[0].second->GetValueAsInteger()) << result->toString().c_str();
935 //
936 // result.reset();
937 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {*count := 1; count += 1; count += 1; --:Error(44)--; count += 1; count += 1*}; 9999; }")););
938 // ASSERT_TRUE(result);
939 // ASSERT_EQ(9999, result->GetValueAsInteger()) << result->toString().c_str();
940 //
941 // result.reset();
942 // // Не должен перехватытвать другой класс объекта
943 // ASSERT_ANY_THROW(ASSERT_NO_THROW(result = jit->Run("{ {*count := 1; count += 1; count += 1; --:Error(55)--; count += 1; count += 1*}:ErrorRunTime; }")););
944 // ASSERT_FALSE(result);
945 //
946 //
947 // ObjPtr test_err = ctx.m_runtime->GetTypeFromString(":Error"));
948 // ASSERT_TRUE(test_err->op_class_test(":Error", &ctx));
949 // ASSERT_FALSE(test_err->op_class_test(":ErrorRunTime", &ctx));
950 //
951 // ObjPtr test_rt = ctx.m_runtime->GetTypeFromString(":ErrorRunTime"));
952 // ASSERT_TRUE(test_rt->op_class_test(":ErrorRunTime", &ctx));
953 // ASSERT_TRUE(test_rt->op_class_test(":Error", &ctx));
954 //
955 // // result.reset();
956 // // // Не должен перехватытвать другой класс объекта, но его перехватывает внешний блок
957 // // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{* {*count := 1; count += 1; count += 1; --:Error(66)--; count += 1; count += 1*}:ErrorRunTime; 777; *}")););
958 // // ASSERT_TRUE(result);
959 // // ASSERT_TRUE(result->is_error());
960 // // ASSERT_STREQ(":RetMinus(:Error(66))", result->toString().c_str());
961 //
962 //
963 // result.reset();
964 // // Должен перехватытвать прерывание и вернуть его как обычный объект без исключения из внешнего блока
965 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {*count := 1; count += 1; count += 1; --:ErrorRunTime(77)--; count += 1; count += 1*}:ErrorRunTime }")););
966 // ASSERT_TRUE(result);
967 // ASSERT_EQ(1, result->size());
968 // ASSERT_EQ(77, (*result)[0].second->GetValueAsInteger());
969 //
970 // result.reset();
971 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {*count := 1; count += 1; count += 1; --:ErrorRunTime(88)--; count += 1; count += 1*}:ErrorRunTime; 9999; }")););
972 // ASSERT_TRUE(result);
973 // ASSERT_EQ(9999, result->GetValueAsInteger());
974 //
975 // result.reset();
976 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{{*count := 1; count += 1; count += 1; --:ErrorRunTime(77)--; count += 1; count += 1*}:Error }")););
977 // ASSERT_TRUE(result);
978 // ASSERT_EQ(1, result->size());
979 // ASSERT_EQ(77, (*result)[0].second->GetValueAsInteger());
980 //
981 // result.reset();
982 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{{*count := 1; count += 1; count += 1; --:ErrorRunTime(88)--; count += 1; count += 1*}:Error; 9999; }")););
983 // ASSERT_TRUE(result);
984 // ASSERT_EQ(9999, result->GetValueAsInteger());
985}
986
987#endif // UNITTEST
newlang::Obj::getType
ObjType getType()
Definition object.h:423
newlang::Obj::m_return_obj
ObjPtr m_return_obj
Definition object.h:1912
newlang::Obj::m_value
std::string m_value
Содержит байтовую строку или байтовый массив с данными для представления в нативном виде (Struct,...
Definition object.h:1905
result
int result
Definition lexer.l:367
LOG_DEBUG
#define LOG_DEBUG(...)
Definition logger.h:119
newlang
Definition nlc.h:59
newlang::ObjPtr
std::shared_ptr< Obj > ObjPtr
Definition variable.h:28
newlang::RuntimePtr
std::shared_ptr< RunTime > RuntimePtr
Definition types.h:242
newlang::toString
const char * toString(TermID type)
Definition term.h:126
warning_pop.h
warning_push.h
Generated by doxygen 1.11.0