a30849986c45fa9d2054587864c280b9e7a5cc23
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 {
288 }
290 bool
292 {
293 /* Выражение e типа Te совместимо по присваиванию с переменной v типа Tv, */
294 /* если выполнено одно из следующих условий: */
295 /* 1. Te и Tv - одинаковые типы; */
296 /* 2. Te и Tv - числовые типы и Tv поглощает Te; */
297 /* 3. Te и Tv - типы запись, Te есть расширение Tv, а v имеет динамический тип Tv; */
298 /* 4. Te и Tv - типы указатель и Te - расширение Tv; */
299 /* 5. Tv - тип указатель или процедурный тип, а e - NIL; */
300 /* 6. Tv - ARRAY n OF CHAR, e - строковая константа из m символов и m < n; */
301 /* 7. Tv - процедурный тип, а e - имя процедуры, чьи формальные параметры */
302 /* совпадают с параметрами Tv. */
303 /* Доп: Tv - символ, е - строковая константа из одного символа */
305 /* SYSTEM: Переменным типа BYTE можно присваивать значения переменных типа CHAR или SHORTINT. */
306 /* SYSTEM: Переменным типа PTR могут быть присвоены значения переменных-указателей любого типа. */
315 || (oberon_is_array_of_char_type(Tv) && !oberon_is_open_array(Tv) && oberon_is_const_string(e) && (strlen(e -> item.string) < Tv -> size))
316 || (oberon_is_procedure_type(Tv) && e -> is_item && e -> item.var -> class == OBERON_CLASS_PROC && oberon_is_some_procedure_signatures(Tv, e -> result))
320 }
322 static bool
324 {
325 /* Фактический параметр a типа Ta является совместимым массивом для формального параметра f типа Tf если */
326 /* 1. Tf и Ta - одинаковые типы или */
327 /* 2. Tf - открытый массив, Ta - любой массив, а типы их элементов - совместимые массивы или */
328 /* 3. f - параметр-значение типа ARRAY OF CHAR, а фактический параметр a - строка. */
331 || (oberon_is_open_array(Tf) && oberon_is_array_type(Ta) && oberon_is_compatible_arrays_types(Tf -> base, Ta -> base));
332 }
334 bool
336 {
342 }
344 void
346 {
348 {
350 }
351 }
353 bool
355 {
356 if(token == EQUAL || token == NEQ || token == LESS || token == LEQ || token == GREAT || token == GEQ)
357 {
360 {
362 }
363 else
364 {
366 }
367 }
368 else
369 {
371 }
372 }
374 bool
376 {
378 {
380 {
382 }
384 {
386 }
387 }
389 {
391 {
393 }
394 }
396 {
398 {
400 }
401 }
403 {
405 {
407 }
409 {
411 }
414 {
416 }
418 {
420 }
422 {
424 }
427 {
429 }
430 }
432 {
434 {
436 }
438 {
440 }
443 {
445 }
446 }
448 {
450 {
452 }
453 }
455 {
457 {
459 }
460 }
463 }
465 bool
467 {
468 /* Пусть Tf - тип формального параметра f (не открытого массива) */
469 /* и Ta - тип соответствующего фактического параметра a. */
470 /* Для параметров-переменных Ta и Tf должны быть одинаковыми типами */
471 /* или Tf должен быть типом запись, а Ta - расширением Tf. */
473 /* SYSTEM: Если формальный параметр-переменная имеет тип ARRAY OF BYTE, */
474 /* то соответствующий фактический параметр может иметь любой тип. */
475 /* SYSTEM: Если формальный параметр-переменная имеет тип PTR, */
476 /* фактический параметр может быть указателем любого типа. */
483 }
485 void
486 oberon_check_compatible_var_param(oberon_context_t * ctx, oberon_type_t * Tf, oberon_type_t * Ta)
487 {
489 {
491 }
492 }
494 void
496 {
498 {
500 }
501 }
503 void
504 oberon_check_compatible_bin_expr(oberon_context_t * ctx, int token, oberon_expr_t * a, oberon_expr_t * b)
505 {
507 {
509 }
510 }
512 void
513 oberon_check_assignment_compatible(oberon_context_t * ctx, oberon_expr_t * e, oberon_type_t * Tv)
514 {
516 {
518 }
519 }
521 void
523 {
525 {
527 }
528 }
530 oberon_type_t *
532 {
534 {
536 }
537 else
538 {
540 }
541 }
543 oberon_type_t *
545 {
548 {
550 }
551 else
552 {
554 }
555 }