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>
14 bool
16 {
18 }
20 bool
22 {
23 /* Открытые массивы всегда размером 0 */
26 }
28 bool
30 {
32 }
34 bool
36 {
38 }
40 bool
42 {
44 }
46 bool
48 {
50 }
52 bool
54 {
56 }
58 bool
60 {
63 }
65 bool
67 {
69 }
71 bool
73 {
75 }
77 bool
79 {
81 }
83 bool
85 {
87 }
89 bool
91 {
93 }
95 bool
97 {
99 }
101 bool
103 {
105 }
107 bool
109 {
111 }
113 bool
115 {
117 }
119 bool
121 {
123 }
125 bool
127 {
129 }
131 bool
133 {
135 }
139 bool
141 {
142 /* Две переменные a и b с типами Ta и Tb имеют одинаковый тип, если */
143 /* 1. Ta и Tb оба обозначены одним и тем же идентификатором типа, или */
144 /* 2. Ta объявлен равным Tb в объявлении типа вида Ta = Tb, или */
145 /* 3. a и b появляются в одном и том же списке идентификаторов переменных, полей записи */
146 /* или объявлении формальных параметров и не являются открытыми массивами. */
149 }
151 bool
153 {
154 /* Два списка формальных параметров совпадают если */
155 /* 1. они имеют одинаковое количество параметров, и */
156 /* 2. они имеют или одинаковый тип результата функции или не имеют никакого, и */
157 /* 3. параметры в соответствующих позициях имеют равные типы, и */
158 /* 4. параметры в соответствующих позициях - оба или параметры-значения */
159 /* или параметры-переменные. */
162 {
164 }
167 {
169 }
175 {
177 {
179 }
182 {
184 }
188 }
191 }
193 bool
195 {
196 /* Два типа Ta, и Tb равны, если */
197 /* 1. Ta и Tb - одинаковые типы, или */
198 /* 2. Ta и Tb - типы открытый массив с равными типами элементов, или */
199 /* 3. Ta и Tb - процедурные типы, чьи списки формальных параметров совпадают. */
202 || (oberon_is_open_array(a) && oberon_is_open_array(b) && oberon_is_some_types(a -> base, b -> base))
203 || (oberon_is_procedure_type(a) && oberon_is_procedure_type(b) && oberon_is_some_procedure_signatures(a, b));
204 }
206 bool
208 {
209 /* a поглощает b */
210 /* LONGREAL >= REAL >= LONGINT >= INTEGER >= SHORTINT */
212 /*
213 printf("oberon_incluses_type: a %i %i\n", a -> class, a -> size);
214 printf("oberon_incluses_type: b %i %i\n", b -> class, b -> size);
215 */
218 {
220 {
222 }
224 {
226 }
227 }
229 {
231 {
233 }
234 }
237 }
239 bool
241 {
242 /* Тип Tb есть расширение типа Ta (Ta есть базовый тип Tb) если */
243 /* 1. Ta и Tb - одинаковые типы, или */
244 /* 2. Tb - непосредственное расширение типа, являющегося расширением Ta */
245 /* Если Pa = POINTER TO Ta и Pb = POINTER TO Tb, то Pb есть расширение Pa */
246 /* (Pa есть базовый тип Pb), если Tb есть расширение Ta. */
249 {
252 }
255 {
257 }
260 {
262 }
265 {
267 {
269 }
271 }
274 }
276 bool
278 {
279 return e -> result -> class == OBERON_TYPE_STRING && e -> is_item && e -> item.mode == MODE_STRING;
280 }
282 bool
284 {
286 }
288 bool
290 {
291 /* Выражение e типа Te совместимо по присваиванию с переменной v типа Tv, */
292 /* если выполнено одно из следующих условий: */
293 /* 1. Te и Tv - одинаковые типы; */
294 /* 2. Te и Tv - числовые типы и Tv поглощает Te; */
295 /* 3. Te и Tv - типы запись, Te есть расширение Tv, а v имеет динамический тип Tv; */
296 /* 4. Te и Tv - типы указатель и Te - расширение Tv; */
297 /* 5. Tv - тип указатель или процедурный тип, а e - NIL; */
298 /* 6. Tv - ARRAY n OF CHAR, e - строковая константа из m символов и m < n; */
299 /* 7. Tv - процедурный тип, а e - имя процедуры, чьи формальные параметры */
300 /* совпадают с параметрами Tv. */
301 /* Доп: Tv - символ, е - строковая константа из одного символа */
303 /* SYSTEM: Переменным типа BYTE можно присваивать значения переменных типа CHAR или SHORTINT. */
304 /* SYSTEM: Переменным типа PTR могут быть присвоены значения переменных-указателей любого типа. */
313 || (oberon_is_array_of_char_type(Tv) && !oberon_is_open_array(Tv) && oberon_is_const_string(e) && (strlen(e -> item.string) < Tv -> size))
314 || (oberon_is_procedure_type(Tv) && e -> is_item && e -> item.var -> class == OBERON_CLASS_PROC && oberon_is_some_procedure_signatures(Tv, e -> result))
318 }
320 static bool
322 {
323 /* Фактический параметр a типа Ta является совместимым массивом для формального параметра f типа Tf если */
324 /* 1. Tf и Ta - одинаковые типы или */
325 /* 2. Tf - открытый массив, Ta - любой массив, а типы их элементов - совместимые массивы или */
326 /* 3. f - параметр-значение типа ARRAY OF CHAR, а фактический параметр a - строка. */
329 || (oberon_is_open_array(Tf) && oberon_is_array_type(Ta) && oberon_is_compatible_arrays_types(Tf -> base, Ta -> base));
330 }
332 bool
334 {
340 }
342 void
344 {
346 {
348 }
349 }
351 bool
353 {
354 if(token == EQUAL || token == NEQ || token == LESS || token == LEQ || token == GREAT || token == GEQ)
355 {
358 {
360 }
361 else
362 {
364 }
365 }
366 else
367 {
369 }
370 }
372 bool
374 {
376 {
378 {
380 }
382 {
384 }
385 }
387 {
389 {
391 }
392 }
394 {
396 {
398 }
399 }
401 {
403 {
405 }
407 {
409 }
412 {
414 }
416 {
418 }
420 {
422 }
425 {
427 }
428 }
430 {
432 {
434 }
436 {
438 }
441 {
443 }
444 }
446 {
448 {
450 }
451 }
453 {
455 {
457 }
458 }
461 }
463 bool
465 {
466 /* Пусть Tf - тип формального параметра f (не открытого массива) */
467 /* и Ta - тип соответствующего фактического параметра a. */
468 /* Для параметров-переменных Ta и Tf должны быть одинаковыми типами */
469 /* или Tf должен быть типом запись, а Ta - расширением Tf. */
471 /* SYSTEM: Если формальный параметр-переменная имеет тип ARRAY OF BYTE, */
472 /* то соответствующий фактический параметр может иметь любой тип. */
473 /* SYSTEM: Если формальный параметр-переменная имеет тип PTR, */
474 /* фактический параметр может быть указателем любого типа. */
481 }
483 void
484 oberon_check_compatible_var_param(oberon_context_t * ctx, oberon_type_t * Tf, oberon_type_t * Ta)
485 {
487 {
489 }
490 }
492 void
494 {
496 {
498 }
499 }
501 void
502 oberon_check_compatible_bin_expr(oberon_context_t * ctx, int token, oberon_expr_t * a, oberon_expr_t * b)
503 {
505 {
507 }
508 }
510 void
511 oberon_check_assignment_compatible(oberon_context_t * ctx, oberon_expr_t * e, oberon_type_t * Tv)
512 {
514 {
516 }
517 }
519 void
521 {
523 {
525 }
526 }
528 oberon_type_t *
530 {
532 {
534 }
535 else
536 {
538 }
539 }
541 oberon_type_t *
543 {
546 {
548 }
549 else
550 {
552 }
553 }