Вики проекта PascalABC.NET - Вклад [ru]

Начало. Возможные ошибки

2015-08-26T09:39:35Z

Ulysses: /* Ошибка ввода */ + ReadInteger

__NOTOC__
=== Неописанная переменная ===
<source lang="pascal">begin
S := 1; // Неизвестное имя S
end.</source>
Все используемые переменные должны быть предварительно описаны с помощью ключевого слова '''var''' (внутри блока begin/end или, что обычно хуже, в разделе описаний вначале программы).

=== Отсутствующая ; ===
<source lang="pascal">
begin
var S: integer
S := 1; // Компилятор здесь скажет: Ожидалась ; — имеется ввиду предыдущая строка!
end.</source>

<source lang="pascal">
begin
var S := 1
S := S + 1 // Аналогично: проблема на предыдущей строке, а на текущей нет, потому что после неё идёт end.
end.</source>
Очень частая ошибка у начинающих. Курсор, как правило, позиционируется '''в начале следующей строки'''.

=== Несовместимость типов при присваивании ===
<source lang="pascal">
begin
var S: integer := 1.3; // Нельзя преобразовать тип real к integer
end.</source>
Безболезненно можно присваивать только данные одного типа. Если данные - разных типов, то в редких случаях можно преобразовать данные одного типа в данные другого. Например, целое можно преобразовать в вещественное, а символ - в строку. Обратные преобразования не допускаются.

Чтобы не ошибаться в подобных простых случаях в Паскале есть следующая '''краткая''' форма объявления и инициализации переменной:
<source lang="pascal">
begin
var S := 1.3; // Тип real будет выведен компилятором автоматически
end.</source>

=== Отсутствие закрывающего апострофа литеральной строки ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln('Результат сложения равен =, x + y); // Не хватает закрывающего апострофа
end.</source>
Закрыть апостроф надо на той же строке, где расположен открывающий апостроф

=== Ошибки расстановки запятых и апострофов при выводе строк и выражений ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln(x, '+,' y, '=', x+y); // Неверная расстановка запятых и апострофов
end.</source>
Слишком много запятых и апострофов рядом, потому начинающие часто путаются :)
Надо уяснить правила:
*запятые разделяют разные элементы вывода
*все, что находится в апострофах, будет выведено на экран без изменений

=== Ошибка ввода ===
<source lang="pascal">
begin
var x: integer;
read(x); // введите блаблабла и посмотрите, что получится
end.</source>
Это - ошибка во время выполнения. Программа пытается преобразовать введенную строку в число, не может это сделать и завершается с ошибкой.

Аналогичный фрагмент в более современном и предпочтительном синтаксисе:
<source lang="pascal">
begin
var x := ReadInteger;
end.</source>

=== Ошибка неинициализированной переменной ===
<source lang="pascal">
begin
var x: integer;
// Забыли инициализировать или ввести x
var r := x * x; // r получает тип integer
writeln('Квадрат числа ', x, ' = ', r);
end.</source>
Перед использованием любую переменную надо ввести или присвоить ей начальное значение. Это действие называется инициализацией переменной.

=== Деление на 0 ===
<source lang="pascal">
begin
var x := 0;
var c := 666 div x; // Здесь происходит деление на 0
end.</source>
Если во время выполнения программа выполнит деление на 0, то она завершится с ошибкой.

=== Корень из отрицательного числа ===
<source lang="pascal">begin
writeln(sqrt(-1)); // Корень из отрицательного числа
end.</source>
В обычном Паскале возникает ошибка времени выполнения.
В PascalABC.NET выводится NaN - Not a Number

== Ссылки ==
*[[Программы для начинающих]]
*[http://pascalabc.net/ru/programmyi-i-algoritmyi-dlya-nachinayuschih.html Сайт PascalABC.NET: Программы и алгоритмы для начинающих]

Начало. Возможные ошибки

2015-08-26T09:38:37Z

Ulysses: /* Деление на 0 */ убираем типы, работает автовывод

__NOTOC__
=== Неописанная переменная ===
<source lang="pascal">begin
S := 1; // Неизвестное имя S
end.</source>
Все используемые переменные должны быть предварительно описаны с помощью ключевого слова '''var''' (внутри блока begin/end или, что обычно хуже, в разделе описаний вначале программы).

=== Отсутствующая ; ===
<source lang="pascal">
begin
var S: integer
S := 1; // Компилятор здесь скажет: Ожидалась ; — имеется ввиду предыдущая строка!
end.</source>

<source lang="pascal">
begin
var S := 1
S := S + 1 // Аналогично: проблема на предыдущей строке, а на текущей нет, потому что после неё идёт end.
end.</source>
Очень частая ошибка у начинающих. Курсор, как правило, позиционируется '''в начале следующей строки'''.

=== Несовместимость типов при присваивании ===
<source lang="pascal">
begin
var S: integer := 1.3; // Нельзя преобразовать тип real к integer
end.</source>
Безболезненно можно присваивать только данные одного типа. Если данные - разных типов, то в редких случаях можно преобразовать данные одного типа в данные другого. Например, целое можно преобразовать в вещественное, а символ - в строку. Обратные преобразования не допускаются.

Чтобы не ошибаться в подобных простых случаях в Паскале есть следующая '''краткая''' форма объявления и инициализации переменной:
<source lang="pascal">
begin
var S := 1.3; // Тип real будет выведен компилятором автоматически
end.</source>

=== Отсутствие закрывающего апострофа литеральной строки ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln('Результат сложения равен =, x + y); // Не хватает закрывающего апострофа
end.</source>
Закрыть апостроф надо на той же строке, где расположен открывающий апостроф

=== Ошибки расстановки запятых и апострофов при выводе строк и выражений ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln(x, '+,' y, '=', x+y); // Неверная расстановка запятых и апострофов
end.</source>
Слишком много запятых и апострофов рядом, потому начинающие часто путаются :)
Надо уяснить правила:
*запятые разделяют разные элементы вывода
*все, что находится в апострофах, будет выведено на экран без изменений

=== Ошибка ввода ===
<source lang="pascal">
begin
var x: integer;
read(x); // введите блаблабла и посмотрите, что получится
end.</source>
Это - ошибка во время выполнения. Программа пытается преобразовать введенную строку в число, не может это сделать и завершается с ошибкой

=== Ошибка неинициализированной переменной ===
<source lang="pascal">
begin
var x: integer;
// Забыли инициализировать или ввести x
var r := x * x; // r получает тип integer
writeln('Квадрат числа ', x, ' = ', r);
end.</source>
Перед использованием любую переменную надо ввести или присвоить ей начальное значение. Это действие называется инициализацией переменной.

=== Деление на 0 ===
<source lang="pascal">
begin
var x := 0;
var c := 666 div x; // Здесь происходит деление на 0
end.</source>
Если во время выполнения программа выполнит деление на 0, то она завершится с ошибкой.

=== Корень из отрицательного числа ===
<source lang="pascal">begin
writeln(sqrt(-1)); // Корень из отрицательного числа
end.</source>
В обычном Паскале возникает ошибка времени выполнения.
В PascalABC.NET выводится NaN - Not a Number

== Ссылки ==
*[[Программы для начинающих]]
*[http://pascalabc.net/ru/programmyi-i-algoritmyi-dlya-nachinayuschih.html Сайт PascalABC.NET: Программы и алгоритмы для начинающих]

Начало. Возможные ошибки

2015-08-26T09:37:41Z

Ulysses: /* Несовместимость типов при присваивании */

__NOTOC__
=== Неописанная переменная ===
<source lang="pascal">begin
S := 1; // Неизвестное имя S
end.</source>
Все используемые переменные должны быть предварительно описаны с помощью ключевого слова '''var''' (внутри блока begin/end или, что обычно хуже, в разделе описаний вначале программы).

=== Отсутствующая ; ===
<source lang="pascal">
begin
var S: integer
S := 1; // Компилятор здесь скажет: Ожидалась ; — имеется ввиду предыдущая строка!
end.</source>

<source lang="pascal">
begin
var S := 1
S := S + 1 // Аналогично: проблема на предыдущей строке, а на текущей нет, потому что после неё идёт end.
end.</source>
Очень частая ошибка у начинающих. Курсор, как правило, позиционируется '''в начале следующей строки'''.

=== Несовместимость типов при присваивании ===
<source lang="pascal">
begin
var S: integer := 1.3; // Нельзя преобразовать тип real к integer
end.</source>
Безболезненно можно присваивать только данные одного типа. Если данные - разных типов, то в редких случаях можно преобразовать данные одного типа в данные другого. Например, целое можно преобразовать в вещественное, а символ - в строку. Обратные преобразования не допускаются.

Чтобы не ошибаться в подобных простых случаях в Паскале есть следующая '''краткая''' форма объявления и инициализации переменной:
<source lang="pascal">
begin
var S := 1.3; // Тип real будет выведен компилятором автоматически
end.</source>

=== Отсутствие закрывающего апострофа литеральной строки ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln('Результат сложения равен =, x + y); // Не хватает закрывающего апострофа
end.</source>
Закрыть апостроф надо на той же строке, где расположен открывающий апостроф

=== Ошибки расстановки запятых и апострофов при выводе строк и выражений ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln(x, '+,' y, '=', x+y); // Неверная расстановка запятых и апострофов
end.</source>
Слишком много запятых и апострофов рядом, потому начинающие часто путаются :)
Надо уяснить правила:
*запятые разделяют разные элементы вывода
*все, что находится в апострофах, будет выведено на экран без изменений

=== Ошибка ввода ===
<source lang="pascal">
begin
var x: integer;
read(x); // введите блаблабла и посмотрите, что получится
end.</source>
Это - ошибка во время выполнения. Программа пытается преобразовать введенную строку в число, не может это сделать и завершается с ошибкой

=== Ошибка неинициализированной переменной ===
<source lang="pascal">
begin
var x: integer;
// Забыли инициализировать или ввести x
var r := x * x; // r получает тип integer
writeln('Квадрат числа ', x, ' = ', r);
end.</source>
Перед использованием любую переменную надо ввести или присвоить ей начальное значение. Это действие называется инициализацией переменной.

=== Деление на 0 ===
<source lang="pascal">
begin
var x: integer := 0;
var c: integer := 666 div x; // Здесь происходит деление на 0
end.</source>
Если во время выполнения программа выполнит деление на 0, то она завершится с ошибкой.

=== Корень из отрицательного числа ===
<source lang="pascal">begin
writeln(sqrt(-1)); // Корень из отрицательного числа
end.</source>
В обычном Паскале возникает ошибка времени выполнения.
В PascalABC.NET выводится NaN - Not a Number

== Ссылки ==
*[[Программы для начинающих]]
*[http://pascalabc.net/ru/programmyi-i-algoritmyi-dlya-nachinayuschih.html Сайт PascalABC.NET: Программы и алгоритмы для начинающих]

Начало. Возможные ошибки

2015-08-26T09:36:18Z

Ulysses: /* Отсутствующая ; */

__NOTOC__
=== Неописанная переменная ===
<source lang="pascal">begin
S := 1; // Неизвестное имя S
end.</source>
Все используемые переменные должны быть предварительно описаны с помощью ключевого слова '''var''' (внутри блока begin/end или, что обычно хуже, в разделе описаний вначале программы).

=== Отсутствующая ; ===
<source lang="pascal">
begin
var S: integer
S := 1; // Компилятор здесь скажет: Ожидалась ; — имеется ввиду предыдущая строка!
end.</source>

<source lang="pascal">
begin
var S := 1
S := S + 1 // Аналогично: проблема на предыдущей строке, а на текущей нет, потому что после неё идёт end.
end.</source>
Очень частая ошибка у начинающих. Курсор, как правило, позиционируется '''в начале следующей строки'''.

=== Несовместимость типов при присваивании ===
<source lang="pascal">
begin
var S: integer := 1.3; // Нельзя преобразовать тип real к integer
end.</source>
Безболезненно можно присваивать только данные одного типа. Если данные - разных типов, то в редких случаях можно преобразовать данные одного типа в данные другого. Например, целое можно преобразовать в вещественное, а символ - в строку. Обратные преобразования не допускаются.

=== Отсутствие закрывающего апострофа литеральной строки ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln('Результат сложения равен =, x + y); // Не хватает закрывающего апострофа
end.</source>
Закрыть апостроф надо на той же строке, где расположен открывающий апостроф

=== Ошибки расстановки запятых и апострофов при выводе строк и выражений ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln(x, '+,' y, '=', x+y); // Неверная расстановка запятых и апострофов
end.</source>
Слишком много запятых и апострофов рядом, потому начинающие часто путаются :)
Надо уяснить правила:
*запятые разделяют разные элементы вывода
*все, что находится в апострофах, будет выведено на экран без изменений

=== Ошибка ввода ===
<source lang="pascal">
begin
var x: integer;
read(x); // введите блаблабла и посмотрите, что получится
end.</source>
Это - ошибка во время выполнения. Программа пытается преобразовать введенную строку в число, не может это сделать и завершается с ошибкой

=== Ошибка неинициализированной переменной ===
<source lang="pascal">
begin
var x: integer;
// Забыли инициализировать или ввести x
var r := x * x; // r получает тип integer
writeln('Квадрат числа ', x, ' = ', r);
end.</source>
Перед использованием любую переменную надо ввести или присвоить ей начальное значение. Это действие называется инициализацией переменной.

=== Деление на 0 ===
<source lang="pascal">
begin
var x: integer := 0;
var c: integer := 666 div x; // Здесь происходит деление на 0
end.</source>
Если во время выполнения программа выполнит деление на 0, то она завершится с ошибкой.

=== Корень из отрицательного числа ===
<source lang="pascal">begin
writeln(sqrt(-1)); // Корень из отрицательного числа
end.</source>
В обычном Паскале возникает ошибка времени выполнения.
В PascalABC.NET выводится NaN - Not a Number

== Ссылки ==
*[[Программы для начинающих]]
*[http://pascalabc.net/ru/programmyi-i-algoritmyi-dlya-nachinayuschih.html Сайт PascalABC.NET: Программы и алгоритмы для начинающих]

Начало. Возможные ошибки

2015-08-26T09:33:52Z

Ulysses: /* Неописанная переменная */ var наше всио, а раздел описаний менее предпочтителен в общем случае

__NOTOC__
=== Неописанная переменная ===
<source lang="pascal">begin
S := 1; // Неизвестное имя S
end.</source>
Все используемые переменные должны быть предварительно описаны с помощью ключевого слова '''var''' (внутри блока begin/end или, что обычно хуже, в разделе описаний вначале программы).

=== Отсутствующая ; ===
<source lang="pascal">
begin
var S: integer // Ожидалась ;
S := 1;
end.</source>

<source lang="pascal">
begin
var S: integer := 1 // Ожидалась ;
S := S + 1
end.</source>
Очень частая ошибка у начинающих. Курсор, как правило, позиционируется в начале следующей строки

=== Несовместимость типов при присваивании ===
<source lang="pascal">
begin
var S: integer := 1.3; // Нельзя преобразовать тип real к integer
end.</source>
Безболезненно можно присваивать только данные одного типа. Если данные - разных типов, то в редких случаях можно преобразовать данные одного типа в данные другого. Например, целое можно преобразовать в вещественное, а символ - в строку. Обратные преобразования не допускаются.

=== Отсутствие закрывающего апострофа литеральной строки ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln('Результат сложения равен =, x + y); // Не хватает закрывающего апострофа
end.</source>
Закрыть апостроф надо на той же строке, где расположен открывающий апостроф

=== Ошибки расстановки запятых и апострофов при выводе строк и выражений ===
<source lang="pascal">
begin
var x := 2; // x получает тип integer
var y := 3; // y получает тип integer
writeln(x, '+,' y, '=', x+y); // Неверная расстановка запятых и апострофов
end.</source>
Слишком много запятых и апострофов рядом, потому начинающие часто путаются :)
Надо уяснить правила:
*запятые разделяют разные элементы вывода
*все, что находится в апострофах, будет выведено на экран без изменений

=== Ошибка ввода ===
<source lang="pascal">
begin
var x: integer;
read(x); // введите блаблабла и посмотрите, что получится
end.</source>
Это - ошибка во время выполнения. Программа пытается преобразовать введенную строку в число, не может это сделать и завершается с ошибкой

=== Ошибка неинициализированной переменной ===
<source lang="pascal">
begin
var x: integer;
// Забыли инициализировать или ввести x
var r := x * x; // r получает тип integer
writeln('Квадрат числа ', x, ' = ', r);
end.</source>
Перед использованием любую переменную надо ввести или присвоить ей начальное значение. Это действие называется инициализацией переменной.

=== Деление на 0 ===
<source lang="pascal">
begin
var x: integer := 0;
var c: integer := 666 div x; // Здесь происходит деление на 0
end.</source>
Если во время выполнения программа выполнит деление на 0, то она завершится с ошибкой.

=== Корень из отрицательного числа ===
<source lang="pascal">begin
writeln(sqrt(-1)); // Корень из отрицательного числа
end.</source>
В обычном Паскале возникает ошибка времени выполнения.
В PascalABC.NET выводится NaN - Not a Number

== Ссылки ==
*[[Программы для начинающих]]
*[http://pascalabc.net/ru/programmyi-i-algoritmyi-dlya-nachinayuschih.html Сайт PascalABC.NET: Программы и алгоритмы для начинающих]

Страничка семинара теории типов

2013-02-23T17:25:47Z

Ulysses: /* Generics of a Higher Kind */ «передаём модели»

По концептам, типам следует читать современные статьи

Можно начинать со школы Одерского:

[http://www.scala-lang.org/node/143 Статьи по теоретическим основам языка Скала]

Выделю тут ряд статей, с которых, по моему мнению, следует начинать:

* [http://drops.dagstuhl.de/opus/volltexte/2009/2338/pdf/09005.OderskyM.2338.pdf Fighting Bit Rot with Types (Experience Report: Scala Collections)]
* [http://lamp.epfl.ch/~dragos/files/scala-spec.pdf Compiling Generics Through User-Directed Type Specialization]
* [http://lamp.epfl.ch/~rompf/continuations-icfp09.pdf Implementing First-Class Polymorphic Delimited Continuations by a Type-Directed Selective CPS-Transform]
* [http://www.comlab.ox.ac.uk//files/2187/ModularVisitor.pdf Modular Visitor Components: A Practical Solution to the Expression Families Problem]
* [http://adriaanm.github.com/files/higher.pdf Generics of a Higher Kind]
* [http://adriaanm.github.com/files/scalina-final.pdf Safe Type-level Abstraction in Scala]
* [http://infoscience.epfl.ch/getfile.py?docid=13847&name=TranslationCorrectness-TR&format=pdf&version=1 Translation Correctness for First-Order Object-Oriented Pattern Matching]
* [http://www.scala-lang.org/sites/default/files/odersky/mfcs06.pdf A Core Calculus for Scala Type Checking]
* [http://www.scala-lang.org/sites/default/files/odersky/ecoop03.pdf A Nominal Theory of Objects with Dependent Types]

== Краткий отчет о статьях ==
==== Compiling Generics Through User-Directed Type Specialization ====
''Juliet:''

Небольшая статья, 6 страниц. О технических особенностях генерации кода для шаблонов.

В двух словах речь о том, что использовать код, который генерируется для шаблона после стирания типов (где вместо типа <tt>T</tt> возникает <tt>Object</tt>) неэффективно для примитивных типов. Так как их приходится заворачивать в классы-обертки, и, соответственно, в специализированной версии возникают лишние операции boxing/unboxing.

В качестве альтернативы при описании шаблона для типа-параметра шаблона можно указать ключевое слово '''specialized''':
<source lang="scala">
def someFun[@specialized T](...
</source>
В этом случае помимо кода с <tt>Object</tt> будут сгенерированы специализации для примитивных типов.

==== Generics of a Higher Kind ====
'''''Juliet''':''

16 страниц.

Насколько я понимаю, концептов в том смысле, как мы уже привыкли их воспринимать, здесь нет. Сплошные классы.

Точнее, есть '''trait''' и '''class'''. Из статьи: класс может наследоваться от другого класса и нескольких траитов. Траит это класс, который может комбинироваться с другими траитами с помощью некой ограниченной версии множественного наследования.

Далее говорится, что в статье разница между траитами и классами не так важна, так что все называется классами.

Класс может быть параметризован. А может содержать абстрактный тип-член. И они вроде бы ничем по сути не отличаются кроме области видимости.

Соль типов-параметров шаблона в том, что в качестве параметра может быть не конкретный тип, а '''конструктор типа'''.

<source lang="Scala">
trait Iterable[T, Container[X]] {
def filter(p: T => Boolean): Container[T]
...
}
</source>

Это означает, что первый параметр — конкретный тип, а второй параметр — конструктор типа от одного параметра. И далее можем написать так:

<source lang="Scala">
trait List[T] extends Iterable[T, List]
</source>

На параметры шаблона можно наложить только два вида ограничений: надтипа и подтипа. Соответственно, если хочется получить несколько разносортных ограничений (то есть по-нашему — если мы хотим, чтобы тип удовлетворял нескольким концептам), надо сделать trait-наследник всех интересующих нас концептов и указать его в качестве надтипа.

Еще один интересный момент, рассматривающийся в статье — сорта типов. Из Haskell мы помним (про расширения я ничего не знаю, к сожалению), что конкретный тип имеет сорт «*», конструктор с одним параметром — «* → *», и так далее. Здесь предлагается рассматривать не просто «*», а «*(lowerBound, upperBound)». То есть сорт содержит информацию об ограничениях типовых составляющих.

Далее говорится о том, что на сортах можно ввести отношение «подсортирования». И еще есть раздел с красивым названием «kind soundness».

В общем, по-моему это крутая статья. Надо над ней подумать...

'''''Miks''':''

Раз концепты есть, то как-то можно обеспечить концепт, связывающий два и более параметров шаблона. Как?
Может, в статье всё-таки ничего не говорится о концептах?

'''''Juliet''':''

Слова «концепты» в статье вообще нет, это правда. Есть пример моделирования классов типов Haskell.

А связать несколько параметров можно, просто trait с несколькими параметрами.
<source lang="scala">
trait myTrait[S, T] {
def convert(x: S): T
}
</source>

'''''Miks''':''

Ну, это не очень - это и на C++ старом можно написать. А вот пример использования triats как концептов в новом C++ можно? В стиле

<source lang="cpp">template<InputIterator Iter, typename V>
requires EqualityComparable<Iter::value_type, V>
Iter find(Iter first, Iter last, V v) {
while (first < last && *first != v)
++first;
return first;
}
</source>

'''''Juliet''':''

По идее можно, но я опять ничего не понимаю, пытаюсь написать...

'''''Juliet''':''

В общем, у меня все печально. С value_type, спрятанным внутрь траита, совсем ничего не получается. Получился какой-то такой ужас:

<source lang="Scala">
trait EqualityComparable[S, T] {
def ==(s: S, t: T): Boolean
def !=(s: S, t: T): Boolean = !(s == t)
}

implicit object EqIntInt extends EqualityComparable[Int, Int] {
def ==(a: Int, b: Int): Boolean = { a == b }
}

trait PInputIterator[value_type] {
def <(b: PInputIterator[value_type]): Boolean
def ++(): Unit
def *(): value_type
}

class IntNumber(x: Int) extends PInputIterator[Int]{
var n = x

def <(b: PInputIterator[Int]): Boolean = {
val y = b.asInstanceOf[IntNumber];
n < y.n
}
def ++(): Unit = { n += 1; }
def *(): Int = n

override def toString(): String = n.toString()
}

def pfind[X, Iter <: PInputIterator[X], V](first: Iter, last: Iter, v: V)
(implicit cmp: EqualityComparable[X, V]): Iter =
{
while (first < last && cmp.!=(first.*(), v))
first.++()
first
} //> pfind: [X, Iter <: concepts.iterator.PInputIterator[X], V](first: Iter, las
//| t: Iter, v: V)(implicit cmp: concepts.iterator.EqualityComparable[X,V])Iter
//|

var c5 = new IntNumber(5) //> c5 : concepts.iterator.IntNumber = 5
var c15 = new IntNumber(15) //> c15 : concepts.iterator.IntNumber = 15
val d11 = pfind[Int, IntNumber, Int](c5, c15, 11)
//> d11 : concepts.iterator.IntNumber = 11

</source>

Причем ''не указывать'' параметры при вызове pfind не получается, ошибка: <tt>Type inferred type arguments [Nothing,IntNumber,Int] do not conform to method pfind's type parameter bounds [X,Iter <: PInputIterator[X],V]</tt>

'''''Juliet''':''

Я снова открыла статью, про которую Артем на семинаре докладывал. Она несколько нивелировала влияние статьи «Generics of a Higher Kind». Теперь у меня вот так получилось (добраться до внутреннего типа все равно никак не получается):

<source lang="Scala">

trait EqualityComparable[S, T] {
def ==(s: S, t: T): Boolean
def !=(s: S, t: T): Boolean = !(s == t)
}

trait InputIterator[Iter] {
type value_type

def <(a: Iter, b: Iter): Boolean
def ++(it: Iter): Unit
def *(it: Iter): value_type
}

trait VTInputIterator[Iter, VT] extends InputIterator[Iter] {
type value_type = VT
}

class ArrayListIterator[T](a: ArrayList[T], i: Int) {
val arr: ArrayList[T] = a
var ind: Int = i

def curr(): T = arr.get(ind)
def ++(): Unit = { ind += 1 }

override def toString() = "[" + ind.toString() + "]"
}

class InputIterArrList[T] extends VTInputIterator[ArrayListIterator[T], T]{
def <(a: ArrayListIterator[T], b: ArrayListIterator[T]) = {
if (a.arr == b.arr) a.ind < b.ind
else throw new IllegalArgumentException()
}

def ++(it: ArrayListIterator[T]): Unit = it.++()
def *(it: ArrayListIterator[T]) = it.curr()
}

object TestInputIterator extends Application{

def find[Iter, VT, V](first: Iter, last: Iter, x: V)(implicit iterator: VTInputIterator[Iter, VT],
cmp: EqualityComparable[VT, V]): Iter =
{
while (iterator.<(first, last) && cmp.!=(iterator.*(first), x))
iterator.++(first)
first
}

implicit object EqIntInt extends EqualityComparable[Int, Int] {
def ==(a: Int, b: Int): Boolean = { a == b }
}

implicit object inputIterArrListInt extends InputIterArrList[Int]{}

val len = 10;
var arr: ArrayList[Int] = new ArrayList(len);
for (i: Int <- 1 to len)
arr.add(i)
var arrFirst = new ArrayListIterator(arr, 0)
var arrLast = new ArrayListIterator(arr, len)
var r = find(arrFirst, arrLast, 7)
println(r)
}
</source>

'''''Juliet:'''''

В общем, итоги на SO (http://stackoverflow.com/questions/15001138/modelling-of-c-concepts-with-scala-traits).

То есть я так понимаю, на Scala мы пишем примерно то, во что генерируются концепты у Сика. То есть явно передаем модели.

И с другой стороны есть возможность указать надтип и подтип для параметров шаблона.

'''''Ulysses:'''''

Не «передаём», а указываем при описании функций — это полный аналог requires. Если есть implicit, то явно передавать при вызове не требуется.

Заглавная страница

2011-02-09T21:11:10Z

Ulysses: Отмена правки 2016 участника Hyldenlearwik (обсуждение)

== Cтатьи==
* [[FAQ по PascalABC.NET]]

== Обучение==
* [[GPLex + GPPG|Задания по курсу "Методы построения компиляторов"]]
* [[Комплект юного разработчика парсеров]]
* [[Как создать компилятор]]

== Примеры==
* [[Программы для начинающих|Программы и алгоритмы для начинающих]]
* [[Особенности языка: базовый уровень]]
* [[Стандартные модули: базовый уровень]]
* [[Особенности языка: продвинутый уровень]]
* [[Стандартные модули: продвинутый уровень]]
* [[Алгоритмы для студентов|Программы и алгоритмы для студентов ИТ]]
* [[Алгоритмы средней сложности]] (пока не реализовано)

== Web-среда разработки PascalABC.NET ==

*[[Основная страница проекта WDE PascalABC.NET|Основная страница проекта]]
* [[2011 год - планы]]
[[Ош1]]

==Другие проекты==

*[[Обзор реализации основных возможностей функционального языка программирования в среде PascalABC.NET|Проект "Реализация основных возможностей функционального языка программирования в среде PascalABC.NET" (Бушманова Н.)]]
*[[Рефакторинг|Проект "Рефакторинг по семантическому дереву PascalABC.NET" (Малеванный М., Коноплев Е.)]]
*[[Аспектно-ориентированное программирование|Проект "Аспектно-ориентированное программирование" (Зарубин М.)]]
* [[Реализация языка программирования Оберон на базе PascalABC.NET]]

* [[Проект Optimus - учебная система оптимизации программ]]

== Статьи о внутреннем представлении PascalABC.NET ==

* [[Архитектура PascalABC.NET]]
* [[Создание нового языка программирования - с чего начать]]
* [[Интерфейс подключения нового языка программирования|Интерфейс подключения нового языка программирования (проект)]]
* [[Директивы компилятора]]
* [[Синтаксическое дерево]]
* [[Семантическое дерево]]
* [[Формат PCU]]
* [[Отладчик]]
* [[Intellisense]]
* [[Шаблоны кода]]
* [[Создание нового стандартного модуля (для разработчика)]]

== Статьи по программированию в PascalABC.NET ==
* [[Локализация приложений]]
* [[Плагины для PascalABC.NET]]
* [[Отслеживание изменений в файловой системе]]
* [[OpenGL]]

== Разное ==
* [[GPPG+GPLex - что исправить для русской кодировки]]
[[Ош]]

Заглавная страница

2011-02-09T21:10:55Z

Ulysses: Отмена правки 2017 участника Hyldenlearwik (обсуждение)

== Cтатьи==
* [[FAQ по PascalABC.NET]]

== Обучение==
* [[GPLex + GPPG|Задания по курсу "Методы построения компиляторов"]]
* [[Комплект юного разработчика парсеров]]
* [[Как создать компилятор]]

== Примеры==
* [[Программы для начинающих|Программы и алгоритмы для начинающих]]
* [[Особенности языка: базовый уровень]]
* [[Стандартные модули: базовый уровень]]
* [[Особенности языка: продвинутый уровень]]
* [[Стандартные модули: продвинутый уровень]]
* [[Алгоритмы для студентов|Программы и алгоритмы для студентов ИТ]]
* [[Алгоритмы средней сложности]] (пока не реализовано)

== Web-среда разработки PascalABC.NET ==

*[[Основная страница проекта WDE PascalABC.NET|Основная страница проекта]]
* [[2011 год - планы]]
[[Ош1]]

==Ссылки==
*[[http://home.ru|квартиры в Москве]]

*[[Обзор реализации основных возможностей функционального языка программирования в среде PascalABC.NET|Проект "Реализация основных возможностей функционального языка программирования в среде PascalABC.NET" (Бушманова Н.)]]
*[[Рефакторинг|Проект "Рефакторинг по семантическому дереву PascalABC.NET" (Малеванный М., Коноплев Е.)]]
*[[Аспектно-ориентированное программирование|Проект "Аспектно-ориентированное программирование" (Зарубин М.)]]
* [[Реализация языка программирования Оберон на базе PascalABC.NET]]

* [[Проект Optimus - учебная система оптимизации программ]]

== Статьи о внутреннем представлении PascalABC.NET ==

* [[Архитектура PascalABC.NET]]
* [[Создание нового языка программирования - с чего начать]]
* [[Интерфейс подключения нового языка программирования|Интерфейс подключения нового языка программирования (проект)]]
* [[Директивы компилятора]]
* [[Синтаксическое дерево]]
* [[Семантическое дерево]]
* [[Формат PCU]]
* [[Отладчик]]
* [[Intellisense]]
* [[Шаблоны кода]]
* [[Создание нового стандартного модуля (для разработчика)]]

== Статьи по программированию в PascalABC.NET ==
* [[Локализация приложений]]
* [[Плагины для PascalABC.NET]]
* [[Отслеживание изменений в файловой системе]]
* [[OpenGL]]

== Разное ==
* [[GPPG+GPLex - что исправить для русской кодировки]]
[[Ош]]

Как создать компилятор

2010-07-28T15:04:41Z

Ulysses: /* Лексический анализатор GPLex и синтаксический анализатор GPPG */ пункт.

=== Общие замечания ===
Сразу скачиваем [http://pascalabc.net/downloads/CompilerConstruction/Oberon00Independent.zip полный комплект разработчика парсеров].

В инфраструктуре PascalABC.NET несложно создавать компиляторы простых языков программирования. Программы, получаемые на таких языках, компилируются в .NET-код и работают, как и любой .NET-код, практически так же производительно, как и машинный.

Для создания компилятора важно понимать следующее. Компилятор имеет несколько внутренних представлений.

* Вначале текст программы разбирается им в так называемое '''синтаксическое дерево'''. Синтаксическое дерево содержит представленный в виде дерева текст программы - семантика на этом уровне не учитывается, проверяется только соответствие синтаксическим конструкциям. Например, на уровне синтаксического дерева не распознаётся ошибка описания двух переменных с одним именем - с точки зрения синтаксиса ошибки нет.
* Затем синтаксическое дерево переводится в '''семантическое дерево'''. Семантическое дерево учитывает все правила, которые сформулированы в описании языка: в частности, то, что в одном пространстве имен нельзя описать две переменные с одним именем. Кроме этого, в семантическом дереве хранится существенно больше информации, чем в синтаксическом: каждая переменная имеет тип, относится к определенному пространству имен, для подпрограмм проверяется соответствие количества и типов формальных и фактических параметров и т.д.
:Заметим, что семантическое дерево, если получено, то содержит '''правильную''' программу. Семантическое дерево откомпилированного модуля можно сохранить на диск для ускорения компиляции. В PascalABC.NET так и происходит: если модуль успешно откомпилирован, то он сохраняется в .pcu-файл - это не что иное как записанное на диск семантическое дерево модуля. Если при компиляции основной программы к ней подключен данный модуль, то он повторно не компилируется - его дерево разворачивается из .pcu-файла в память, что гораздо быстрее.
* Наконец, по семантическому дереву генерируется .NET-код.

Заметим, что такое разделение на синтаксическое и семантическое деревья позволяет упростить процесс создания новых языков. В частности, если язык достаточно простой и похож на Паскаль, то он может быть переведен в синтаксическое дерево, после чего достаточно использовать стандартный преобразователь в семантическое дерево и генератор кода. Для более сложных языков с семантикой, отличной от Паскаля, для некоторых узлов синтаксического дерева необходимо писать свой преобразователь в узлы семантического дерева. в ещё более сложных ситуациях имеющихся узлов семантического дерева может оказаться недостаточно, поэтому придется создавать новые и писать для них генерацию .NET-кода.

Далее мы будем рассматривать только такие языки, в которых текст программы достаточно перевести в синтаксическое дерево, что означает, что семантика конструкций - такая же, как и в Паскале. Например, это означает, что целый тип неявно преобразуется в вещественный, но не наоборот.

Следует отметить, что в большинстве ситуаций за счёт проведения дополнительных проверок перевода в узлы синтаксического дерева вполне достаточно. Далее это станет понятнее на конкретных примерах.

Рассмотрим создание простого языка, который мы назовём Oberon00. Это - подмножество языка Oberon с двумя типами - INTEGER и BOOLEAN - и возможностью вызывать процедуры из внешних модулей.

=== Что нужно для создания компилятора ===

Для создания компилятора, интегрированного в среду PascalABC.NET, нам потребуется создать несколько файлов. В случае языка Oberon00 потребуется создать:
* Oberon00Parser.dll - библиотеку, содержащую парсер языка (ее следует скопировать в папку установки PascalABC.NET)
* Oberon00.xhsd - файл подсветки синтаксиса (скопировать в папку PascalABC.NET\Highlighting)
Кроме этого, обычно требуется системный модуль, содержащий стандартные подпрограммы. Его можно создать на языке Паскаль. Пусть для Оберона00 этот модуль называется Oberon00System.pas. Требуется откомпилировать его в .pcu и затем
* Скопировать Oberon00System.pas в папку PascalABC.NET\LibSource
* Скопировать Oberon00System.pcu в папку PascalABC.NET\Lib

Перезапустив среду PascalABC.NET, мы получим новый компилятор.

Для того чтобы сразу увидеть конечный результат, можно скопировать [http://pascalabc.net/downloads/CompilerConstruction/Oberon00Independent.zip полный комплект разработчика парсеров].

=== Что входит в комплект разработчика парсеров ===
# Папка DLL, содержащая dll из комплекта PascalABC.NET, необходимые для создания парсера.
# Папка GPLex_GPPG, содержащая генератор компиляторов GPLex+GPPG и документацию к нему.
# Папка Install, содержащая файлы, которые необходимо скопировать в папку PascalABC.NET для того чтобы в оболочке PascalABc.NET появился компилятор нового языка.
# Файл generate_all.bat для компиляции файлов .lex и .y в файлы .cs, компиляции проекта и получения библиотеки Oberon00Parser.dll и копирования этого файла в папку Install.

Далее разберем последовательно, как создать парсер.

=== Лексический анализатор GPLex и синтаксический анализатор GPPG ===

Итак, наша задача - разобрать текст программы и по нему получить синтаксическое дерево программы. Такой построитель синтаксического дерева программы будем называть '''парсером''' или '''синтаксическим анализатором'''. Для работы синтаксического анализатора необходим также '''сканер''' или '''лексический анализатор''', который разбивает программу на лексемы - неделимые слова. Например, в языке Паскаль лексемами являются ключевые слова, идентификаторы, числовые и строковые константы, знаки операций (:= <> и т.д.).

Синтаксические анализаторы обычно создаются с помощью специальных программ, называемых '''генераторами компиляторов'''. Одним из наиболее известных генераторов компиляторов является '''Yacc''' (Yet Another Compiler of Compilers) - и в паре с ним работает генератор лексических анализаторов '''Lex'''.

Наиболее полной реализацией Yacc-Lex для .NET, генерирующей код парсера на C#, является GPLex+GPPG, разработанный Queensland University of Technology, Австралия. Вот странички продуктов: [http://plas2003.fit.qut.edu.au/gplex/ GPLex] и [http://plas2003.fit.qut.edu.au/gppg/ GPPG]. Однако рекомендуется [http://pascalabc.net/downloads/CompilerConstruction/GPLex_GPPG_2010.zip скачать исполнимые файлы отсюда] - они содержат небольшие модификации, связанные с корректной русификацией.

=== Создание лексического анализатора ===
==== Класс Scanner ====
Создаваемый в результате компиляции .lex-файла класс '''Scanner''' содержит несколько важных методов и свойств. Рассмотрим их подробнее.

* Функция int '''yylex'''() возвращает уникальный номер лексемы. Все лексемы хранятся в перечислимом типе Tokens. По-существу, возвращается номер константы в перечислимом типе Tokens - например, для лексемы ID возвращается (int)Tokens.ID
* Помимо уникального номера некоторые лексемы должны возвращать дополнительные значения. Таким значением для идентификатора является его строковое представление, для INTNUM - целое число и т.д. Дополнительное значение для некоторых лексем возвращается в свойстве '''yylval''', которое имеет тип ValueType и содержит ряд полей различных типов - для каждой лексемы может быть предусмотрено своё поле. Например, для лексемы ID предусмотрено поле string sVal, а для лексемы INTNUM - поле iVal.
Объяснение того, как это поле сопоставляется с типом лексемы, отложим до знакомства с содержимым файла .y
* Свойство '''yytext''' возвращает строковое представление текущей лексемы
* Свойство '''yylloc''' содержит положение лексемы в тексте, задаваемое типом LexLocation из пространства имен QUT.Gppg. Он хранит координаты начала и конца лексемы

==== Файл .lex ====
Лексический анализатор обычно создается в файле с расширением .lex. Он имеет вид:

Определения
%%
Правила
%%
Пользовательский код

Рассмотрим файл лексического анализатора Oberon00.lex:
<source lang="CSharp">%namespace GPPGParserScanner

%using PascalABCCompiler.Oberon00Parser;

Alpha [a-zA-Z_]
Digit [0-9]
AlphaDigit {Alpha}|{Digit}
INTNUM {Digit}+
ID {Alpha}{AlphaDigit}*

%%

":=" { return (int)Tokens.ASSIGN; }
";" { return (int)Tokens.SEMICOLUMN; }
"-" { return (int)Tokens.MINUS; }
"+" { return (int)Tokens.PLUS; }
"*" { return (int)Tokens.MULT; }
"/" { return (int)Tokens.DIVIDE; }
"<" { return (int)Tokens.LT; }
">" { return (int)Tokens.GT; }
"<=" { return (int)Tokens.LE; }
">=" { return (int)Tokens.GE; }
"=" { return (int)Tokens.EQ; }
"#" { return (int)Tokens.NE; }
"(" { return (int)Tokens.LPAREN; }
")" { return (int)Tokens.RPAREN; }
"," { return (int)Tokens.COLUMN; }
"~" { return (int)Tokens.NOT; }
"&" { return (int)Tokens.AND; }
"." { return (int)Tokens.COMMA; }
":" { return (int)Tokens.COLON; }
"!" { return (int)Tokens.EXCLAMATION; }
\x01 { return (int)Tokens.INVISIBLE; }

{ID} {
int res = Keywords.KeywordOrIDToken(yytext);
if (res == (int)Tokens.ID)
yylval.sVal = yytext;
return res;
}

{INTNUM} {
yylval.iVal = int.Parse(yytext);
return (int)Tokens.INTNUM;
}

%{
yylloc = new QUT.Gppg.LexLocation(tokLin, tokCol, tokELin, tokECol);
%}

%%

public override void yyerror(string format, params object[] args)
{
string errorMsg = PT.CreateErrorString(args);
PT.AddError(errorMsg,yylloc);
}</source>

После обработки генератором лексических анализаторов GPLex мы получим одноименный cs-файл Oberon00.cs, содержащий класс Scanner лексического анализатора.

Разберем содержимое .lex-файла подробнее.

==== Секция определений ====

Вначале рассмотрим первую часть, содержащую определения лексем:

<source lang="CSharp">%namespace GPPGParserScanner

%using PascalABCCompiler.Oberon00Parser;

Alpha [a-zA-Z_]
Digit [0-9]
AlphaDigit {Alpha}|{Digit}
INTNUM {Digit}+
ID {Alpha}{AlphaDigit}*
</source>

Строка %namespace GPPGParserScanner означает, что класс сканера будет помещен в пространство имен GPPGParserScanner

Строка %using PascalABCCompiler.Oberon00Parser; приводит к генерации соответствующей строки в cs-файле. Пространство имен PascalABCCompiler.Oberon00Parser полностью находится во вспомогательном файле Oberon00ParserTools.cs, который содержит различные глобальные описания и подпрограммы (подробнее содержимое этого файла будет объяснено позже).

Далее идёт описание некоторых лексем в виде регулярных выражений. Например, целое число INTNUM представляет собой последовательность одной или более цифр {Digit}+, а идентификатор ID - последовательность букв или цифр, начинающуюся с буквы: {Alpha}{AlphaDigit}*

==== Секция правил ====

Вторая секция (между первым и вторым %%) является основной и содержит действия, которые необходимо выполнить, когда распознана та или иная лексема.

<source lang="CSharp">":=" { return (int)Tokens.ASSIGN; }
";" { return (int)Tokens.SEMICOLUMN; }
"-" { return (int)Tokens.MINUS; }
"+" { return (int)Tokens.PLUS; }
"*" { return (int)Tokens.MULT; }
"/" { return (int)Tokens.DIVIDE; }
"<" { return (int)Tokens.LT; }
">" { return (int)Tokens.GT; }
"<=" { return (int)Tokens.LE; }
">=" { return (int)Tokens.GE; }
"=" { return (int)Tokens.EQ; }
"#" { return (int)Tokens.NE; }
"(" { return (int)Tokens.LPAREN; }
")" { return (int)Tokens.RPAREN; }
"," { return (int)Tokens.COLUMN; }
"~" { return (int)Tokens.NOT; }
"&" { return (int)Tokens.AND; }
"." { return (int)Tokens.COMMA; }
":" { return (int)Tokens.COLON; }
"!" { return (int)Tokens.EXCLAMATION; }
\x01 { return (int)Tokens.INVISIBLE; }

{ID} {
int res = Keywords.KeywordOrIDToken(yytext);
if (res == (int)Tokens.ID)
yylval.sVal = yytext;
return res;
}

{INTNUM} {
yylval.iVal = int.Parse(yytext);
return (int)Tokens.INTNUM;
}</source>
Здесь приведены действия в случае если встречена та или иная лексема. Большинство действий просто возвращает порядковый номер лексемы в перечислимом типе Tokens.

Последняя лексема - INVISIBLE - символ с кодом 1 - необязательна и является вспомогательной для компилятора выражений языка (необходим для поддержки IntelliSense).

В случае лексемы INTNUM в поле yylval.iVal дополнительно возвращается целое число, соответствующее лексеме: int.Parse(yytext). Обратим внимание, что здесь нет никакой защиты от неправильного преобразования (например, в случае очень длинного целого). Причина - чтобы пока не усложнять изложение обработкой ошибок.

В случае лексемы ID вначале проверяется, не является ли она ключевым словом, и если является, то возвращается целое, соответствующее лексеме ключевого слова (например, для BEGIN возвращается (int)Tokens.BEGIN), а если не является, то возвращается (int)Tokens.ID и параллельно в поле yylval.sVal возвращается строковое представление идентификатора. Именно на этом уровне мы можем задать, чувствителен ли наш язык к регистру (например, преобразованием всех идентификаторов к UpperCase).

Секция правил завершается следующим кодом:
<source lang="CSharp">%{
yylloc = new QUT.Gppg.LexLocation(tokLin, tokCol, tokELin, tokECol);
%}</source>
Этот код позволяет для каждой лексемы получать её местоположение в тексте. Вникать в этот код не надо - он просто необходим.

==== Секция пользовательского кода ====
Наконец, в секции пользовательского кода содержится единственный переопределенный в классе Scanner метод

<source lang="CSharp">public override void yyerror(string format, params object[] args)
{
string errorMsg = PT.CreateErrorString(args);
PT.AddError(errorMsg,yylloc);
}
</source>
Он вызывается всякий раз когда происходит синтаксическая ошибка. Здесь мы пользуемся услугами статического класса PT, который находится в файле Oberon00ParserTools.cs. PT.CreateErrorString(args) формирует строку ошибки, а PT.AddError(errorMsg,yylloc); добавляет ошибку в список ошибок компиляции PascalABC.NET. Здесь интересно то, что в случае автоматического вызова yyerror в args попадают токены, которые ожидались после данного.

==== Генерация кода лексического анализатора ====
Для генерации кода лексического анализатора следует выполнить команду:
gplex.exe /unicode oberon00.lex
Здесь gplex.exe - генератор лексических анализаторов, хранящийся в папке GPLex_GPPG, параметр /unicode указывает на то, что созданный лексический анализатор будет распознавать файлы в кодировке unicode (заметим, что он будет распознавать и однобайтные кодировки).

=== Создание синтаксического анализатора ===
==== Общая информация ====
Синтаксический анализатор - ядро нашего компилятора. Он строится по .y - файлу, в котором записываются правила '''грамматики языка''' и действия, которые выполняются по этим правилам. Каждое из действий создает соответствующий узел в синтаксическом дереве. Все узлы синтаксического дерева представляют собой иерархию классов с общим предком syntax_tree_node и описаны во внешней библиотеке SyntaxTree.dll.

Для понимания дальнейшего следует иметь некоторое начальное представление о грамматиках языков программирования, о том, как они порождают языки и об автоматах, которые проверяют, принадлежит ли данная цепочка символов языку, порождаемому грамматикой. Более конкретно, следует представлять, что такое '''контекстно-свободная грамматика''', что Yacc-Lex системы работают с так называемыми LL(k) грамматиками, являющимися достаточно широким подмножеством контекстно-свободных грамматик.

В процессе построения грамматик придется сталкиваться с недостижимыми и циклическими продукциями грамматик, неоднозначными грамматиками. Необходимо уметь исправлять подобные ситуации хотя бы методом проб и ошибок. Особенно необходимо понимать, что Shift-Reduce - конфликты грамматик допустимы и разрешаются в пользу более длинной правой части продукции, а Reduce-Reduce - конфликты недопустимы и свидетельствуют об ошибках проектирования грамматики.

Соответствующую информацию можно прочитать в книге Ахо "Компиляторы: принципы, технологии, инструменты".

==== Некоторые классы синтаксического дерева ====
Как уже было сказано, синтаксическое дерево состоит из объектов классов - наследников syntax_tree_node. Перечислим некоторые важные классы - наследники syntax_tree_node, которые будут нами использованы для реализации парсера Оберона00:

ident - идентификатор
ident_list - список идентификаторов
uses_list - список модулей и пространств имен в секции uses
unit_or_namespace - модуль или пространство имен
block - блок
program_module - программа
int32_const - целая константа
bool_const - логическая константа
expression - выражение (базовый класс для всех выражений)
expression_list - список выражений
un_expr - унарное ввыражение
bin_expr - бинарное выражение
assign - оператор присваивания
if_node - условный оператор
while_node - оператор цикла while
empty_statement - пустой оператор
method_call - вызов метода или внешней подпрограммы
statement_list - последовательность операторов
named_type_reference - имя типа
declarations - описания
var_def_statement - описания переменных с одним типом
variable_definitions - секция объявлений переменных
simple_const_definition - определение именованной константы
consts_definitions_list - секция определений именованных констант

Каждый класс имеет свои поля, все необходимые поля заполняются обычно в конструкторе класса. В базовом классе syntax_tree_node имеется поле source_context типа SourceContext, определяющее местоположение конструкции, соответствующей синтаксическому узлу, в тексте программы. Именно поэтому каждый конструктор синтаксического дерева содержит последним параметром объект класса SourceContext.

Просмотреть все узлы синтаксического дерева, их свойства и методы можно с помощью утилиты
[http://pascalabc.net/downloads/CompilerConstruction/NodesGenReader.zip Просмотрщик классов синтаксического дерева]

==== Правила грамматики ====
Правила грамматики содержат терминальные символы (терминалы), которые распознаются лексическим анализатором, и нетерминальные символы (нетерминалы). Каждое правило грамматики выражает нетерминал через другие терминалы и нетерминалы. Например, для оператора присваивания имеется следующее правило:

<source lang="text">AssignOperator : ID ASSIGN expr ;
</source>
Здесь нетерминал AssignOperator выражается через терминалы ID и ASSIGN и нетерминал expr, который будет определен в другом правиле.

Нетерминал, с которого начинается разбор, называется стартовым символом грамматики. Этот нетерминал описывает всю программу. В нашей грамматике это module, а соответствующее стартовое правило имеет вид:

<source lang="text">module : MODULE ident SEMICOLUMN Declarations BEGIN StatementSequence END ident COMMA</source>

В конечном итоге все нетерминалы выражаются через терминалы, образующие основную программу. Соответствующий процесс получения программы из стартового символа называется выводом, а правила грамматики - правилами вывода.

В каждом правиле может быть несколько альтернатив, разделяемых символом |:

<source lang="text">IfStatement
: IF expr THEN StatementSequence END
| IF expr THEN StatementSequence ELSE StatementSequence END
;</source>

Правила могут быть рекурсивными. Например, правило для фактических параметров имеет вид:
<source lang="text">factparams
: expr
| factparams COLUMN expr
;</source>

Обратим внимание, что данное правило является леворекурсивным, поскольку рекурсивное вхождение нетерминала factparams в правую часть правила находится с левой стороны. Для рассматриваемых нами генераторов компиляторов леворекурсивные правила являются предпочтительнее праворекурсивных.

==== Формат .y-файла ====
.y-файл имеет такой же формат, как и .lex:
Определения
%%
Правила
%%
Пользовательский код

==== Раздел определений .y-файла ====
===== Общий вид =====
Рассмотрим раздел определений файла Oberon00.y

<source lang="CSharp">%{
public syntax_tree_node root; // Корневой узел синтаксического дерева
public GPPGParser(AbstractScanner<ValueType, LexLocation> scanner) : base(scanner) { }
%}

%output=oberon00yacc.cs

%parsertype GPPGParser

%union
{
public bool bVal;
public string sVal;
public int iVal;
public named_type_reference ntr;
public ident_list il;
public var_def_statement vds;
public variable_definitions vdss;
public expression ex;
public expression_list el;
public ident id;
public statement st;
public statement_list sl;
public declarations decl;
public Operators op;
public simple_const_definition scd;
public consts_definitions_list cdl;
}

%using PascalABCCompiler.SyntaxTree
%using PascalABCCompiler.Errors
%using PascalABCCompiler.Oberon00Parser

%namespace GPPGParserScanner

%start module

%token <sVal> ID
%token <iVal> INTNUM
%token <bVal> TRUE FALSE
%token <op> PLUS MINUS MULT DIVIDE AND OR LT GT LE GE EQ NE
%token NOT
%token ASSIGN SEMICOLUMN LPAREN RPAREN COLUMN COMMA COLON EXCLAMATION
%token TRUE FALSE ODD BOOLEAN INTEGER
%token IF THEN ELSE BEGIN END WHILE DO MODULE CONST VAR
%token INVISIBLE

%type <id> ident
%type <ntr> type
%type <ex> expr ConstExpr
%type <st> Assignment IfStatement WhileStatement WriteStatement Statement
%type <st> EmptyStatement ProcCallStatement
%type <sl> StatementSequence
%type <decl> Declarations
%type <el> factparams
%type <il> IDList
%type <vds> VarDecl
%type <vdss> VarDeclarations VarDeclarationsSect
%type <scd> ConstDecl
%type <cdl> ConstDeclarations ConstDeclarationsSect

%left LT GT LE GE EQ NE
%left PLUS MINUS OR
%left MULT DIVIDE AND
%left NOT
%left UMINUS</source>

===== Начальные строки =====
Он состоит из нескольких неравнозначных частей. Первая часть заключена в символы %{ %} и содержит код на C#, который будет вставлен в создаваемый класс Parser:

<source lang="CSharp"> public syntax_tree_node root; // Корневой узел синтаксического дерева
public GPPGParser(AbstractScanner<ValueType, LexLocation> scanner) : base(scanner) { }
</source>
Здесь root - корневой узел синтаксического дерева программы, он явно описан как поле класса GPPGParser.
Описываемый во второй строке конструктор носит технический характер - его просто необходимо в этом месте написать. Думаю, что эта строчка связана с неудачным проектированием генератора парсеров GPPG - разработчик забыл в генерируемый класс включить этот нужный конструктор.

Строка
<source lang="Delphi">%output=oberon00yacc.cs</source>
означает, что компиляция .y-файла с помощью gppg.exe будет осуществляться в файл oberon00yacc.cs

Строка
<source lang="CSharp">%parsertype GPPGParser</source>
говорит о том, что класс парсера будет иметь имя GPPGParser

Строки
<source lang="CSharp">%using PascalABCCompiler.SyntaxTree
%using PascalABCCompiler.Errors
%using PascalABCCompiler.Oberon00Parser</source>
означают подключение в коде парсера соответствующих пространств имен (точки с запятой в конце строк не нужны в отличие от лексического анализатора - видимо, это ошибка проектирования gppg),
а строка
<source lang="CSharp">%namespace GPPGParserScanner</source>
означает, что класс парсера будет помещен в пространство имен GPPGParserScanner.

Строка
<source lang="Delphi">%start module</source>
означает, что стартовым в нашей грамматике является нетерминал module (обычно эту строку можно не писать - считается, что стартовым является нетерминал в левой части первого правила).

===== Описание используемых терминалов =====
Все используемые терминалы должны быть описаны в секции определений следующим образом:
<source lang="CSharp">%token ASSIGN SEMICOLUMN LPAREN RPAREN COLUMN COMMA COLON EXCLAMATION
</source>
Именно по этим определениям формируется перечислимый тип Tokens, который встречался в .lex-файле.

Кроме этого, некоторым терминалам и нетерминалам можно задавать тип.

===== Типы терминалов и нетерминалов =====

Большинство нетерминалов и некоторые терминалы должны иметь тип. Например, терминал ID имеет тип string, а терминал INTNUM - тип int.
Для задания этих типов используют структуру-объединение вида

<source lang="CSharp">%union
{
public bool bVal;
public string sVal;
public int iVal;
public ident id;
public ident_list il;
public statement st;
public statement_list sl;
...
}
</source>

Если с терминалом или нетерминалом необходимо связать значение некоторого типа, то поле этого типа описывается в структуре union. Например, чтобы связать с терминалом ID значение строкового типа, необходимо описать в структуре union поле
<source lang="CSharp">public string sVal;
</source>
После этого необходимо описать типизированный терминал следующим образом:
<source lang="CSharp">%token <sVal> ID
</source>
Аналогично чтобы связать с нетерминалом Assignment тип statement, необходимо описать в структуре union поле
<source lang="CSharp">public statement st;
</source>
и после этого связать поле st с нетерминалом Assignment следующим образом:
<source lang="CSharp">%type <st> Assignment</source>

Полный код описаний для типов терминалов и нетерминалов, а также полей структуры union имеет вид:
<source lang="CSharp">%union
{
public bool bVal;
public string sVal;
public int iVal;
public named_type_reference ntr;
public ident_list il;
public var_def_statement vds;
public variable_definitions vdss;
public expression ex;
public expression_list el;
public ident id;
public statement st;
public statement_list sl;
public declarations decl;
public Operators op;
public simple_const_definition scd;
public consts_definitions_list cdl;
}

%token <sVal> ID
%token <iVal> INTNUM
%token <bVal> TRUE FALSE
%token <op> PLUS MINUS MULT DIVIDE AND OR LT GT LE GE EQ NE
%token NOT
%token ASSIGN SEMICOLUMN LPAREN RPAREN COLUMN COMMA COLON EXCLAMATION
%token TRUE FALSE ODD BOOLEAN INTEGER
%token IF THEN ELSE BEGIN END WHILE DO MODULE CONST VAR
%token INVISIBLE

%type <id> ident
%type <ntr> type
%type <ex> expr ConstExpr
%type <st> Assignment IfStatement WhileStatement WriteStatement Statement
%type <st> EmptyStatement ProcCallStatement
%type <sl> StatementSequence
%type <decl> Declarations
%type <el> factparams
%type <il> IDList
%type <vds> VarDecl
%type <vdss> VarDeclarations VarDeclarationsSect
%type <scd> ConstDecl
%type <cdl> ConstDeclarations ConstDeclarationsSect</source>

===== Приоритеты операций языка =====
Чтобы не задавать приоритеты операций в грамматике, в Yacc-системах используется секция задания приоритетов операций. Она имеет вид:
<source lang="CSharp">
%left LT GT LE GE EQ NE
%left PLUS MINUS OR
%left MULT DIVIDE AND
%left NOT
%left UMINUS</source>
Операции задаются в порядке от самого низкого приоритета до самого высокого.

После такого задания приоритетов операций в грамматике выражений можно писать:
<source lang="CSharp">expr
: expr PLUS expr
| expr MULT expr
| expr AND expr
| expr OR expr
| expr EQ expr
...
</source>
и это не вызовет неоднозначности грамматики.

==== Секция правил грамматики ====
Попробуем проследить, как распознаются правила грамматики.

===== Правило Assignment =====
Рассмотрим вначале правило для оператора присваивания:
<source lang="CSharp">Assignment : ident ASSIGN expr {
$$ = new assign($1, $3, Operators.Assignment,@$);
}
;
</source>
Здесь формируется узел синтаксического дерева для оператора присваивания. assign - это класс - наследник syntax_tree_node, который хранит всю синтаксическую информацию об операторе присваивания: идентификатор в левой части, выражение в правой части, тип оператора присваивания (в данном случае обычное присваивание, есть ещё += *= и т.д.), а также позиция конструкции присваивания в тексте программы. В данной записи $$ обозначает нетерминал в левой части, $1 - первый символ (нетерминал или терминал) в правой части правила, $2 - второй символ в правой части правила и т.д. Таким образом, $$ соответствует символу
Assignment, $1 - символу ident, а $3 - символу expr. Очень важно, что если типы соответствующих символов были прописаны в секции описаний, то выражения $$, $1, $2 и т.д. имеют ровно эти типы. Узнаем в разделе описаний типы Assignment, ident и expr:
<source lang="CSharp">%type <st> Assignment
%type <id> ident
%type <ex> expr</source>
Теперь заглянём в структуру union:
<source lang="CSharp">%union
{
public expression ex;
public ident id;
public statement st;
}</source>
Таким образом, можно сделать вывод, что $$ имеет тип statement, $1 - тип ident, а $3 - тип expression.
Если окажется, что для какого-то нетерминала или терминала не определен тип, то считается, что соответствующий символ $... имеет тип Object.

Наконец, обратим внимание на символ @$. Он соответствует положению в тексте символа Assignment из левой части правила. Тип символа @$ - LexLocation (это стандартный тип библиотеки GPPG), неявно преобразующийся в тип SourceContext (это тип библиотеки PascalABC.NET; можно для простоты считать, что @$ имеет тип SourceContext). Аналогично @1 - это SourceContext для первого символа в правой части, @2 - для второго и т.д.

Как правило, в большинстве узлов @$ будет передаваться в качестве последнего параметра конструктора.

===== Правило StatementSequence =====
Правило для StatementSequence имеет вид:
<source lang="CSharp">StatementSequence
: Statement {
$$ = new statement_list($1,@$);
}
| StatementSequence SEMICOLUMN Statement {
$1.Add($3,@$);
$$ = $1;
}
;
</source>
Здесь формируется список операторов, которые в программе разделены точкой с запятой. Обратим внимание, что за счёт леворекурсивности этого правила первым заканчивается разбор первого оператора Statement - в этот момент мы и создаём statement_list вызовом конструктора. В рекурсивной части считается, что statement_list уже создан, и мы добавляем в него следующий Statement с помощью метода Add класса statement_list.

Во втором правиле есть и ещё одна тонкость, рассмотрим её подробнее - она часто встречается. Рассмотрим ещё раз второе правило внимательнее:
<source lang="CSharp">StatementSequence : StatementSequence SEMICOLUMN Statement
{
$1.Add($3,@$);
$$ = $1;
}
</source>
Здесь надо понимать, что на момент разбора этого правила StatementSequence в левой части ещё не определен, а StatementSequence в правой части, напротив, определен на предыдущих шагах. Поэтому мы вначале к переменной $1, связанной со StatementSequence в правой части и имеющей тип statement_list, добавляем Statement, хранящийся в $3, после чего инициализируем StatementSequence в левой части, присваивая ему StatementSequence из правой части: $$ = $1. За счёт ссылочной модели объектов в C# здесь можно было бы поступить и иначе:
<source lang="CSharp">{
$$ = $1;
$$.Add($3,@$);
}</source>
или даже так:
<source lang="CSharp">{
$$ = $1;
$1.Add($3,@$);
}</source>
- всё равно после присваивания $$ = $1 переменные $$ и $1 указывают на один объект.

===== Правила Statement =====
Проследим далее за правилами Statement:
<source lang="CSharp">Statement: Assignment
| IfStatement
| WhileStatement
| WriteStatement
| ProcCallStatement
| EmptyStatement
;
</source>
Здесь нет действий в {}, поэтому по умолчанию всегда подразумевается действие '''$$ := $1''', что нам и надо.

Рассмотрим ещё несколько правил, в которых есть ранее не встречавшиеся моменты.

===== Правило ident =====
Чтобы не преобразовывать всякий раз строковый ID в узел синтаксического дерева ident, введено правило:
<source lang="CSharp">ident : ID {
$$ = new ident($1,@$);
}
;</source>

===== Правило для унарного минуса =====
Правило для унарного минуса имеет вид:
<source lang="CSharp">expr : MINUS expr %prec UMINUS {
$$ = new un_expr($2,Operators.Minus,@$);
}</source>
Ключевое слово %prec меняет в рамках одного правила приоритет операции MINUS и делает его таким же, как и у UMINUS. Заметим, что терминал UMINUS - фиктивный - он не может возникнуть при лексическом разборе, и задаётся только в секции приоритетов операций - последним и, значит, самым приоритетным.

===== Правило для всей программы =====
Вся программа на Oberon00 представляет собой модуль:
<source lang="CSharp">module : MODULE ident SEMICOLUMN mainblock ident COMMA
</source>
По этому правилу производятся следующие действия:
<source lang="CSharp">{
if ($2.name != $5.name)
PT.AddError("Имя "+$5.name+" должно совпадать с именем модуля "+$2.name,@5);

// Подключение стандартного модуля Oberon00System, написанного на PascalABC.NET
var ul = new uses_list("Oberon00System");

// Формирование модуля основной программы (используется фабричный метод вместо конструктора)
root = program_module.create($2, ul, $4, @$);
}
</source>
Поясним их подробнее. Во-первых, проверяется, совпадает ли имя модуля в начале и в конце программы и если нет. то генерируется семантическая ошибка с помощью PT.AddError (эта ошибка будет добавлена в окно ошибок компиляции). Заметим, что на этапе построения синтаксического дерева можно распознать и диагностировать некоторые синтаксические ошибки.

Затем в начало списка подключаемых модулей добавляется так называемый системный модуль Oberon00System - он написан на Паскале и должен быть откомпилирован в .pcu.

После этого формируется синтаксический узел для всей программы (класс program_module) и присваивается переменной root.

=== Создание системного модуля ===
Напишем для компилятора Oberon00 простой системный модуль на паскале Obеron00System.pas:
<source lang="Delphi">
unit Oberon00System;

interface

procedure Print(o: object);
procedure Println(o: object);
procedure Println;

implementation

uses System;

procedure Print(o: object);
begin
Console.Write(o);
end;

/// Вывести значение
procedure Println(o: object);
begin
Console.WriteLine(o);
end;

procedure Println;
begin
Console.WriteLine;
end;

end.</source>
Именно он подключается автоматически к любой программе на Обероне в действиях для правила module:
<source lang="Delphi">...
var ul = new uses_list("Oberon00System");</source>
В принципе, этот модуль можно было написать на самом Обероне, но в Обероне нет возможности прямого доступа к .NET-библиотекам.

Замечательная особенность среды PascalABC.NET - возможность совмещать разные языки программирования в одном проекте на уровне исходных кодов.

=== Обработка ошибок ===

=== Создание парсера-плагина для среды PascalABC.NET ===

=== Инсталляция плагина ===

Как создать компилятор

2010-07-28T15:01:12Z

Ulysses: /* Что входит в комплект разработчика парсеров */ оформлен wiki-список

=== Общие замечания ===
Сразу скачиваем [http://pascalabc.net/downloads/CompilerConstruction/Oberon00Independent.zip полный комплект разработчика парсеров].

В инфраструктуре PascalABC.NET несложно создавать компиляторы простых языков программирования. Программы, получаемые на таких языках, компилируются в .NET-код и работают, как и любой .NET-код, практически так же производительно, как и машинный.

Для создания компилятора важно понимать следующее. Компилятор имеет несколько внутренних представлений.

* Вначале текст программы разбирается им в так называемое '''синтаксическое дерево'''. Синтаксическое дерево содержит представленный в виде дерева текст программы - семантика на этом уровне не учитывается, проверяется только соответствие синтаксическим конструкциям. Например, на уровне синтаксического дерева не распознаётся ошибка описания двух переменных с одним именем - с точки зрения синтаксиса ошибки нет.
* Затем синтаксическое дерево переводится в '''семантическое дерево'''. Семантическое дерево учитывает все правила, которые сформулированы в описании языка: в частности, то, что в одном пространстве имен нельзя описать две переменные с одним именем. Кроме этого, в семантическом дереве хранится существенно больше информации, чем в синтаксическом: каждая переменная имеет тип, относится к определенному пространству имен, для подпрограмм проверяется соответствие количества и типов формальных и фактических параметров и т.д.
:Заметим, что семантическое дерево, если получено, то содержит '''правильную''' программу. Семантическое дерево откомпилированного модуля можно сохранить на диск для ускорения компиляции. В PascalABC.NET так и происходит: если модуль успешно откомпилирован, то он сохраняется в .pcu-файл - это не что иное как записанное на диск семантическое дерево модуля. Если при компиляции основной программы к ней подключен данный модуль, то он повторно не компилируется - его дерево разворачивается из .pcu-файла в память, что гораздо быстрее.
* Наконец, по семантическому дереву генерируется .NET-код.

Заметим, что такое разделение на синтаксическое и семантическое деревья позволяет упростить процесс создания новых языков. В частности, если язык достаточно простой и похож на Паскаль, то он может быть переведен в синтаксическое дерево, после чего достаточно использовать стандартный преобразователь в семантическое дерево и генератор кода. Для более сложных языков с семантикой, отличной от Паскаля, для некоторых узлов синтаксического дерева необходимо писать свой преобразователь в узлы семантического дерева. в ещё более сложных ситуациях имеющихся узлов семантического дерева может оказаться недостаточно, поэтому придется создавать новые и писать для них генерацию .NET-кода.

Далее мы будем рассматривать только такие языки, в которых текст программы достаточно перевести в синтаксическое дерево, что означает, что семантика конструкций - такая же, как и в Паскале. Например, это означает, что целый тип неявно преобразуется в вещественный, но не наоборот.

Следует отметить, что в большинстве ситуаций за счёт проведения дополнительных проверок перевода в узлы синтаксического дерева вполне достаточно. Далее это станет понятнее на конкретных примерах.

Рассмотрим создание простого языка, который мы назовём Oberon00. Это - подмножество языка Oberon с двумя типами - INTEGER и BOOLEAN - и возможностью вызывать процедуры из внешних модулей.

=== Что нужно для создания компилятора ===

Для создания компилятора, интегрированного в среду PascalABC.NET, нам потребуется создать несколько файлов. В случае языка Oberon00 потребуется создать:
* Oberon00Parser.dll - библиотеку, содержащую парсер языка (ее следует скопировать в папку установки PascalABC.NET)
* Oberon00.xhsd - файл подсветки синтаксиса (скопировать в папку PascalABC.NET\Highlighting)
Кроме этого, обычно требуется системный модуль, содержащий стандартные подпрограммы. Его можно создать на языке Паскаль. Пусть для Оберона00 этот модуль называется Oberon00System.pas. Требуется откомпилировать его в .pcu и затем
* Скопировать Oberon00System.pas в папку PascalABC.NET\LibSource
* Скопировать Oberon00System.pcu в папку PascalABC.NET\Lib

Перезапустив среду PascalABC.NET, мы получим новый компилятор.

Для того чтобы сразу увидеть конечный результат, можно скопировать [http://pascalabc.net/downloads/CompilerConstruction/Oberon00Independent.zip полный комплект разработчика парсеров].

=== Что входит в комплект разработчика парсеров ===
# Папка DLL, содержащая dll из комплекта PascalABC.NET, необходимые для создания парсера.
# Папка GPLex_GPPG, содержащая генератор компиляторов GPLex+GPPG и документацию к нему.
# Папка Install, содержащая файлы, которые необходимо скопировать в папку PascalABC.NET для того чтобы в оболочке PascalABc.NET появился компилятор нового языка.
# Файл generate_all.bat для компиляции файлов .lex и .y в файлы .cs, компиляции проекта и получения библиотеки Oberon00Parser.dll и копирования этого файла в папку Install.

Далее разберем последовательно, как создать парсер.

=== Лексический анализатор GPLex и синтаксический анализатор GPPG ===

Итак, наша задача - разобрать текст программы и по нему получить синтаксическое дерево программы. Такой построитель синтаксического дерева программы будем называть '''парсером''' или '''синтаксическим анализатором'''. Для работы синтаксического анализатора необходим также '''сканер''' или '''лексический анализатор''', который разбивает программу на лексемы - неделимые слова. Например, в языке Паскаль лексемами являются ключевые слова, идентификаторы, числовые и строковые константы, знаки операций (:= <> и т.д.).

Синтаксические анализаторы обычно создаются с помощью специальных программ, называемых '''генераторами компиляторов'''. Одним из наиболее известных генераторов компиляторов является '''Yacc''' (Yet Another Compiler of Compilers) - и в паре с ним работает генератор лексических анализаторов '''Lex'''.

Наиболее полной реализацией Yacc-Lex для .NET, генерирующей код парсера на C#, является GPLex+GPPG, разработанный Queensland University of Technology, Австралия. Вот странички продуктов: [http://plas2003.fit.qut.edu.au/gplex/ GPLex] и [http://plas2003.fit.qut.edu.au/gppg/ GPPG]. Однако, рекомендуется [http://pascalabc.net/downloads/CompilerConstruction/GPLex_GPPG_2010.zip скачать исполнимые файлы отсюда] - они содержат небольшие модификации, связанные с корректной русификацией.

=== Создание лексического анализатора ===
==== Класс Scanner ====
Создаваемый в результате компиляции .lex-файла класс '''Scanner''' содержит несколько важных методов и свойств. Рассмотрим их подробнее.

* Функция int '''yylex'''() возвращает уникальный номер лексемы. Все лексемы хранятся в перечислимом типе Tokens. По-существу, возвращается номер константы в перечислимом типе Tokens - например, для лексемы ID возвращается (int)Tokens.ID
* Помимо уникального номера некоторые лексемы должны возвращать дополнительные значения. Таким значением для идентификатора является его строковое представление, для INTNUM - целое число и т.д. Дополнительное значение для некоторых лексем возвращается в свойстве '''yylval''', которое имеет тип ValueType и содержит ряд полей различных типов - для каждой лексемы может быть предусмотрено своё поле. Например, для лексемы ID предусмотрено поле string sVal, а для лексемы INTNUM - поле iVal.
Объяснение того, как это поле сопоставляется с типом лексемы, отложим до знакомства с содержимым файла .y
* Свойство '''yytext''' возвращает строковое представление текущей лексемы
* Свойство '''yylloc''' содержит положение лексемы в тексте, задаваемое типом LexLocation из пространства имен QUT.Gppg. Он хранит координаты начала и конца лексемы

==== Файл .lex ====
Лексический анализатор обычно создается в файле с расширением .lex. Он имеет вид:

Определения
%%
Правила
%%
Пользовательский код

Рассмотрим файл лексического анализатора Oberon00.lex:
<source lang="CSharp">%namespace GPPGParserScanner

%using PascalABCCompiler.Oberon00Parser;

Alpha [a-zA-Z_]
Digit [0-9]
AlphaDigit {Alpha}|{Digit}
INTNUM {Digit}+
ID {Alpha}{AlphaDigit}*

%%

":=" { return (int)Tokens.ASSIGN; }
";" { return (int)Tokens.SEMICOLUMN; }
"-" { return (int)Tokens.MINUS; }
"+" { return (int)Tokens.PLUS; }
"*" { return (int)Tokens.MULT; }
"/" { return (int)Tokens.DIVIDE; }
"<" { return (int)Tokens.LT; }
">" { return (int)Tokens.GT; }
"<=" { return (int)Tokens.LE; }
">=" { return (int)Tokens.GE; }
"=" { return (int)Tokens.EQ; }
"#" { return (int)Tokens.NE; }
"(" { return (int)Tokens.LPAREN; }
")" { return (int)Tokens.RPAREN; }
"," { return (int)Tokens.COLUMN; }
"~" { return (int)Tokens.NOT; }
"&" { return (int)Tokens.AND; }
"." { return (int)Tokens.COMMA; }
":" { return (int)Tokens.COLON; }
"!" { return (int)Tokens.EXCLAMATION; }
\x01 { return (int)Tokens.INVISIBLE; }

{ID} {
int res = Keywords.KeywordOrIDToken(yytext);
if (res == (int)Tokens.ID)
yylval.sVal = yytext;
return res;
}

{INTNUM} {
yylval.iVal = int.Parse(yytext);
return (int)Tokens.INTNUM;
}

%{
yylloc = new QUT.Gppg.LexLocation(tokLin, tokCol, tokELin, tokECol);
%}

%%

public override void yyerror(string format, params object[] args)
{
string errorMsg = PT.CreateErrorString(args);
PT.AddError(errorMsg,yylloc);
}</source>

После обработки генератором лексических анализаторов GPLex мы получим одноименный cs-файл Oberon00.cs, содержащий класс Scanner лексического анализатора.

Разберем содержимое .lex-файла подробнее.

==== Секция определений ====

Вначале рассмотрим первую часть, содержащую определения лексем:

<source lang="CSharp">%namespace GPPGParserScanner

%using PascalABCCompiler.Oberon00Parser;

Alpha [a-zA-Z_]
Digit [0-9]
AlphaDigit {Alpha}|{Digit}
INTNUM {Digit}+
ID {Alpha}{AlphaDigit}*
</source>

Строка %namespace GPPGParserScanner означает, что класс сканера будет помещен в пространство имен GPPGParserScanner

Строка %using PascalABCCompiler.Oberon00Parser; приводит к генерации соответствующей строки в cs-файле. Пространство имен PascalABCCompiler.Oberon00Parser полностью находится во вспомогательном файле Oberon00ParserTools.cs, который содержит различные глобальные описания и подпрограммы (подробнее содержимое этого файла будет объяснено позже).

Далее идёт описание некоторых лексем в виде регулярных выражений. Например, целое число INTNUM представляет собой последовательность одной или более цифр {Digit}+, а идентификатор ID - последовательность букв или цифр, начинающуюся с буквы: {Alpha}{AlphaDigit}*

==== Секция правил ====

Вторая секция (между первым и вторым %%) является основной и содержит действия, которые необходимо выполнить, когда распознана та или иная лексема.

<source lang="CSharp">":=" { return (int)Tokens.ASSIGN; }
";" { return (int)Tokens.SEMICOLUMN; }
"-" { return (int)Tokens.MINUS; }
"+" { return (int)Tokens.PLUS; }
"*" { return (int)Tokens.MULT; }
"/" { return (int)Tokens.DIVIDE; }
"<" { return (int)Tokens.LT; }
">" { return (int)Tokens.GT; }
"<=" { return (int)Tokens.LE; }
">=" { return (int)Tokens.GE; }
"=" { return (int)Tokens.EQ; }
"#" { return (int)Tokens.NE; }
"(" { return (int)Tokens.LPAREN; }
")" { return (int)Tokens.RPAREN; }
"," { return (int)Tokens.COLUMN; }
"~" { return (int)Tokens.NOT; }
"&" { return (int)Tokens.AND; }
"." { return (int)Tokens.COMMA; }
":" { return (int)Tokens.COLON; }
"!" { return (int)Tokens.EXCLAMATION; }
\x01 { return (int)Tokens.INVISIBLE; }

{ID} {
int res = Keywords.KeywordOrIDToken(yytext);
if (res == (int)Tokens.ID)
yylval.sVal = yytext;
return res;
}

{INTNUM} {
yylval.iVal = int.Parse(yytext);
return (int)Tokens.INTNUM;
}</source>
Здесь приведены действия в случае если встречена та или иная лексема. Большинство действий просто возвращает порядковый номер лексемы в перечислимом типе Tokens.

Последняя лексема - INVISIBLE - символ с кодом 1 - необязательна и является вспомогательной для компилятора выражений языка (необходим для поддержки IntelliSense).

В случае лексемы INTNUM в поле yylval.iVal дополнительно возвращается целое число, соответствующее лексеме: int.Parse(yytext). Обратим внимание, что здесь нет никакой защиты от неправильного преобразования (например, в случае очень длинного целого). Причина - чтобы пока не усложнять изложение обработкой ошибок.

В случае лексемы ID вначале проверяется, не является ли она ключевым словом, и если является, то возвращается целое, соответствующее лексеме ключевого слова (например, для BEGIN возвращается (int)Tokens.BEGIN), а если не является, то возвращается (int)Tokens.ID и параллельно в поле yylval.sVal возвращается строковое представление идентификатора. Именно на этом уровне мы можем задать, чувствителен ли наш язык к регистру (например, преобразованием всех идентификаторов к UpperCase).

Секция правил завершается следующим кодом:
<source lang="CSharp">%{
yylloc = new QUT.Gppg.LexLocation(tokLin, tokCol, tokELin, tokECol);
%}</source>
Этот код позволяет для каждой лексемы получать её местоположение в тексте. Вникать в этот код не надо - он просто необходим.

==== Секция пользовательского кода ====
Наконец, в секции пользовательского кода содержится единственный переопределенный в классе Scanner метод

<source lang="CSharp">public override void yyerror(string format, params object[] args)
{
string errorMsg = PT.CreateErrorString(args);
PT.AddError(errorMsg,yylloc);
}
</source>
Он вызывается всякий раз когда происходит синтаксическая ошибка. Здесь мы пользуемся услугами статического класса PT, который находится в файле Oberon00ParserTools.cs. PT.CreateErrorString(args) формирует строку ошибки, а PT.AddError(errorMsg,yylloc); добавляет ошибку в список ошибок компиляции PascalABC.NET. Здесь интересно то, что в случае автоматического вызова yyerror в args попадают токены, которые ожидались после данного.

==== Генерация кода лексического анализатора ====
Для генерации кода лексического анализатора следует выполнить команду:
gplex.exe /unicode oberon00.lex
Здесь gplex.exe - генератор лексических анализаторов, хранящийся в папке GPLex_GPPG, параметр /unicode указывает на то, что созданный лексический анализатор будет распознавать файлы в кодировке unicode (заметим, что он будет распознавать и однобайтные кодировки).

=== Создание синтаксического анализатора ===
==== Общая информация ====
Синтаксический анализатор - ядро нашего компилятора. Он строится по .y - файлу, в котором записываются правила '''грамматики языка''' и действия, которые выполняются по этим правилам. Каждое из действий создает соответствующий узел в синтаксическом дереве. Все узлы синтаксического дерева представляют собой иерархию классов с общим предком syntax_tree_node и описаны во внешней библиотеке SyntaxTree.dll.

Для понимания дальнейшего следует иметь некоторое начальное представление о грамматиках языков программирования, о том, как они порождают языки и об автоматах, которые проверяют, принадлежит ли данная цепочка символов языку, порождаемому грамматикой. Более конкретно, следует представлять, что такое '''контекстно-свободная грамматика''', что Yacc-Lex системы работают с так называемыми LL(k) грамматиками, являющимися достаточно широким подмножеством контекстно-свободных грамматик.

В процессе построения грамматик придется сталкиваться с недостижимыми и циклическими продукциями грамматик, неоднозначными грамматиками. Необходимо уметь исправлять подобные ситуации хотя бы методом проб и ошибок. Особенно необходимо понимать, что Shift-Reduce - конфликты грамматик допустимы и разрешаются в пользу более длинной правой части продукции, а Reduce-Reduce - конфликты недопустимы и свидетельствуют об ошибках проектирования грамматики.

Соответствующую информацию можно прочитать в книге Ахо "Компиляторы: принципы, технологии, инструменты".

==== Некоторые классы синтаксического дерева ====
Как уже было сказано, синтаксическое дерево состоит из объектов классов - наследников syntax_tree_node. Перечислим некоторые важные классы - наследники syntax_tree_node, которые будут нами использованы для реализации парсера Оберона00:

ident - идентификатор
ident_list - список идентификаторов
uses_list - список модулей и пространств имен в секции uses
unit_or_namespace - модуль или пространство имен
block - блок
program_module - программа
int32_const - целая константа
bool_const - логическая константа
expression - выражение (базовый класс для всех выражений)
expression_list - список выражений
un_expr - унарное ввыражение
bin_expr - бинарное выражение
assign - оператор присваивания
if_node - условный оператор
while_node - оператор цикла while
empty_statement - пустой оператор
method_call - вызов метода или внешней подпрограммы
statement_list - последовательность операторов
named_type_reference - имя типа
declarations - описания
var_def_statement - описания переменных с одним типом
variable_definitions - секция объявлений переменных
simple_const_definition - определение именованной константы
consts_definitions_list - секция определений именованных констант

Каждый класс имеет свои поля, все необходимые поля заполняются обычно в конструкторе класса. В базовом классе syntax_tree_node имеется поле source_context типа SourceContext, определяющее местоположение конструкции, соответствующей синтаксическому узлу, в тексте программы. Именно поэтому каждый конструктор синтаксического дерева содержит последним параметром объект класса SourceContext.

Просмотреть все узлы синтаксического дерева, их свойства и методы можно с помощью утилиты
[http://pascalabc.net/downloads/CompilerConstruction/NodesGenReader.zip Просмотрщик классов синтаксического дерева]

==== Правила грамматики ====
Правила грамматики содержат терминальные символы (терминалы), которые распознаются лексическим анализатором, и нетерминальные символы (нетерминалы). Каждое правило грамматики выражает нетерминал через другие терминалы и нетерминалы. Например, для оператора присваивания имеется следующее правило:

<source lang="text">AssignOperator : ID ASSIGN expr ;
</source>
Здесь нетерминал AssignOperator выражается через терминалы ID и ASSIGN и нетерминал expr, который будет определен в другом правиле.

Нетерминал, с которого начинается разбор, называется стартовым символом грамматики. Этот нетерминал описывает всю программу. В нашей грамматике это module, а соответствующее стартовое правило имеет вид:

<source lang="text">module : MODULE ident SEMICOLUMN Declarations BEGIN StatementSequence END ident COMMA</source>

В конечном итоге все нетерминалы выражаются через терминалы, образующие основную программу. Соответствующий процесс получения программы из стартового символа называется выводом, а правила грамматики - правилами вывода.

В каждом правиле может быть несколько альтернатив, разделяемых символом |:

<source lang="text">IfStatement
: IF expr THEN StatementSequence END
| IF expr THEN StatementSequence ELSE StatementSequence END
;</source>

Правила могут быть рекурсивными. Например, правило для фактических параметров имеет вид:
<source lang="text">factparams
: expr
| factparams COLUMN expr
;</source>

Обратим внимание, что данное правило является леворекурсивным, поскольку рекурсивное вхождение нетерминала factparams в правую часть правила находится с левой стороны. Для рассматриваемых нами генераторов компиляторов леворекурсивные правила являются предпочтительнее праворекурсивных.

==== Формат .y-файла ====
.y-файл имеет такой же формат, как и .lex:
Определения
%%
Правила
%%
Пользовательский код

==== Раздел определений .y-файла ====
===== Общий вид =====
Рассмотрим раздел определений файла Oberon00.y

<source lang="CSharp">%{
public syntax_tree_node root; // Корневой узел синтаксического дерева
public GPPGParser(AbstractScanner<ValueType, LexLocation> scanner) : base(scanner) { }
%}

%output=oberon00yacc.cs

%parsertype GPPGParser

%union
{
public bool bVal;
public string sVal;
public int iVal;
public named_type_reference ntr;
public ident_list il;
public var_def_statement vds;
public variable_definitions vdss;
public expression ex;
public expression_list el;
public ident id;
public statement st;
public statement_list sl;
public declarations decl;
public Operators op;
public simple_const_definition scd;
public consts_definitions_list cdl;
}

%using PascalABCCompiler.SyntaxTree
%using PascalABCCompiler.Errors
%using PascalABCCompiler.Oberon00Parser

%namespace GPPGParserScanner

%start module

%token <sVal> ID
%token <iVal> INTNUM
%token <bVal> TRUE FALSE
%token <op> PLUS MINUS MULT DIVIDE AND OR LT GT LE GE EQ NE
%token NOT
%token ASSIGN SEMICOLUMN LPAREN RPAREN COLUMN COMMA COLON EXCLAMATION
%token TRUE FALSE ODD BOOLEAN INTEGER
%token IF THEN ELSE BEGIN END WHILE DO MODULE CONST VAR
%token INVISIBLE

%type <id> ident
%type <ntr> type
%type <ex> expr ConstExpr
%type <st> Assignment IfStatement WhileStatement WriteStatement Statement
%type <st> EmptyStatement ProcCallStatement
%type <sl> StatementSequence
%type <decl> Declarations
%type <el> factparams
%type <il> IDList
%type <vds> VarDecl
%type <vdss> VarDeclarations VarDeclarationsSect
%type <scd> ConstDecl
%type <cdl> ConstDeclarations ConstDeclarationsSect

%left LT GT LE GE EQ NE
%left PLUS MINUS OR
%left MULT DIVIDE AND
%left NOT
%left UMINUS</source>

===== Начальные строки =====
Он состоит из нескольких неравнозначных частей. Первая часть заключена в символы %{ %} и содержит код на C#, который будет вставлен в создаваемый класс Parser:

<source lang="CSharp"> public syntax_tree_node root; // Корневой узел синтаксического дерева
public GPPGParser(AbstractScanner<ValueType, LexLocation> scanner) : base(scanner) { }
</source>
Здесь root - корневой узел синтаксического дерева программы, он явно описан как поле класса GPPGParser.
Описываемый во второй строке конструктор носит технический характер - его просто необходимо в этом месте написать. Думаю, что эта строчка связана с неудачным проектированием генератора парсеров GPPG - разработчик забыл в генерируемый класс включить этот нужный конструктор.

Строка
<source lang="Delphi">%output=oberon00yacc.cs</source>
означает, что компиляция .y-файла с помощью gppg.exe будет осуществляться в файл oberon00yacc.cs

Строка
<source lang="CSharp">%parsertype GPPGParser</source>
говорит о том, что класс парсера будет иметь имя GPPGParser

Строки
<source lang="CSharp">%using PascalABCCompiler.SyntaxTree
%using PascalABCCompiler.Errors
%using PascalABCCompiler.Oberon00Parser</source>
означают подключение в коде парсера соответствующих пространств имен (точки с запятой в конце строк не нужны в отличие от лексического анализатора - видимо, это ошибка проектирования gppg),
а строка
<source lang="CSharp">%namespace GPPGParserScanner</source>
означает, что класс парсера будет помещен в пространство имен GPPGParserScanner.

Строка
<source lang="Delphi">%start module</source>
означает, что стартовым в нашей грамматике является нетерминал module (обычно эту строку можно не писать - считается, что стартовым является нетерминал в левой части первого правила).

===== Описание используемых терминалов =====
Все используемые терминалы должны быть описаны в секции определений следующим образом:
<source lang="CSharp">%token ASSIGN SEMICOLUMN LPAREN RPAREN COLUMN COMMA COLON EXCLAMATION
</source>
Именно по этим определениям формируется перечислимый тип Tokens, который встречался в .lex-файле.

Кроме этого, некоторым терминалам и нетерминалам можно задавать тип.

===== Типы терминалов и нетерминалов =====

Большинство нетерминалов и некоторые терминалы должны иметь тип. Например, терминал ID имеет тип string, а терминал INTNUM - тип int.
Для задания этих типов используют структуру-объединение вида

<source lang="CSharp">%union
{
public bool bVal;
public string sVal;
public int iVal;
public ident id;
public ident_list il;
public statement st;
public statement_list sl;
...
}
</source>

Если с терминалом или нетерминалом необходимо связать значение некоторого типа, то поле этого типа описывается в структуре union. Например, чтобы связать с терминалом ID значение строкового типа, необходимо описать в структуре union поле
<source lang="CSharp">public string sVal;
</source>
После этого необходимо описать типизированный терминал следующим образом:
<source lang="CSharp">%token <sVal> ID
</source>
Аналогично чтобы связать с нетерминалом Assignment тип statement, необходимо описать в структуре union поле
<source lang="CSharp">public statement st;
</source>
и после этого связать поле st с нетерминалом Assignment следующим образом:
<source lang="CSharp">%type <st> Assignment</source>

Полный код описаний для типов терминалов и нетерминалов, а также полей структуры union имеет вид:
<source lang="CSharp">%union
{
public bool bVal;
public string sVal;
public int iVal;
public named_type_reference ntr;
public ident_list il;
public var_def_statement vds;
public variable_definitions vdss;
public expression ex;
public expression_list el;
public ident id;
public statement st;
public statement_list sl;
public declarations decl;
public Operators op;
public simple_const_definition scd;
public consts_definitions_list cdl;
}

%token <sVal> ID
%token <iVal> INTNUM
%token <bVal> TRUE FALSE
%token <op> PLUS MINUS MULT DIVIDE AND OR LT GT LE GE EQ NE
%token NOT
%token ASSIGN SEMICOLUMN LPAREN RPAREN COLUMN COMMA COLON EXCLAMATION
%token TRUE FALSE ODD BOOLEAN INTEGER
%token IF THEN ELSE BEGIN END WHILE DO MODULE CONST VAR
%token INVISIBLE

%type <id> ident
%type <ntr> type
%type <ex> expr ConstExpr
%type <st> Assignment IfStatement WhileStatement WriteStatement Statement
%type <st> EmptyStatement ProcCallStatement
%type <sl> StatementSequence
%type <decl> Declarations
%type <el> factparams
%type <il> IDList
%type <vds> VarDecl
%type <vdss> VarDeclarations VarDeclarationsSect
%type <scd> ConstDecl
%type <cdl> ConstDeclarations ConstDeclarationsSect</source>

===== Приоритеты операций языка =====
Чтобы не задавать приоритеты операций в грамматике, в Yacc-системах используется секция задания приоритетов операций. Она имеет вид:
<source lang="CSharp">
%left LT GT LE GE EQ NE
%left PLUS MINUS OR
%left MULT DIVIDE AND
%left NOT
%left UMINUS</source>
Операции задаются в порядке от самого низкого приоритета до самого высокого.

После такого задания приоритетов операций в грамматике выражений можно писать:
<source lang="CSharp">expr
: expr PLUS expr
| expr MULT expr
| expr AND expr
| expr OR expr
| expr EQ expr
...
</source>
и это не вызовет неоднозначности грамматики.

==== Секция правил грамматики ====
Попробуем проследить, как распознаются правила грамматики.

===== Правило Assignment =====
Рассмотрим вначале правило для оператора присваивания:
<source lang="CSharp">Assignment : ident ASSIGN expr {
$$ = new assign($1, $3, Operators.Assignment,@$);
}
;
</source>
Здесь формируется узел синтаксического дерева для оператора присваивания. assign - это класс - наследник syntax_tree_node, который хранит всю синтаксическую информацию об операторе присваивания: идентификатор в левой части, выражение в правой части, тип оператора присваивания (в данном случае обычное присваивание, есть ещё += *= и т.д.), а также позиция конструкции присваивания в тексте программы. В данной записи $$ обозначает нетерминал в левой части, $1 - первый символ (нетерминал или терминал) в правой части правила, $2 - второй символ в правой части правила и т.д. Таким образом, $$ соответствует символу
Assignment, $1 - символу ident, а $3 - символу expr. Очень важно, что если типы соответствующих символов были прописаны в секции описаний, то выражения $$, $1, $2 и т.д. имеют ровно эти типы. Узнаем в разделе описаний типы Assignment, ident и expr:
<source lang="CSharp">%type <st> Assignment
%type <id> ident
%type <ex> expr</source>
Теперь заглянём в структуру union:
<source lang="CSharp">%union
{
public expression ex;
public ident id;
public statement st;
}</source>
Таким образом, можно сделать вывод, что $$ имеет тип statement, $1 - тип ident, а $3 - тип expression.
Если окажется, что для какого-то нетерминала или терминала не определен тип, то считается, что соответствующий символ $... имеет тип Object.

Наконец, обратим внимание на символ @$. Он соответствует положению в тексте символа Assignment из левой части правила. Тип символа @$ - LexLocation (это стандартный тип библиотеки GPPG), неявно преобразующийся в тип SourceContext (это тип библиотеки PascalABC.NET; можно для простоты считать, что @$ имеет тип SourceContext). Аналогично @1 - это SourceContext для первого символа в правой части, @2 - для второго и т.д.

Как правило, в большинстве узлов @$ будет передаваться в качестве последнего параметра конструктора.

===== Правило StatementSequence =====
Правило для StatementSequence имеет вид:
<source lang="CSharp">StatementSequence
: Statement {
$$ = new statement_list($1,@$);
}
| StatementSequence SEMICOLUMN Statement {
$1.Add($3,@$);
$$ = $1;
}
;
</source>
Здесь формируется список операторов, которые в программе разделены точкой с запятой. Обратим внимание, что за счёт леворекурсивности этого правила первым заканчивается разбор первого оператора Statement - в этот момент мы и создаём statement_list вызовом конструктора. В рекурсивной части считается, что statement_list уже создан, и мы добавляем в него следующий Statement с помощью метода Add класса statement_list.

Во втором правиле есть и ещё одна тонкость, рассмотрим её подробнее - она часто встречается. Рассмотрим ещё раз второе правило внимательнее:
<source lang="CSharp">StatementSequence : StatementSequence SEMICOLUMN Statement
{
$1.Add($3,@$);
$$ = $1;
}
</source>
Здесь надо понимать, что на момент разбора этого правила StatementSequence в левой части ещё не определен, а StatementSequence в правой части, напротив, определен на предыдущих шагах. Поэтому мы вначале к переменной $1, связанной со StatementSequence в правой части и имеющей тип statement_list, добавляем Statement, хранящийся в $3, после чего инициализируем StatementSequence в левой части, присваивая ему StatementSequence из правой части: $$ = $1. За счёт ссылочной модели объектов в C# здесь можно было бы поступить и иначе:
<source lang="CSharp">{
$$ = $1;
$$.Add($3,@$);
}</source>
или даже так:
<source lang="CSharp">{
$$ = $1;
$1.Add($3,@$);
}</source>
- всё равно после присваивания $$ = $1 переменные $$ и $1 указывают на один объект.

===== Правила Statement =====
Проследим далее за правилами Statement:
<source lang="CSharp">Statement: Assignment
| IfStatement
| WhileStatement
| WriteStatement
| ProcCallStatement
| EmptyStatement
;
</source>
Здесь нет действий в {}, поэтому по умолчанию всегда подразумевается действие '''$$ := $1''', что нам и надо.

Рассмотрим ещё несколько правил, в которых есть ранее не встречавшиеся моменты.

===== Правило ident =====
Чтобы не преобразовывать всякий раз строковый ID в узел синтаксического дерева ident, введено правило:
<source lang="CSharp">ident : ID {
$$ = new ident($1,@$);
}
;</source>

===== Правило для унарного минуса =====
Правило для унарного минуса имеет вид:
<source lang="CSharp">expr : MINUS expr %prec UMINUS {
$$ = new un_expr($2,Operators.Minus,@$);
}</source>
Ключевое слово %prec меняет в рамках одного правила приоритет операции MINUS и делает его таким же, как и у UMINUS. Заметим, что терминал UMINUS - фиктивный - он не может возникнуть при лексическом разборе, и задаётся только в секции приоритетов операций - последним и, значит, самым приоритетным.

===== Правило для всей программы =====
Вся программа на Oberon00 представляет собой модуль:
<source lang="CSharp">module : MODULE ident SEMICOLUMN mainblock ident COMMA
</source>
По этому правилу производятся следующие действия:
<source lang="CSharp">{
if ($2.name != $5.name)
PT.AddError("Имя "+$5.name+" должно совпадать с именем модуля "+$2.name,@5);

// Подключение стандартного модуля Oberon00System, написанного на PascalABC.NET
var ul = new uses_list("Oberon00System");

// Формирование модуля основной программы (используется фабричный метод вместо конструктора)
root = program_module.create($2, ul, $4, @$);
}
</source>
Поясним их подробнее. Во-первых, проверяется, совпадает ли имя модуля в начале и в конце программы и если нет. то генерируется семантическая ошибка с помощью PT.AddError (эта ошибка будет добавлена в окно ошибок компиляции). Заметим, что на этапе построения синтаксического дерева можно распознать и диагностировать некоторые синтаксические ошибки.

Затем в начало списка подключаемых модулей добавляется так называемый системный модуль Oberon00System - он написан на Паскале и должен быть откомпилирован в .pcu.

После этого формируется синтаксический узел для всей программы (класс program_module) и присваивается переменной root.

=== Создание системного модуля ===
Напишем для компилятора Oberon00 простой системный модуль на паскале Obеron00System.pas:
<source lang="Delphi">
unit Oberon00System;

interface

procedure Print(o: object);
procedure Println(o: object);
procedure Println;

implementation

uses System;

procedure Print(o: object);
begin
Console.Write(o);
end;

/// Вывести значение
procedure Println(o: object);
begin
Console.WriteLine(o);
end;

procedure Println;
begin
Console.WriteLine;
end;

end.</source>
Именно он подключается автоматически к любой программе на Обероне в действиях для правила module:
<source lang="Delphi">...
var ul = new uses_list("Oberon00System");</source>
В принципе, этот модуль можно было написать на самом Обероне, но в Обероне нет возможности прямого доступа к .NET-библиотекам.

Замечательная особенность среды PascalABC.NET - возможность совмещать разные языки программирования в одном проекте на уровне исходных кодов.

=== Обработка ошибок ===

=== Создание парсера-плагина для среды PascalABC.NET ===

=== Инсталляция плагина ===

Обсуждение:Проект "MonoDevelop Add-in для PascalABC.NET"

2009-12-19T23:15:14Z

Ulysses: орфография

<blockquote>Добавление в программу MonoDevelop "плагинов" (Mono.Addins) реализованно намного удобней, чем по сравнению с инструментом SharpDevelop, который реализован на основе идей от Eclipse add-in engine (добавления "плагинов" в системе Eclipse).</blockquote>
А можно какие-то пруфлинки: 1) насчёт «удобней», 2) насчёт того, что SharpDevelop использует идеи Eclipse (беглый просмотр [http://wiki.sharpdevelop.net/AddinWritingHelp.ashx офсайта] ничего подобного не показал), 3) что за зверь Eclipse add-in engine — модульность Eclipse основана на том, что Eclipse, а верней, одна из компонент его, Equinox, реализует стандарт [http://en.wikipedia.org/wiki/OSGi OSGi], на который сейчас перешли уже почти все Java app-сервера (GlassFish, JBoss, Weblogic и т.д.), в связи с чем эти заявления про «неудобность» выглядят как-то неправдоподобно... — [[Участник:Ulysses|Ulysses]] 16:43, 15 декабря 2009 (UTC).

Да уж, удобнее. То-то мы не можем уже 4 месяца разобраться, как это делается. И форум Mono Developа молчит. Еще немного - будем делать плагин к менее удобному Eclipse.
[[Участник:Mikst|Mikst]] 20:09, 19 декабря 2009 (UTC)

Рефакторинг

2009-12-15T16:54:12Z

Ulysses: /* Ссылки */

'''Рефакторинг''' — процесс полного или частичного преобразования внутренней структуры программы при сохранении её внешнего поведения.

== Литература ==
* [http://djvu.504.com1.ru:8019/WWW/0dd8afebee3171e2ce06a1a0ef42e4f4.pdf Фаулер М. Рефакторинг. Улучшение существующего кода 2003]
* [http://www.brain2life.com/book/358.html Макконнелл С. Совершенный код. 2-e издание]

== Ссылки ==
* [http://www.refactoring.com/ Домашняя страница Мартина Фаулера о рефакторинге]
* [http://ru.wikipedia.org/wiki/Рефакторинг http://ru.wikipedia.org/wiki/Рефакторинг]
* [http://help.eclipse.org/help32/index.jsp?topic=/org.eclipse.jdt.doc.user/reference/ref-menu-refactor.htm Возможности по рефакторингу Eclipse IDE]

Обсуждение:Проект "MonoDevelop Add-in для PascalABC.NET"

2009-12-15T16:43:31Z

Ulysses: Новая: <blockquote>Добавление в программу MonoDevelop "плагинов" (Mono.Addins) реализованно намного удобней, чем по сравнению...

<blockquote>Добавление в программу MonoDevelop "плагинов" (Mono.Addins) реализованно намного удобней, чем по сравнению с инструментом SharpDevelop, который реализован на основе идей от Eclipse add-in engine (добавления "плагинов" в системе Eclipse).</blockquote>
А можно какие-то пруфы: 1) насчёт «удобней», 2) насчёт того, что SharpDevelop использует идеи Eclipse (беглый просмотр [http://wiki.sharpdevelop.net/AddinWritingHelp.ashx офсайта] ничего подобного не показал), 3) что за зверь Eclipse add-in engine — модульность Eclipse основана на том, что Eclipse, а верней, одна из компонент его, Equinox, реализует стандарт [http://en.wikipedia.org/wiki/OSGi OSGi], на который сейчас перешли уже почти все Java app-сервера (GlassFish, JBoss, Weblogic и т.д.), в связи с чем эти заявления про неудобность выгледят как-то неправдоподобно... — [[Участник:Ulysses|Ulysses]] 16:43, 15 декабря 2009 (UTC).

Обсуждение:Обзор реализации основных возможностей функционального языка программирования в среде PascalABC.NET

2009-12-15T16:28:25Z

Ulysses:

<blockquote>Такие языки как Haskell и Clean имеют 100% соответствие своей семантики с семантикой подразумеваемых конструкций лямбда-исчисления.</blockquote>Такая фраза выглядит некорректно: под словосочетанием «семантика лямбда-исчисления» понимается [http://en.wikipedia.org/wiki/Lambda_calculus#Semantics вполне определённая вещь], которая здесь явно ввиду не имелась. Так что я бы рекомендовал изложить эту мысль какими-то другими словами. Можно взять какую-нибудь книжку по Хаскелю и оттуда списать. — [[Участник:Ulysses|Ulysses]] 16:28, 15 декабря 2009 (UTC).

Участник:Ulysses

2009-12-15T16:25:27Z

Ulysses: Новая: Это он. Вы не ошиблись.

Это он. Вы не ошиблись.

Обсуждение:Обзор реализации основных возможностей функционального языка программирования в среде PascalABC.NET

2009-12-15T16:25:05Z

Ulysses: Новая: <blockquote>Такие языки как Haskell и Clean имеют 100% соответствие своей семантики с семантикой подразумеваемых к...

<blockquote>Такие языки как Haskell и Clean имеют 100% соответствие своей семантики с семантикой подразумеваемых конструкций лямбда-исчисления.</blockquote>Такая фраза взрывает мозг любому хоть немного знакомому с лямбда-исчислением. Под словосочетанием «семантика лямбда-исчисления» понимается [http://en.wikipedia.org/wiki/Lambda_calculus#Semantics вполне конкретная вещь], которая здесь явно ввиду не имелась. Так что я бы рекомендовал изложить эту мысль какими-то другими словами. Можно взять какую-нибудь книжку по Хаскелю и оттуда списать. — [[Участник:Ulysses|Ulysses]] 16:25, 15 декабря 2009 (UTC).