Ниже приводится скриншот данного плагина:

Для «перехвата» синтаксического дерева необходимо подключится к событию OnChangeCompilerState компилятора. Все структуры внутреннего предсавления, в том числе и синтаксическое дерево, будут существовать вплоть до момента CompilerState.Ready. Самый удобный момент захвата ссылки на синтаксическое дерево - это событие CompilerState.CompilationFinished, которое срабатывает сразу перед событием CompilerState.Ready.

Compiler.UnitTable - хеш таблица откомпилированных модулей. Каждый модуль из этой таблицы хранит свое синтаксическое и семантическое дерево. Обраться к синтаксическому дереву i-го модуля можно следующим образом: Compiler.UnitTable.Values[i].SyntaxTree. Далее все ссылки на синтаксические деревья запоминаются, и для просмотра любого дерева достаточно выбрать его из списка.

Для отображения дерева используется визитор по синтаксическому дереву. Приведем пример функций visit данного визитора:

public void visit(statement_list _statement_list)

{

prepare_node(_statement_list.left_logical_bracket, "left_logical_bracket");

prepare_collection(_statement_list.subnodes,"subnodes");

prepare_node(_statement_list.right_logical_bracket, "right_logical_bracket");

}

public void visit(assign _assign)

{

prepare_node(_assign.to,"to");

prepare_node(_assign.from,"from");

}

Функция prepare_node создает визуальный узел дерева и далее запускает для него тот же самый визитор.

13.3 Модуль «Управление компилятором»

Плагин «Управление компилятором» используется разработчиками для отладки компилятора. Данный модуль позволяет отключить различные блоки компилятора. Отключение различных частей компилятора происходит с помощью обращения к специальному полю Compiler.InternalDebug, которое имеет следующую структуру:

public class CompilerInternalDebug

{

public bool AddStandartUnits;

public bool CodeGeneration;

public bool PCUGenerate;

public bool SemanticAnalysis;

public bool SkipInternalErrorsIfSyntaxTreeIsCorrupt;

public bool SkipPCUErrors;

public bool DebugVersion { get; }

}

Изменение этих полей приводит к отключению соответствующих частей компилятора. Например, положив CodeGeneration=True, можно осуществить компиляцию без генерации кода.



Также данный модуль добавляет на панель визуальной оболочки кнопки:

· запустить ILDASM - запускает стандартный IL дизасемблер для последенего откомпилированного файла;

· запустить DBGCLR - запускает стандартный отладчик для последенего откомпилированного файла.

13.4 Модуль «Контроль внутренних ошибок»

Плагин «Контроль внутренних ошибок» перехватывает ошибки компилятора, принадлежащие к классу CompilerInternalError. Появление такой ошибки свидетельствует об ошибке в коде ядра компилятора. При возникновении такой ошибки плагин собирает все необходимые сведения: исходные коды модулей, которые участвовали в компиляции, PCU файлы, а также следующую информацию:

· время и дату;

· полную версию компилятора;

· версию платформы;

· версию ОС;

· количество процессоров;

· список состояний компилятора;

· полный текст ошибки.

Все эти данные сжимаются в zip-архив, и этот архив предлагается выслать разрабочикам компилятора.

Ошибка перхватывается при срабатывании события CompilerState.Ready путем анализа списка всех возникших во время компиляции ошибок, находящихся в Compiler.ErrorsList.

Скриншот произошедшей внутренней ошибки приведен ниже:



14. Подключение задачника Programming Taskbook

Электронный задачник Programming Taskbook предназначен для обучения программированию на языках Pascal, Visual Basic, C++, C#, Visual Basic .NET. Он содержит 1000 учебных заданий, охватывающих все основные разделы базового курса программирования: от скалярных типов и управляющих операторов до сложных структур данных и рекурсивных алгоритмов. Автор задачника - М. Э. Абрамян [11].

Задачник поставляется в виде неуправляемой динамической библиотеки (dll) со следующим интерфейсом:

procedure StartPT(options:integer);

external 'PT4PABC.dll' name 'startpt';

procedure FreePT;

external 'PT4PABC.dll' name 'freept';

function CheckPT(var res:integer):string;

external 'PT4PABC.dll' name 'checkptf';

procedure RaisePT(s1,s2:string);

external 'PT4PABC.dll' name 'raisept';

procedure Task(name:string);

external 'PT4PABC.dll' name 'task';

procedure GetR(var param:real);

external 'PT4PABC.dll' name 'getr';

procedure PutR(r:real);

external 'PT4PABC.dll' name 'putr';

procedure GetN(var param:integer);

external 'PT4PABC.dll' name 'getn';

procedure PutN(param:integer);

external 'PT4PABC.dll' name 'putn';

procedure GetC(var param:char);

external 'PT4PABC.dll' name 'getc';

procedure PutC(param:char);

external 'PT4PABC.dll' name 'putc';

procedure GetS(param:StringBuilder);

external 'PT4PABC.dll' name 'gets';

procedure PutS(param:string);

external 'PT4PABC.dll' name 'puts';

procedure GetB(var param:integer);

external 'PT4PABC.dll' name 'getb';

procedure PutB(param:integer);

external 'PT4PABC.dll' name 'putb';

procedure GetP(var param:IntPtr);

external 'PT4PABC.dll' name 'getp';

procedure PutP(var param:IntPtr);

external 'PT4PABC.dll' name 'putvarp';

procedure DisposeP(sNode:IntPtr);

external 'PT4PABC.dll' name 'disposep';

14.1 Модуль на языке PascalABC.NET

Подлючение задачника к системе программирования PascalABC.NET осуществляет модуль PT4.pas, который написан на языке PascalABC.NET. Данный модуль делает все необходимые обертки над вызовами процедур из dll, а также инициализирует и завершает работу задачника. Интерфейс этого модуля приведен далее:

type

InternalNode = record

Data:integer;

Next:IntPtr;

Prev:IntPtr;

end;

PT4Node = class

public

property Next:PT4Node

property Prev:PT4Node

property Data:integer

constructor;

constructor(aData:integer);

constructor(aData:integer; aNext:PT4Node);

destructor Destroy;

end;

TNode = PT4Node;

procedure Task(name:string);

procedure Write(params args:array of object);

function GetInteger:integer;

function GetReal:real;

function GetChar:char;

function GetString:string;

function GetBoolean:boolean;

function GetNode:PT4Node;

procedure PutInteger(val:integer);

procedure PutReal(val:real);

procedure PutChar(val:char);

procedure PutString(val:string);

procedure PutBoolean(val:boolean);

procedure PutNode(val:PT4Node);

procedure Read(var val:integer);

procedure Read(var val:real);

procedure Read(var val:char);

procedure Read(var val:string);

procedure Read(var val:boolean);

procedure Read(var val:PT4Node);

Пример прогаммы, реализующей решение задачи Text1 на PascalABC.NET, имеет вид:

uses PT4;

var f:text;

filename:string;

n,k,i,j:integer;

begin

Task('Text1');

read(filename);read(n);read(k);

AssignFile(f,filename);

Rewrite(f);

for i:=1 to n do begin

for j:=1 to k do

write(f,'*');

writeln(f);

end;

CloseFile(f);

end.

Пример прогаммы реализующей решение задачи Dynamic2, имеет вид:

uses PT4;

var tek,prev:TNode;

n:integer;

begin

Task('Dynamic2');

read(tek);

while tek<>nil do begin

n:=n+1;

write(tek.Data);

prev:=tek;

tek:=tek.Next;

end;

write(n,prev);

end.

Ниже приводится скриншот выполненного задания:

14.2 Модуль визуальной оболочки

Модуль визуальной оболочки используется для добавления в оболочку трех кнопок:

· посмотреть задания;

· создать шаблон программы;

· посмотреть результаты.



Плагин использует следующие функции из dll задачника:

[DllImport("PT4\\PT4PABC.dll", CharSet = CharSet.Ansi, EntryPoint = "pt4demo")]

static extern int pt4demo(string startdir,

string ptdir, string dllname,

int dlloptions, int usedlltopics, int usedemodat,

string demodatname, string demodatdir,

StringBuilder topic, ref int number);

[DllImport("PT4\\PT4PABC.dll", CharSet = CharSet.Ansi, EntryPoint = "pt4load")]

static extern int pt4load(string startdir,

string ptdir, string envlist, string dirlist,

int startenv, StringBuilder edittext, StringBuilder filename);

[DllImport("PT4\\PT4PABC.dll", CharSet = CharSet.Ansi, EntryPoint = "pt4results")]

static extern int pt4results(string startdir,

string ptdir, int showbrowsedir, int browsesubdirs,

ref int fontsize, ref int showinffile, ref int showtxtfile);

[DllImport("PT4\\PT4PABC.dll", CharSet = CharSet.Ansi, EntryPoint = "pt4getdatinfo")]

static extern int pt4getdatinfo(string startdir,

StringBuilder studentname, ref int fontsize,

StringBuilder envir, StringBuilder ptdir);

[DllImport("PT4\\PT4PABC.dll", CharSet = CharSet.Ansi, EntryPoint = "pt4setdatinfo")]

public static extern int pt4setdatinfo(string startdir,

int fontsize, string envir);

Примеры вызова этих функций были предоставлены автором задачника вместе с самим задачником. Над этими функциями сделаны следующие обертки:

public int Demo(StringBuilder topic, ref int number)

{

return pt4demo(PABCWorkDirectory, PT4Directory, "pt4", 0, 1, 2, "", "", topic, ref number);

}

public int Load(StringBuilder edittext, StringBuilder filename)

{

return pt4load(PABCWorkDirectory, PT4Directory, "PABC2", "", 1, edittext, filename);

}

public void Results()

{

StringBuilder

s1 = new StringBuilder(50),

s2 = new StringBuilder(20),

s3 = new StringBuilder(100);

int fsize = 0, fontsize = 0,

showinf = 1, showtxt = 1,

i = pt4getdatinfo("", s1, ref fsize, s2, s3);

if (i == 0)

fontsize = fsize;

pt4results(PABCWorkDirectory, PT4Directory, 0, 0, ref fontsize,

ref showinf, ref showtxt);

if (i == 0 && fsize != fontsize)

pt4setdatinfo("", fontsize, "");

}

Функции, реализующие собственно эти три действия, выглядят так:

1. Посмотреть задания:

public void ExecuteB_D()

{

Demo(topic, ref number);

}

2. Создать шаблон программы:

public void ExecuteB_L()

{

StringBuilder filename = new StringBuilder(250);

int i = Load(edittext, filename);

if (i < 1 || filename.ToString() == "")

return;

VisualEnvironmentCompiler.ExecuteAction(

VisualEnvironmentCompilerAction.OpenFile,

filename.ToString());

}

3. Посмотреть результаты:

public void ExecuteB_R()

{

Results();

}

Заключение

Работа над проектом PascalABC.NET началась в сентябре 2005 года. Одной из наиболее сложных задач было распараллеливание проекта на относительно независимые части, для того чтобы разработчики могли работать над проектом независимо. Проект был разделен на следующие независимые части:

· синтаксическое дерево;

· синтаксический анализатор;

· семантическое дерево;

· конвертор синтаксического дерева в семантическое дерево;

· генератор кода.

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

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

· грамматика языка PascalABC.NET;

· синтаксическое дерево и синтаксический анализатор;

· таблица символов и таблица пространств имен, алгоритмы поиска имен в таблице символов;

· управляющий блок;

· алгоритм компиляции модулей, учитывающий наличие промежуточного представления PCU;

· реализация типизированных файлов;

· концепция реализации изменяемых строк;

· система локализации.

Итогом совместной работы ниже перечисленных студентов (5 человек) над проектом является система программирования PascalABC.NET, включающая язык PascalABC.NET и компилятор с этого языка и предназначенная для начального обучения современному программированию.

В проекте участвовали следующие разработчики:

Бондарев Иван, магистр 2 года мехмата РГУ. Генератор IL кода, PCU файлы. Работал над проектом до весны 2006 года.

Водолазов Николай, магистр 2 года мехмата ЮФУ. Семантическое дерево и семантический анализ, генерация кода.

Иванов Сергей, магистр 1 года мехмата ЮФУ. Работает в проекте, начиная с февраля 2007 года. Занимается введением в язык управляемых и неуправляемых шаблонов. С апреля 2007: семантическое дерево и семантический анализ, генерация кода.

Ткачук Александр, 5 курс мехмата ЮФУ. Синтаксическое дерево и синтаксический анализатор. Таблица символов. Управляющий блок. Плагины. С апреля 2007: Семантическое дерево и семантический анализ, генерация кода.

Харитонова Любовь, 4 курс мехмата ЮФУ. Занимается разработкой визуальной оболочки для компилятора. Работает в проекте с сентября 2006 года.

Исходный код проекта состоит из 220 файлов (4,6 мегабайт, 145000 строк).

По результатам работы опубликовано 4 статьи и в 2006-2007 гг. проведено 2 семинара: для преподавателей и для студентов, а также сделан доклад на семинаре Штейнберга Б.Я. Кроме того, в 2007 году Михалковичем С.С. и Ткачуком А.В. был создан сайт проекта [12].

Литература

1. Ахо А., Сети Р., Ульман Дж. Компиляторы: принципы, технологии и инструменты.: Пер. с англ. - М.: Издательский дом «Вильямс», 2001, 768 с.

2. Водолазов Н.Н., Михалкович С.С., Ткачук А.В. Архитектура компилятора PascalABC.NET. Труды IV Всероссийской научно-технической конференции «Технологии Microsoft в теории и практике программирования». 2007 г., с 181-182.

3. Бондарев И.В., Водолазов Н.Н., Михалкович С.С., Ткачук А.В. Некоторые вопросы реализации компилятора языка программирования PascalABC.NET. Всероссийская школа-семинар «Математическое моделирование, биомеханика и информационные технологии в современном университете». 2006. Тезисы докладов. с.10-11.

4. Водолазов Н.Н., Михалкович С.С., Ткачук А.В. Преимущества использования компилятора PascalABC.NET в учебном процессе. Всероссийская школа-семинар "Математическое моделирование, биомеханика и информационные технологии в современном университете". 2007. Тезисы докладов.

5. Водолазов Н.Н., Михалкович С.С., Ткачук А.В. Опыт разработки учебного языка программирования для платформы .NET. «Современные информационные технологии в образовании: Южный Федеральный округ» Научно-методическая конференция 2007. Тезисы докладов.

6. Э.Гамма, Р. Хелм, Р. Джонсон, Дж. Влиссидес. Приемы объектно-ориентированного проектирования (паттерны проектирования). Питер, 2001, 368 с.

7. http://www.devincook.com/goldparser/doc/index.htm. Documentation for the GOLD Parser Builder.

8. Ткачук А.В. Доклад «Реализация таблицы символов компилятора», науч. рук. Михалкович С.С.

http://pascalabc.net/downloads/doklad_nametable_konf2004.rar.

9. Роберт Седжвик. Фундаментальные алгоритмы на С++. Части 1-4. М., Диасофт, 2002. 496 с.

10. Common Language Infrastructure Standards. http://msdn2.microsoft.com/en-us/netframework/aa569283.aspx

11. Абрамян М.Э. Электронный задачник Programming Taskbook: опыт разработки и применения. II Международная научно-практическая конференция «Современные информационные технологии и ИТ-образование». Сборник трудов. Москва, 2006 г., с.194-199.

12. Сайт проекта PаscalABC.NET - http://pascalabc.net

pascalabc компилятор модуль семантический

ПРИЛОЖЕНИЕ 1. Грамматика языка PascalABC.NET

"Start Symbol" = <parse_goal>

{Ident Letter} = {Letter} + [_]

{All ASCII} = {#1..#256}+{Cyrillic}+{#8100..#8800}

{TextPart} = {All ASCII} - {Control Codes}

{String Char} = {TextPart} - ['']

{CommentPartSlashes} = {All ASCII} - {LF}

{CommentPart1} = {All ASCII} - [}]

{CommentPart2} = {All ASCII}

{Hex Digit} = {Number} + [abcdefABCDEF]

Whitespace = ({Whitespace}+ | (('//' {CommentPartSlashes}* {LF}) | ('{' {CommentPart1}* '}' )))

tkFloat = ({Number}+'.'{Number}+) | (({Number}+'.')? {Number}+ [eE] [+-]? {Number}+)

tkIdentifier = ('&')? {Ident Letter} ({Ident Letter}|{Number})*

tkInteger = {Number}+

tkHex = '$'{Hex Digit}+

tkAsciiChar = '#'{Number}+

tkStringLiteral = ''({String Char}|'''')*''

tkDirectiveName = '#'{Ident Letter} ({Ident Letter}|{Number})*

tkAddressOf = '@'

tkComma = ','

tkColon = ':'

tkDeref = '^'

tkDotDot = '..'

tkPoint = '.'

tkRoundOpen = '('

tkRoundClose = ')'

tkSemiColon = ';'

tkSquareOpen = '['

tkSquareClose = ']'

tkAssign = ':='

tkPlusEqual = '+='

tkMinusEqual = '-='

tkMultEqual = '*='

tkDivEqual = '/='

tkMinus = '-'

tkPlus = '+'

tkSlash = '/'

tkStar = '*'

tkEqual = '='

tkGreater = '>'

tkGreaterEqual = '>='

tkLower = '<'

tkLowerEqual = '<='

tkNotEqual = '<>'

! Reserved !

tkOr = 'or'

tkXor = 'xor'

tkAnd = 'and'

tkDiv = 'div'

tkMod = 'mod'

tkShl = 'shl'

tkShr = 'shr'

tkNot = 'not'

tkAs = 'as'

tkIn = 'in'

tkIs = 'is'

tkSizeOf = 'sizeof'

tkTypeOf = 'typeof'

tkWhere = 'where'

tkArray = 'array'

tkBegin = 'begin'

tkCase = 'case'

tkClass = 'class'

tkConst = 'const'

tkConstructor = 'constructor'

tkDestructor = 'destructor'

tkDownto = 'downto'

tkDo = 'do'

tkElse = 'else'

tkEnd = 'end'

tkExcept = 'except'

tkFile = 'file'

tkFinalization = 'finalization'

tkFinally = 'finally'

tkFor = 'for'

tkForeach = 'foreach'

tkFunction = 'function'

tkIf = 'if'

tkImplementation = 'implementation'

tkInherited = 'inherited'

tkInitialization = 'initialization'

tkInterface = 'interface'

tkProcedure = 'procedure'

tkOperator = 'operator'

tkProperty = 'property'

tkRaise = 'raise'

tkRecord = 'record'

tkRepeat = 'repeat'

tkSet = 'set'

tkTry = 'try'

tkType = 'type'

tkThen = 'then'

tkTo = 'to'

tkUntil = 'until'

tkUses = 'uses'

tkUsing = 'using'

tkVar = 'var'

tkWhile = 'while'

tkWith = 'with'

tkNil = 'nil'

tkGoto = 'goto'

tkOf = 'of'

tkLabel = 'label'

tkDispinterface = 'dispinterface'

tkProgram = 'program'

tkPacked = 'packed'

tkInline = 'inline'

tkExports = 'exports'

tkResourceString = 'resourcestring'

tkThreadvar = 'threadvar'

! Non Reserved !

tkAt = 'at'

tkOn = 'on'

tkBF = 'bf'

tkContains = 'contains'

tkLibrary = 'library'

tkOut = 'out'

tkPackage = 'package'

tkRequires = 'requires'

tkUnit = 'unit'

tkShortInt = 'shortint'

tkSmallInt = 'smallint'

tkOrdInteger = 'integer'

tkByte = 'byte'

tkLongInt = 'longint'

tkInt64 = 'int64'

tkWord = 'word'

tkBoolean = 'boolean'

tkChar = 'char'

tkWideChar = 'widechar'

tkLongWord = 'longword'

tkPChar = 'pchar'

tkCardinal = 'cardinal'

tkReal = 'real'

tkSingle = 'single'

tkDouble = 'double'

tkExtended = 'extended'

tkCurrency = 'currency'

tkComp = 'comp'

tkVariant = 'variant'

tkOleVariant = 'olevariant'

tkParams = 'params'

tkObject = 'object'

tkStatic = 'static'

tkAbstract = 'abstract'

tkForward = 'forward'

tkOverload = 'overload'

tkOverride = 'override'

tkVirtual = 'virtual'

tkAbsolute = 'absolute'

tkAssembler = 'assembler'

tkAutomated = 'automated'

tkDefault = 'default'

tkExternal = 'external'

tkIndex = 'index'

tkName = 'name'

tkPrivate = 'private'

tkProtected = 'protected'

tkPublic = 'public'

tkInternal = 'internal'

tkRead = 'read'

tkReintroduce = 'reintroduce'

tkResident = 'resident'

tkStored = 'stored'

tkWrite = 'write'

tkReadOnly = 'readonly'

tkWriteOnly = 'writeonly'

! ======================================= Rules

<parse_goal>

::= <program_file>

| <unit_file>

<opt_head_compiler_directives>

::=

| <head_compiler_directives>

<head_compiler_directives>

::= <one_compiler_directive>

| <head_compiler_directives> <one_compiler_directive>

<one_compiler_directive>

::= tkDirectiveName tkIdentifier

| tkDirectiveName tkStringLiteral

<program_file>

::= <program_heading> <opt_head_compiler_directives> <main_uses_clause> <using_clause> <program_block> tkPoint

<program_heading>

::=

| tkProgram <program_name> <program_heading_2>

<program_heading_2>

::= tkSemiColon

| tkRoundOpen <program_param_list> tkRoundClose tkSemiColon

<program_name>

::= tkIdentifier

<program_param_list>

::= <program_param>

| <program_param_list> tkComma <program_param>

<program_param>

::= tkIdentifier

<program_block>

::= <program_decl_sect_list> <compound_stmt>

<program_decl_sect_list>

::= <impl_decl_sect_list>

<uses_clause>

::= <main_uses_clause>

<using_clause>

::=

| <using_list>

<using_list>

::= <using_one>

| <using_list> <using_one>

<using_one>

::=tkUsing <ident_or_keyword_pointseparator_list> tkSemiColon

<ident_or_keyword_pointseparator_list>

::= <identifier_or_keyword>

| <ident_or_keyword_pointseparator_list> tkPoint <identifier_or_keyword>

<main_uses_clause>

::=

| tkUses <main_used_units_list> tkSemiColon

<main_used_units_list>

::= <main_used_units_list> tkComma <main_used_unit_name>

| <main_used_unit_name>

<main_used_unit_name>

::= <ident_or_keyword_pointseparator_list>

| <ident_or_keyword_pointseparator_list> tkIn tkStringLiteral

<library_file>

::= <library_heading> <main_uses_clause> <library_block> tkPoint

<library_heading>

::= tkLibrary tkIdentifier tkSemiColon

<library_block>

::= <library_impl_decl_sect_list> <compound_stmt>

<library_impl_decl_sect_list>

::=

| <library_impl_decl_sect_list> <library_impl_decl_sect>

<library_impl_decl_sect>

::= <label_decl_sect>

| <const_decl_sect>

| <res_str_decl_sect>

| <type_decl_sect>

| <var_decl_sect>

| <proc_decl>

| <func_decl>

| <constructor_decl>

| <destructor_decl>

| <export_clause>

<export_clause>

::= tkExports <exports_list> tkSemiColon

<exports_list>

::= <exports_entry>

| <exports_list> tkComma <exports_entry>

<exports_entry>

::= <identifier> <exports_index> <exports_name> <exports_resident>

<exports_index>

::=

| tkIndex <integer_const>

<exports_name>

::=

| tkName <identifier>

| tkName <literal>

<exports_resident>

::=

| tkResident

<unit_file>

::= <unit_heading> <interface_part> <implementation_part> <initialization_part> tkPoint

| <unit_heading> <abc_interface_part> <initialization_part> tkPoint

<unit_heading>

::= tkUnit <unit_name> tkSemiColon <opt_head_compiler_directives>

<unit_name>

::= tkIdentifier

<interface_part>

::= tkInterface <uses_clause> <using_clause> <int_decl_sect_list>

<implementation_part>

::= tkImplementation <uses_clause> <using_clause> <impl_decl_sect_list>

<abc_interface_part>

::=<uses_clause> <using_clause> <impl_decl_sect_list>

<initialization_part>

::= tkEnd

| tkInitialization <stmt_list> tkEnd

| tkInitialization <stmt_list> tkFinalization <stmt_list> tkEnd

| tkBegin <stmt_list> tkEnd

<package_file>

::= tkPackage <package_name> tkSemiColon <requires_clause> <contains_clause> tkEnd tkPoint

<package_name>

::= <identifier>

<requires_clause>

::=

| tkRequires

| tkRequires <main_used_units_list> tkSemiColon

<contains_clause>

::=

| tkContains

| tkContains <main_used_units_list> tkSemiColon

<int_decl_sect_list>

::= <int_decl_sect_list1>

<int_decl_sect_list1>

::=

| <int_decl_sect_list1> <int_decl_sect>

<impl_decl_sect_list>

::=<impl_decl_sect_list1>

<impl_decl_sect_list1>

::=

| <impl_decl_sect_list1> <impl_decl_sect>

<abc_decl_sect_list>

::=<abc_decl_sect_list1>

<abc_decl_sect_list1>

::=

| <abc_decl_sect_list1> <abc_decl_sect>

<int_decl_sect>

::= <const_decl_sect>

| <res_str_decl_sect>

| <type_decl_sect>

| <var_decl_sect>

| <int_proc_heading>

| <int_func_heading>

<impl_decl_sect>

::= <label_decl_sect>

| <const_decl_sect>

| <res_str_decl_sect>

| <type_decl_sect>

| <var_decl_sect>

| <proc_decl>

| <func_decl>

| <constructor_decl>

| <destructor_decl>

<abc_decl_sect>

::= <label_decl_sect>

| <const_decl_sect>

| <res_str_decl_sect>

| <type_decl_sect>

| <var_decl_sect>

<int_proc_heading>

::= <proc_heading>

| <proc_heading> tkForward tkSemiColon

<int_func_heading>

::= <func_heading>

| <func_heading> tkForward tkSemiColon

<label_decl_sect>

::= tkLabel <label_list> tkSemiColon

<label_list>

::= <label_name>

| <label_list> tkComma <label_name>

<label_name>

::= tkInteger

| tkFloat

| <identifier>

<const_decl_sect>

::= tkConst <const_decl>

| <const_decl_sect> <const_decl>

<res_str_decl_sect>

::= tkResourceString <const_decl>

| <res_str_decl_sect> <const_decl>

<type_decl_sect>

::= tkType <type_decl>

| <type_decl_sect> <type_decl>

<var_decl_sect>

::= tkVar <var_decl>

| tkThreadvar <var_decl>

| <var_decl_sect> <var_decl>

<const_decl>

::= <only_const_decl> tkSemiColon

<only_const_decl>

::= <const_name> tkEqual <const_expr>

| <const_name> tkColon <type_ref> tkEqual <typed_const>

<const_name>

::= <identifier>

<const_expr>

::= <const_simple_expr>

| <const_simple_expr> <const_relop> <const_simple_expr>

<const_relop>

::= tkEqual

| tkNotEqual

| tkLower

| tkGreater

| tkLowerEqual

| tkGreaterEqual

| tkIn

<const_simple_expr>

::= <const_term>

| <const_simple_expr> <const_addop> <const_term>

<const_addop>

::= tkPlus

| tkMinus

| tkOr

| tkXor

<const_term>

::= <const_factor>

| <const_term> <const_mulop> <const_factor>

<const_mulop>

::= tkStar

| tkSlash

| tkDiv

| tkMod

| tkShl

| tkShr

| tkAnd

<const_factor>

::= <const_variable>

| <const_set>

| <unsigned_number>

| <literal>

| tkNil

| tkAddressOf <const_factor>

| tkRoundOpen <const_expr> tkRoundClose

| tkNot <const_factor>

| <sign> <const_factor>

| tkDeref <const_factor>

<const_set>

::= tkSquareOpen <const_elem_list> tkSquareClose

<sign>

::= tkPlus

| tkMinus

<const_variable>

::= <identifier>

| <const_variable> <const_variable_2>

<const_variable_2>

::= tkPoint <identifier_or_keyword>

| tkDeref

| tkRoundOpen <const_func_expr_list> tkRoundClose

<const_func_expr_list>

::= <const_expr>

| <const_func_expr_list> tkComma <const_expr>

<const_elem_list>

::= <const_elem_list1>

|

<const_elem_list1>

::= <const_elem>

| <const_elem_list1> tkComma <const_elem>

<const_elem>

::= <const_expr>

| <const_expr> tkDotDot <const_expr>

<unsigned_number>

::= tkInteger

| tkHex

| tkFloat

<typed_const>

::= <const_expr>

| <array_const>

| <record_const>

<array_const>

::= tkRoundOpen <typed_const_list> tkRoundClose

| tkRoundOpen <record_const> tkRoundClose

| tkRoundOpen <array_const> tkRoundClose

<typed_const_list>

::=

| <typed_const> tkComma <typed_const>

| <typed_const_list> tkComma <typed_const>

<record_const>

::= tkRoundOpen <const_field_list> tkRoundClose

<const_field_list>

::= <const_field_list_1>

| <const_field_list_1> tkSemiColon

<const_field_list_1>

::= <const_field>

| <const_field_list_1> tkSemiColon <const_field>

<const_field>

::= <const_field_name> tkColon <typed_const>

<const_field_name>

::= <identifier>

<type_decl>

::= <identifier> tkEqual <type_decl_type> tkSemiColon

<type_decl_type>

::= <type_ref>

| tkType <type_ref>

| <object_type>

<type_ref>

::= <simple_type>

| <string_type>

| <pointer_type>

| <structured_type>

| <procedural_type>

| <template_type>

<template_type>

::= <simple_type_identifier> <template_type_params>

<template_type_params>

::= tkLower <template_param_list> tkGreater

<template_param_list>

::= <template_param>

| <template_param_list> tkComma <template_param>

<template_param>

::= <simple_type_identifier>

| <template_type>

<simple_type>

::= <simple_type_identifier>

| <range_expr> tkDotDot <range_expr>

| tkRoundOpen <enumeration_id_list> tkRoundClose

<range_expr>

::= <range_term>

| <range_expr> <const_addop> <range_term>

<range_term>

::= <range_factor>

| <range_term> <const_mulop> <range_factor>

<range_factor>

::= <simple_type_identifier>

| <unsigned_number>

| <sign> <range_factor>

| <literal>

| <range_factor> tkRoundOpen <const_elem_list> tkRoundClose

| tkRoundOpen <const_expr> tkRoundClose

<range_methodname>

::= <identifier>

| <identifier> tkPoint <identifier_or_keyword>

<simple_type_identifier>

::= <identifier>

| <simple_type_identifier> tkPoint <identifier_or_keyword>

<enumeration_id_list>

::= <enumeration_id> tkComma <enumeration_id>

| <enumeration_id_list> tkComma <enumeration_id>

<enumeration_id>

::= <identifier>

<pointer_type>

::= tkDeref <fptype>

<structured_type>

::= <unpacked_structured_type>

| tkPacked <unpacked_structured_type>

<unpacked_structured_type>

::= <array_type>

| <new_record_type>

| <set_type>

| <file_type>

<array_type>

::= tkArray tkSquareOpen <simple_type_list> tkSquareClose tkOf <type_ref>

| tkArray tkOf <type_ref>

<simple_type_list>

::= <simple_type>

| <simple_type_list> tkComma <simple_type>

<record_type>

::= tkRecord <field_list> tkEnd

| tkRecord tkEnd

<field_list>

::= <fixed_part>

| <variant_part>

| <fixed_part_2> tkSemiColon <variant_part>

<fixed_part>

::= <fixed_part_2>

| <fixed_part_2> tkSemiColon

<fixed_part_2>

::= <record_section>

| <fixed_part_2> tkSemiColon <record_section>

<record_section>

::= <record_section_id_list> tkColon <type_ref>

<record_section_id_list>

::= <record_section_id>

| <record_section_id_list> tkComma <record_section_id>

<record_section_id>

::= <identifier>

<variant_part>

::= tkCase <tag_field> tkOf <variant_list>

<tag_field>

::= <tag_field_name>

| <tag_field_name> tkColon <tag_field_typename>

<tag_field_name>

::= <identifier>

<tag_field_typename>

::= <fptype>

<variant_list>

::= <variant_list_2>

| <variant_list_2> tkSemiColon

<variant_list_2>

::= <variant>

| <variant_list_2> tkSemiColon <variant>

<variant>

::= <case_tag_list> tkColon tkRoundOpen <variant_field_list> tkRoundClose

<variant_field_list>

::=

| <field_list>

<case_tag_list>

::= <const_expr_list>

<const_expr_list>

::= <const_expr>

| <const_expr_list> tkComma <const_expr>

<set_type>

::= tkSet tkOf <simple_type>

<file_type>

::= tkFile tkOf <type_ref>

| tkFile

<string_type>

::= tkIdentifier tkSquareOpen <const_expr> tkSquareClose

<procedural_type>

::= <procedural_type_kind>

<procedural_type_kind>

::= <procedural_type_decl>

| <procedural_type_decl> tkOf <identifier>

<procedural_type_decl>

::= tkProcedure <fp_list> <maybe_error>

| tkFunction <fp_list> tkColon <fptype>

<maybe_error>

::= tkColon <fptype>

|

<object_type>

::= <new_object_type>

<oot_privat_list>

::=

| tkPrivate <oot_component_list>

<oot_component_list>

::=

| <oot_field_list>

| <oot_field_list> <oot_method_list>

| <oot_method_list>

<oot_successor>

::= tkRoundOpen <oot_typeidentifier> tkRoundClose

<oot_typeidentifier>

::= <identifier>

<oot_field_list>

::= <oot_field>

| <oot_field_list> <oot_field>

<oot_field>

::= <oot_id_list> tkColon <type_ref> tkSemiColon

<oot_id_list>

::= <oot_field_identifier>

| <oot_id_list> tkComma <oot_field_identifier>

<oot_field_identifier>

::= <identifier>

<oot_method_list>

::= <oot_method>

| <oot_method_list> <oot_method>

<oot_method>

::= <oot_method_head>

<oot_method_head>

::= <proc_heading>

| <func_heading>

| <oot_constructor_head>

| <oot_destructor_head>

<oot_constructor_head>

::= tkConstructor <proc_name> <fp_list> <opt_meth_modificators>

<oot_destructor_head>

::= tkDestructor <proc_name> <fp_list> <opt_meth_modificators>

<new_object_type>

::= <not_class_reference_type>

| <not_object_type>

<not_class_reference_type>

::= tkClass tkOf <not_object_type_identifier>

<not_object_type_identifier>

::= <identifier>

<not_object_type>

::= <class_or_interface_keyword> <opt_template_arguments> <opt_base_classes> <opt_where_section> <opt_not_component_list_seq_end>

<new_record_type>

::= tkRecord <opt_base_classes> <record_component_list> tkEnd

<class_or_interface_keyword>

::= tkClass

| tkInterface

<opt_not_component_list_seq_end>

::=

| <not_component_list_seq> tkEnd

<opt_base_classes>

::=

| tkRoundOpen <base_classes_names_list> tkRoundClose

<base_classes_names_list>

::= <base_class_name>

| <base_classes_names_list> tkComma <base_class_name>

<base_class_name>

::= <simple_type_identifier>

| <template_type>

<opt_template_arguments>

::=

| tkLower <ident_list> tkGreater

<opt_where_section>

::=

| tkWhere <where_part_list>

<where_part_list>

::= <where_part>

| <where_part_list> <where_part>

<where_part>

::= <ident_list> tkColon <type_ref_list> <opt_constructor_secific> tkSemiColon

<type_ref_list>

::= <type_ref>

| <type_ref_list> tkComma <type_ref>

<opt_constructor_secific>

::=

| tkComma tkConstructor <opt_constructor_specific_params>

<opt_constructor_specific_params>

::=

| tkRoundOpen <opt_type_ref_list> tkRoundClose

<opt_type_ref_list>

::=

| <type_ref_list>

<record_component_list>

::= <not_component_list>

<not_component_list_seq>

::= <not_component_list>

| <not_component_list_seq> <ot_visibility_specifier> <not_component_list>

<ot_visibility_specifier>

::= tkInternal

| tkPublic

| tkProtected

| tkPrivate

<not_object_type_identifier_list>

::= <simple_type_identifier>

| <not_object_type_identifier_list> tkComma <simple_type_identifier>

<ident_list>

::= <identifier>

| <ident_list> tkComma <identifier>

<not_component_list>

::= <not_guid>

| <not_guid> <not_component_list_1> <opt_semicolon>

| <not_guid> <not_component_list_2>

| <not_guid> <not_component_list_1> tkSemiColon <not_component_list_2>

<opt_semicolon>

::=

| tkSemiColon

<not_guid>

::=

<not_component_list_1>

::= <filed_or_const_definition>

| <not_component_list_1> tkSemiColon <filed_or_const_definition>

<not_component_list_2>

::= <not_method_definition>

| <not_property_definition>

| <not_component_list_2> <not_method_definition>

| <not_component_list_2> <not_property_definition>

<filed_or_const_definition>

::= tkConst <only_const_decl>

| <not_field_definition>

<not_field_definition>

::= <not_field_identifier_list> tkColon <type_ref>

<not_field_identifier_list>

::= <not_field_identifier>

| <not_field_identifier_list> tkComma <not_field_identifier>

<not_field_identifier>

::= <identifier>

<not_method_definition>

::= <not_method_heading>

| <abc_method_decl>

<abc_method_decl>

::= <abc_proc_decl>

| <abc_func_decl>

| <abc_constructor_decl>

| <abc_destructor_decl>

<not_method_heading>

::= tkClass <proc_heading>

| tkClass <func_heading>

| <func_heading>

| <proc_heading>

| <not_constructor_heading>

| <not_destructor_heading>

<optional_qualified_identifier>

::= <qualified_identifier>

|

<not_constructor_heading>

::= tkConstructor <optional_qualified_identifier> <fp_list> <opt_meth_modificators>

<not_destructor_heading>

::= tkDestructor <optional_qualified_identifier> <fp_list> <opt_meth_modificators>

<qualified_identifier>

::= <identifier>

| <visibility_specifier>

| <qualified_identifier> tkPoint <identifier>

| <qualified_identifier> tkPoint <visibility_specifier>

<not_property_definition>

::= tkProperty <qualified_identifier> <not_property_interface> <not_property_specifiers> tkSemiColon <not_array_defaultproperty>

<not_array_defaultproperty>

::=

| tkDefault tkSemiColon

<not_property_interface>

::=

| <not_property_parameter_list> tkColon <fptype> <not_property_interface_index>

<not_property_interface_index>

::=

| tkIndex <expr>

<not_property_parameter_list>

::=

| tkSquareOpen <not_parameter_decl_list> tkSquareClose

<not_parameter_decl_list>

::= <not_parameter_decl>

| <not_parameter_decl_list> tkSemiColon <not_parameter_decl>

<not_parameter_decl>

::= <not_parameter_name_list> tkColon <fptype>

| tkConst <not_parameter_name_list> tkColon <fptype>

| tkVar <not_parameter_name_list> tkColon <fptype>

| tkOut <not_parameter_name_list> tkColon <fptype>

<not_parameter_name_list>

::= <ident_list>

<not_property_specifiers>

::=

| tkReadOnly <not_property_specifiers>

| tkWriteOnly <not_property_specifiers>

| tkDispid <const_expr> <not_property_specifiers>

| tkDefault <const_expr> <not_property_specifiers>

| tkNodefault <not_property_specifiers>

| tkStored <const_expr> <not_property_specifiers>

| tkRead <identifier> <not_property_specifiers>

| tkWrite <identifier> <not_property_specifiers>

<var_decl>

::= <var_decl_part> tkSemiColon

<var_decl_part>

::= <var_decl_part_normal>

| <var_name_list> tkColon <type_ref> tkEqual <var_init_value>

| <var_name_list> tkEqual <var_init_value>

<var_decl_part_normal>

::= <var_name_list> tkColon <type_ref>

<var_init_value>

::= <typed_const>

<var_name_list>

::= <var_name>

| <var_name_list> tkComma <var_name>

<var_name>

::= <identifier>

<declared_var_name>

::= <identifier>

<constructor_decl>

::= <not_constructor_heading> <not_constructor_block_decl>

<abc_constructor_decl>

::= <not_constructor_heading> <abc_block>

<destructor_decl>

::= <not_destructor_heading> <not_constructor_block_decl>

<abc_destructor_decl>

::= <not_destructor_heading> <abc_block>

<not_constructor_block_decl>

::= <block>

| <external_directr>

| <asm_block>

<proc_decl>

::= <proc_decl_noclass>

| tkClass <proc_decl_noclass>

<proc_decl_noclass>

::= <proc_heading> <proc_block>

<abc_proc_decl>

::= <abc_proc_decl_noclass>

| tkClass <abc_proc_decl_noclass>

<abc_proc_decl_noclass>

::= <proc_heading> <abc_proc_block>

<func_decl>

::= <func_decl_noclass>

| tkClass <func_decl_noclass>

<func_decl_noclass>

::= <func_heading> <func_block>

<abc_func_decl>

::= <abc_func_decl_noclass>

| tkClass <abc_func_decl_noclass>

<abc_func_decl_noclass>

::= <func_heading> <abc_proc_block>

<proc_heading>

::= tkProcedure <proc_name> <fp_list> <maybe_error> <opt_meth_modificators>

| tkProcedure <proc_name> tkEqual <qualified_identifier> tkSemiColon

<proc_name>

::= <func_name>

<func_name>

::= <func_meth_name_ident>

| <func_class_name_ident> tkPoint <func_meth_name_ident>

<func_meth_name_ident>

::= <identifier>

| <visibility_specifier>

| <operator_name_ident>

<func_class_name_ident>

::= <identifier>

| <visibility_specifier>

<func_heading>

::= tkFunction <func_name> <fp_list> tkColon <fptype> <opt_meth_modificators>

| tkFunction <func_name> <opt_meth_modificators>

| tkFunction <func_name> tkEqual <qualified_identifier> tkSemiColon

<proc_block>

::= <proc_block_decl>

<func_block>

::= <proc_block_decl>

<proc_block_decl>

::= <block>

| <external_directr>

| <asm_block>

| tkForward tkSemiColon

<abc_proc_block>

::= <abc_block>

| <external_directr>

<external_directr>

::= <abc_external_directr>

| <abc_external_directr> tkSemiColon

<external_directr_ident>

::= <identifier>

| <literal>

<abc_external_directr>

::= tkExternal <external_directr_ident> tkName <external_directr_ident>

<asm_block>

::= <impl_decl_sect_list> tkAsmBody tkSemiColon

<block>

::= <impl_decl_sect_list> <compound_stmt> tkSemiColon

<abc_block>

::= <abc_decl_sect_list> <compound_stmt> tkSemiColon

<fp_list>

::=

| tkRoundOpen <fp_sect_list> tkRoundClose

<fp_sect_list>

::=

| <fp_sect>

| <fp_sect_list> tkSemiColon <fp_sect>

<fp_sect>

::= <param_name_list> tkColon <fptype_new>

| <param_name_list>

| tkVar <param_name_list> tkColon <fptype_new>

| tkVar <param_name_list>

| tkOut <param_name_list> tkColon <fptype_new>

| tkOut <param_name_list>

| tkConst <param_name_list> tkColon <fptype_new>

| tkConst <param_name_list>

| tkParams <param_name_list> tkColon <fptype_new>

| tkParams <param_name_list>

| <param_name_list> tkColon <fptype> tkEqual <const_expr>

| tkVar <param_name_list> tkColon <fptype> tkEqual <const_expr>

| tkOut <param_name_list> tkColon <fptype> tkEqual <const_expr>

| tkConst <param_name_list> tkColon <fptype> tkEqual <const_expr>

<param_name_list>

::= <param_name>

| <param_name_list> tkComma <param_name>

<param_name>

::= <identifier>

<fptype>

::= <type_ref>

<fptype_new>

::= <type_ref>

| tkArray tkOf tkConst

<stmt>

::= <unlabelled_stmt>

| <label_name> tkColon <unlabelled_stmt>

<unlabelled_stmt>

::=

| <assignment>

| <proc_call>

| <goto_stmt>

| <compound_stmt>

| <if_stmt>

| <case_stmt>

| <repeat_stmt>

| <while_stmt>

| <for_stmt>

| <with_stmt>

| <asm_stmt>

| <inherited_message>

| <try_stmt>

| <raise_stmt>

| <foreach_stmt>

| <var_stmt>

<var_stmt>

::= tkVar <var_decl_part_in_stmt>

<var_decl_part_in_stmt>

::= <var_decl_part_normal>

| <var_name_list> tkColon <type_ref> tkEqual <expr>

| <var_name_list> tkAssign <expr>

<assignment>

::= <var_reference> <assign_operator> <expr>

<proc_call>

::= <var_reference>

<goto_stmt>

::= tkGoto <label_name>

<compound_stmt>

::= tkBegin <stmt_list> tkEnd

<stmt_list>

::= <stmt>

| <stmt_list> tkSemiColon <stmt>

<if_stmt>

::= tkIf <expr> <if_then_else_branch>

<if_then_else_branch>

::= tkThen <then_branch>

| tkThen <then_branch> tkElse <else_branch>

<then_branch>

::= <stmt>

<else_branch>

::= <stmt>

<case_stmt>

::= tkCase <expr> tkOf <case_list> <else_case> tkEnd

<case_list>

::= <case_item>

| <case_list> tkSemiColon <case_item>

<case_item>

::=

| <case_label_list> tkColon <stmt>

<case_label_list>

::= <case_label>

| <case_label_list> tkComma <case_label>

<case_label>

::= <const_elem>

<else_case>

::=

| tkElse <stmt_list>

<repeat_stmt>

::= tkRepeat <stmt_list> tkUntil <expr>

<while_stmt>

::= tkWhile <expr> tkDo <stmt>

<foreach_stmt>

::= tkForeach <identifier> tkColon <type_ref> tkIn <expr> tkDo <stmt>

<for_stmt>

::= tkFor <identifier> tkAssign <expr> <for_cycle_type> <expr> tkDo <stmt>

<for_cycle_type>

::= tkTo

| tkDownto

<with_stmt>

::= tkWith <expr_list> tkDo <stmt>

<inherited_message>

::= tkInherited

<try_stmt>

::= tkTry <stmt_list> <try_handler>

<try_handler>

::= tkFinally <stmt_list> tkEnd

| tkExcept <exception_block> tkEnd

<exception_block>

::= <exception_handler_list> <exception_block_else_branch>

| <exception_handler_list> tkSemiColon <exception_block_else_branch>

| <stmt_list>

<exception_handler_list>

::= <exception_handler>

| <exception_handler_list> tkSemiColon <exception_handler>

<exception_block_else_branch>

::=

| tkElse <stmt_list>

<exception_handler>

::= tkOn <exception_identifier> tkDo <stmt>

<exception_identifier>

::= <exception_class_type_identifier>

| <exception_variable> tkColon <exception_class_type_identifier>

<exception_class_type_identifier>

::= <simple_type_identifier>

<exception_variable>

::= <identifier>

<raise_stmt>

::= tkRaise

| tkRaise <expr>

| tkRaise <expr> tkAt <expr>

<asm_stmt>

::= tkAsmBody

<expr_list>

::= <expr>

| <expr_list> tkComma <expr>

<expr>

::= <relop_expr>

| <new_expr>

<sizeof_expr>

::= tkSizeOf tkRoundOpen <simple_type_identifier> tkRoundClose

<typeof_expr>

::= tkTypeOf tkRoundOpen <simple_type_identifier> tkRoundClose

<new_expr>

::= <identifier> <simple_type_identifier> <opt_template_type_params>

<opt_expr_list_with_bracket>

<opt_template_type_params>

::=

| <template_type_params>

<opt_expr_list_with_bracket>

::=

| tkRoundOpen <opt_expr_list> tkRoundClose

<relop_expr>

::= <simple_expr>

| <simple_expr> <relop> <relop_expr>

| <simple_expr> tkColon <simple_expr>

| <simple_expr> tkColon <simple_expr> tkColon <simple_expr>

<relop>

::= tkEqual

| tkNotEqual

| tkLower

| tkGreater

| tkLowerEqual

| tkGreaterEqual

| tkIn

<simple_expr>

::= <term>

| <simple_expr> <addop> <term>

<addop>

::= tkPlus

| tkMinus

| tkOr

| tkXor

<typecast_op>

::= tkAs

| tkIs

<term>

::= <factor>

| <term> <mulop> <factor>

| <term> <typecast_op> <simple_type_identifier>

<mulop>

::= tkStar

| tkSlash

| tkDiv

| tkMod

| tkShl

| tkShr

| tkAnd

<factor>

::= tkNil

| <literal_or_number>

| tkSquareOpen <elem_list> tkSquareClose

| tkNot <factor>

| <sign> <factor>

| tkDeref <factor>

| <var_reference>

<literal_or_number>

::= <literal>

| <unsigned_number>

<var_reference>

::= <var_address> <variable>

| <variable>

<var_address>

::= tkAddressOf

| <var_address> tkAddressOf

<variable>

::= <identifier>

| <operator_name_ident>

| tkInherited <identifier>

| tkRoundOpen <expr> tkRoundClose

| <sizeof_expr>

| <typeof_expr>

| tkRoundOpen tkRoundClose

| <literal_or_number> tkPoint <identifier_or_keyword>

| <variable> <var_specifiers>

<opt_expr_list>

::= <expr_list>

|

<var_specifiers>

::= tkSquareOpen <expr_list> tkSquareClose

| tkSquareOpen tkSquareClose

| tkRoundOpen <opt_expr_list> tkRoundClose

| tkPoint <identifier_keyword_operatorname>

| tkDeref

<template_type_back_varspecifiers>

::= tkRoundOpen <expr_list> tkRoundClose

| tkRoundOpen tkRoundClose

<elem_list>

::= <elem_list1>

|

<elem_list1>

::= <elem>

| <elem_list1> tkComma <elem>

<elem>

::= <expr>

| <expr> tkDotDot <expr>

<one_literal>

::= tkStringLiteral

| tkAsciiChar

<literal>

::=<literal_list>

<literal_list>

::= <one_literal>

| <literal_list> <one_literal>

<operator_name_ident>

::= tkOperator <overload_operator>

<opt_meth_modificators>

::= tkSemiColon

| tkSemiColon <meth_modificators> tkSemiColon

<meth_modificators>

::= <meth_modificator>

| <meth_modificators> tkSemiColon <meth_modificator>

<integer_const>

::= <sign> tkInteger

| tkInteger

| <sign> tkHex

| tkHex

| <identifier>

| <sign> <identifier>

<identifier>

::= tkIdentifier

| <real_type_name>

| <ord_type_name>

| <variant_type_name>

| <meth_modificator>

| <property_specifier_directives>

| <non_reserved>

| <other>

<identifier_or_keyword>

::= <identifier>

| <keyword>

| <reserved_keyword>

<identifier_keyword_operatorname>

::= <identifier>

| <keyword>

| <operator_name_ident>

<real_type_name>

::= tkReal

| tkSingle

| tkDouble

| tkExtended

| tkCurrency

| tkComp

<ord_type_name>

::= tkShortInt

| tkSmallInt

| tkOrdInteger

| tkByte

| tkLongInt

| tkInt64

| tkWord

| tkBoolean

| tkChar

| tkWideChar

| tkLongWord

| tkPChar

| tkCardinal

<variant_type_name>

::= tkVariant

| tkOleVariant

<meth_modificator>

::= tkAbstract

| tkOverload

| tkOverride

| tkVirtual

| tkStatic

<property_specifier_directives>

::= tkDefault

| tkRead

| tkWrite

| tkStored

| tkNodefault

| tkImplements

| tkWriteOnly

| tkReadOnly

| tkDispid

<non_reserved>

::= tkAt

| tkAbsolute

| tkOn

| tkName

| tkIndex

| tkMessage

| tkContains

| tkRequires

| tkForward

| tkOut

| tkObject

<visibility_specifier>

::= tkInternal

| tkPublic

| tkProtected

| tkPrivate

<other>

::= tkPackage

| tkUnit

| tkLibrary

| tkExternal

| tkBF

| tkParams

<keyword>

::= <visibility_specifier>

| tkOr

| tkTypeOf

| tkSizeOf

| tkWhere

| tkXor

| tkAnd

| tkDiv

| tkMod

| tkShl

| tkShr

| tkNot

| tkAs

| tkIn

| tkIs

| tkArray

| tkBegin

| tkCase

| tkClass

| tkConst

| tkConstructor

| tkDestructor

| tkDownto

| tkDo

| tkElse

| tkEnd

| tkExcept

| tkFile

| tkFinalization

| tkFinally

| tkFor

| tkFunction

| tkIf

| tkImplementation

| tkInherited

| tkInitialization

| tkInterface

| tkProcedure

| tkProperty

| tkRaise

| tkRecord

| tkRepeat

| tkSet

| tkTry

| tkType

| tkThen

| tkTo

| tkUntil

| tkUses

| tkUsing

| tkVar