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