4291f6c5f402d97b9e5c859056dd107099b31895
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stdarg.h>
4 #include <ctype.h>
5 #include <string.h>
6 #include <assert.h>
7 #include <stdbool.h>
8 #include <math.h>
16 bool
18 {
20 }
22 bool
24 {
25 /* Открытые массивы всегда размером 0 */
28 }
30 bool
32 {
34 }
36 bool
38 {
40 }
42 bool
44 {
46 }
48 bool
50 {
52 }
54 bool
56 {
58 }
60 bool
62 {
65 }
67 bool
69 {
71 }
73 bool
75 {
77 }
79 bool
81 {
83 }
85 bool
87 {
89 }
91 bool
93 {
95 }
97 bool
99 {
101 }
103 bool
105 {
107 }
109 bool
111 {
113 }
115 bool
117 {
119 }
121 bool
123 {
125 }
127 bool
129 {
131 }
133 bool
135 {
137 }
141 bool
143 {
144 /* Две переменные a и b с типами Ta и Tb имеют одинаковый тип, если */
145 /* 1. Ta и Tb оба обозначены одним и тем же идентификатором типа, или */
146 /* 2. Ta объявлен равным Tb в объявлении типа вида Ta = Tb, или */
147 /* 3. a и b появляются в одном и том же списке идентификаторов переменных, полей записи */
148 /* или объявлении формальных параметров и не являются открытыми массивами. */
151 }
153 bool
155 {
156 /* Два списка формальных параметров совпадают если */
157 /* 1. они имеют одинаковое количество параметров, и */
158 /* 2. они имеют или одинаковый тип результата функции или не имеют никакого, и */
159 /* 3. параметры в соответствующих позициях имеют равные типы, и */
160 /* 4. параметры в соответствующих позициях - оба или параметры-значения */
161 /* или параметры-переменные. */
164 {
166 }
169 {
171 }
177 {
179 {
181 }
184 {
186 }
190 }
193 }
195 bool
197 {
198 /* Два типа Ta, и Tb равны, если */
199 /* 1. Ta и Tb - одинаковые типы, или */
200 /* 2. Ta и Tb - типы открытый массив с равными типами элементов, или */
201 /* 3. Ta и Tb - процедурные типы, чьи списки формальных параметров совпадают. */
204 || (oberon_is_open_array(a) && oberon_is_open_array(b) && oberon_is_some_types(a -> base, b -> base))
205 || (oberon_is_procedure_type(a) && oberon_is_procedure_type(b) && oberon_is_some_procedure_signatures(a, b));
206 }
208 bool
210 {
211 /* a поглощает b */
212 /* LONGREAL >= REAL >= LONGINT >= INTEGER >= SHORTINT */
214 /*
215 printf("oberon_incluses_type: a %i %i\n", a -> class, a -> size);
216 printf("oberon_incluses_type: b %i %i\n", b -> class, b -> size);
217 */
220 {
222 {
224 }
226 {
228 }
229 }
231 {
233 {
235 }
236 }
239 }
241 bool
243 {
244 /* Тип Tb есть расширение типа Ta (Ta есть базовый тип Tb) если */
245 /* 1. Ta и Tb - одинаковые типы, или */
246 /* 2. Tb - непосредственное расширение типа, являющегося расширением Ta */
247 /* Если Pa = POINTER TO Ta и Pb = POINTER TO Tb, то Pb есть расширение Pa */
248 /* (Pa есть базовый тип Pb), если Tb есть расширение Ta. */
251 {
254 }
257 {
259 }
262 {
264 }
267 {
269 {
271 }
273 }
276 }
278 bool
280 {
281 return e -> result -> class == OBERON_TYPE_STRING && e -> is_item && e -> item.mode == MODE_STRING;
282 }
284 bool
286 {
287 /* Выражение e типа Te совместимо по присваиванию с переменной v типа Tv, */
288 /* если выполнено одно из следующих условий: */
289 /* 1. Te и Tv - одинаковые типы; */
290 /* 2. Te и Tv - числовые типы и Tv поглощает Te; */
291 /* 3. Te и Tv - типы запись, Te есть расширение Tv, а v имеет динамический тип Tv; */
292 /* 4. Te и Tv - типы указатель и Te - расширение Tv; */
293 /* 5. Tv - тип указатель или процедурный тип, а e - NIL; */
294 /* 6. Tv - ARRAY n OF CHAR, e - строковая константа из m символов и m < n; */
295 /* 7. Tv - процедурный тип, а e - имя процедуры, чьи формальные параметры */
296 /* совпадают с параметрами Tv. */
297 /* Доп: Tv - символ, е - строковая константа из одного символа */
299 /* SYSTEM: переменным типа BYTE можно присваивать значения переменных типа CHAR или SHORTINT. */
300 /* SYSTEM: Переменным типа PTR могут быть присвоены значения переменных-указателей любого типа. */
309 || (oberon_is_array_of_char_type(Tv) && !oberon_is_open_array(Tv) && oberon_is_const_string(e) && (strlen(e -> item.string) < Tv -> size))
310 || (oberon_is_procedure_type(Tv) && e -> is_item && e -> item.var -> class == OBERON_CLASS_PROC && oberon_is_some_procedure_signatures(Tv, e -> result))
314 }
316 static bool
318 {
319 /* Фактический параметр a типа Ta является совместимым массивом для формального параметра f типа Tf если */
320 /* 1. Tf и Ta - одинаковые типы или */
321 /* 2. Tf - открытый массив, Ta - любой массив, а типы их элементов - совместимые массивы или */
322 /* 3. f - параметр-значение типа ARRAY OF CHAR, а фактический параметр a - строка. */
325 || (oberon_is_open_array(Tf) && oberon_is_array_type(Ta) && oberon_is_compatible_arrays_types(Tf -> base, Ta -> base));
326 }
328 bool
330 {
336 }
338 void
340 {
342 {
344 }
345 }
347 bool
349 {
351 {
353 {
355 }
357 {
359 }
360 }
362 {
364 {
366 }
367 }
369 {
371 {
373 }
374 }
376 {
378 {
380 }
382 {
384 }
387 {
389 }
391 {
393 }
395 {
397 }
398 else if((oberon_is_nil_type(a) || oberon_is_pointer_to_record(a) || oberon_is_procedure_type(a))
400 {
402 }
403 }
405 {
407 {
409 }
411 {
413 }
416 {
418 }
419 }
421 {
423 {
425 }
426 }
428 {
430 {
432 }
433 }
436 }
438 bool
440 {
441 /* Пусть Tf - тип формального параметра f (не открытого массива) */
442 /* и Ta - тип соответствующего фактического параметра a. */
443 /* Для параметров-переменных Ta и Tf должны быть одинаковыми типами */
444 /* или Tf должен быть типом запись, а Ta - расширением Tf. */
446 /* SYSTEM: Если формальный параметр-переменная имеет тип ARRAY OF BYTE, */
447 /* то соответствующий фактический параметр может иметь любой тип. */
448 /* SYSTEM: Если формальный параметр-переменная имеет тип PTR, */
449 /* фактический параметр может быть указателем любого типа. */
455 }
457 void
458 oberon_check_compatible_var_param(oberon_context_t * ctx, oberon_type_t * Tf, oberon_type_t * Ta)
459 {
461 {
463 }
464 }
466 void
468 {
470 {
472 }
473 }
475 void
476 oberon_check_compatible_bin_expr_types(oberon_context_t * ctx, int token, oberon_type_t * a, oberon_type_t * b)
477 {
479 {
481 }
482 }
484 void
485 oberon_check_assignment_compatible(oberon_context_t * ctx, oberon_expr_t * e, oberon_type_t * Tv)
486 {
488 {
490 }
491 }
493 void
495 {
497 {
499 }
500 }
502 oberon_type_t *
504 {
506 {
508 }
509 else
510 {
512 }
513 }
515 oberon_type_t *
517 {
520 {
522 }
523 else
524 {
526 }
527 }