Разработка транслятора с ограниченного подмножества языка высокого уровня

Тип работы:
Курсовая
Предмет:
Программирование


Узнать стоимость

Детальная информация о работе

Выдержка из работы

«Разработка транслятора с ограниченного подмножества языка высокого уровня»

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

Введение

Как известно, целью трансляции является преобразование исходного текста программы в текст, который будет понятен адресату. В качестве адресата может выступать как программное, так и техническое средство. Следовательно, с развитием вычислительных систем разработка качественного транслятора остаётся актуальной темой. Известно, что транслятор имеет ряд характеристик:

· Корректная обработка исходного (входного) текста.

· Корректная обработка всевозможных исключительных ситуаций.

· Универсальность.

· Оптимизированная работа.

· Наличие на выходе корректного результата обработки исходного текста. Выше перечисленные пункты значимы при разработке, потому что транслятор, который будет некорректно обрабатывать входные данные, или иметь на выходе ложный результат, никому не нужен. Так же очень важна скорость обработки входных данных, поэтому оптимизация играет не малую роль. Целью данной курсовой работы является разработка транслятора. Для достижения поставленной цели необходимо решить следующие задачи:

· Представить синтаксис языка в БНФ. Определить терминалы, нетерминалы, начальный символ и набор правил для данного языка.

· Создать каркас транслятора.

· Построить лексический анализатор. Результатом работы анализатора должна быть таблица лексем.

· Построить синтаксический анализатор. Приведение выражений к обратной польской записи.

· Построить генератор кода.

1. Теоретическая часть

1. 1 Транслятор

Транслятор -- программа или техническое средство, выполняющее трансляцию программы. Цель трансляции -- преобразовать текст с одного языка на другой, который понятен адресату текста. В случае программ-трансляторов, адресатом является техническое устройство (процессор) или программа-интерпретатор.

Язык процессоров (машинный код) обычно является низкоуровневым. Существуют платформы, использующие в качестве машинного язык высокого уровня, но они являются исключением из правила в силу сложности и дороговизны. Транслятор, который преобразует программы в машинный язык, принимаемый и исполняемый непосредственно процессором, называется компилятором.

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

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

1. 2 Лексический анализатор

В информатике лексический анализ -- процесс аналитического разбора входной последовательности символов (например, такой как исходный код на одном из языков программирования) с целью получения на выходе последовательности символов, называемых «токенами» (подобно группировке букв в слова). Группа символов входной последовательности, идентифицируемая на выходе процесса как токен, называется лексемой. В процессе лексического анализа производится распознавание и выделение лексем из входной последовательности символов.

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

Традиционно принято организовывать процесс лексического анализа, рассматривая входную последовательность символов как поток символов. При такой организации процесс самостоятельно управляет выборкой отдельных символов из входного потока. Распознавание лексем в контексте грамматики обычно производится путём их идентификации (или классификации) согласно идентификаторам (или классам) токенов, определяемых грамматикой языка. При этом любая последовательность символов входного потока (лексема), которая согласно грамматике не может быть идентифицирована как токен языка, обычно рассматривается как специальныйтокен-ошибка.

Каждый токен можно представить в виде структуры, содержащей идентификатор токена (или идентификатор класса токена) и, если нужно, последовательность символов лексемы, выделенной из входного потока.

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

1. 3 Синтаксический анализатор

В информатике, синтаксический анализ -- это процесс сопоставления линейной последовательности лексем (слов, токенов) языка с его формальной грамматикой. Результатом обычно является дерево разбора (синтаксическое дерево). Обычно применяется совместно с лексическим анализом. Синтаксический анализатор (парсер) -- это программа или часть программы, выполняющая синтаксический анализ.

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

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

1. 4 Генератор кода

Последней фазой компиляции является генерация кода. Результатом выполнения этой фазы обычно является программа в выполняемых кодах той ЭВМ, на которой она должна выполняться. Однако в ряде случаев в качестве выходного языка транслятора используют ассемблер. В данной работе мы будем генерировать программу на языке ассемблера. Чтобы облегчить написание генератора кода и освободить его от посторонних соображений, связанных с конкретными особенностями какой-либо ЭВМ, будем использовать гипотетический процессор (виртуальную машину). Этот процессор не существует на самом деле (в аппаратном виде). При выборе его архитектуры требовалась максимальная простота и, в то же время, возможность легко выполнять на нем программы на языках, реализуемых в процессе выполнения лабораторных работ и курсового проектирования. Особенностью архитектуры является то, что все действия выполняются только над элементами в вершине стека, результаты операций также помещаются в вершину стека. Поэтому в арифметических и логических операциях нет необходимости в указании адреса операндов. Если операция имеет 2 операнда, то ее выполнения подразумевает перенос элемента из вершины стека в регистр-аккумулятор и «понижение» на один элемент вниз указателя стека. Второй операнд, оказавшийся в вершине стека, подается непосредственно в АЛУ. Результат операции помещается в вершину стека вместо него.

2. Практическая часть

2. 1 Синтаксис языка в БНФ. Терминалы, нетерминалы, начальный символ и правила

Вариант задания:

< Программа>: := < Объявление переменных> <Описание вычислений> <Описание вычислений>: := Begin< Список присваиваний> End<Объявление переменных>: := Int< Список переменных> |

Int< Список переменных> <Объявление переменных>

< Список переменных>: := < Идент>; | < Идент> ,< Список переменных> <Список присваиваний> := < Присваивание> |

< Присваивание><Список присваиваний> <Присваивание>: := < Идент> := < Выражение>;

< Выражение>: := < Ун. оп. ><Подвыражение> | < Подвыражение><Подвыражение>: = (< Выражение>) | < Операнд> |

< Подвыражение > <Бин. оп. ><Подвыражение>

< Ун. оп. >: := «-»

< Бин. оп. >: := «-» | «+» | «*» | «/»

< Операнд>: := < Идент> | < Const>

< Идент>: := < Буква><Идент> | < Буква>

< Const>: := < Цифра><Const> | < Цифра>

Форма Бекуса — Наура — набор правил, последовательным применением которых можно построить любое предложение.

Грамматика определяется, как следующая четверка Vt — алфавит, символы которого называются терминалами из них строятся цепочки порождаемые грамматикой; Vn- алфавит, символы которого называется нетерминальными (не терминалами), используются при построении цепочек. P — Набор правил, по которым строится грамматика; S — начальное правило.

Нетерминалы:

N={

S=< Программа>

D=< Объявление переменных>

F=< Описание вычислений>

P=< Оператор печати>

V=< Список переменных>

I=< Идентификатор>

G=< Список присваиваний>

A=< Присваивание>

E=< Выражение>

H=< Подвыражение>

O=< Операнд>

C=< Const>

N=< Цифра>

}

Терминалы:

Ключевыесловаязыка:

T={begin, end, integer, print}

Разделители:

R={: =,. ();}

Алфавит:

A=…

Бинарные операции:

B=-

Унарная опреация:

U={-}

Цифры:

C=…

Правила:

1. S=DF

2. F=begin G end

3. G=A

4. G=AG

5. A=I: =E

6. I=LI

7. I=L

8. E=UH

9. E=H

10. H=(E)

11. H=O

12. H= HBH

13. O=I

14. O=C

15. C=NC

16. C=N

17. D=integer V

18. V=I;

19. V=I, V

20. P=print I

2. 2 Каркас транслятора

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

Создадим классы и перечисления необходимые в дальнейшем для реализации всех частей транслятора:

///< summary>

///Парсер

///< /summary>

publicstaticclassReader

///< summary>

///Лексическийанализатор

///< /summary>

publicstaticclassLexicalAnalyzer

///< summary>

///Лексемы

///< /summary>

publicenumLexems

{

None, Name, Number, Begin, End, Multiplication, Division,

Plus, Minus, Equal, NotEqual, Less, LessOrEqual, More, MoreOrEqual, Int,

Print, LeftBracket, RightBracket, Semi, Comma, EOF, Determine,

LongInt, Until, Do, EndUntil

}

///< summary>

///Ключевоеслово

///< /summary>

internalstructKeyWord

{

publicstring word;

publicLexemslex;

}

///< summary>

///Категория

///< /summary>

publicenumtCat

{

Const, Var, Type

}

///< summary>

///Тип

///< /summary>

publicenumtType

{

None, Int, LInt, Bool

}

///< summary>

///Идентификатор

///< /summary>

publicstructIdentificator

{

publicstring name;

publictCat category;

publictType type;

}

///< summary>

///Таблицаимен

///< /summary>

publicstaticclassNameTable

///< summary>

///Синтаксическийанализатор

///< /summary>

publicstaticclassSyntaxAnalyzer

///< summary>

/// Генератор постфиксной записи

///< /summary>

publicstaticclassPostFix

///< summary>

///Генераторкода

///< /summary>

publicstaticclassCodeGenerator

Дальше создаем необходимый для удобной работы интерфейс (рис. 1), с верхним меню:

Рис. 1 Интерфейс приложения

2. 3 Лексический анализатор

Для задания типа лексемы обычно используется перечисление, включающее в себя все возможные в исходном языке типы: ключевые слова, операторы, идентификаторы и числа.

publicenumLexems

{

None, Name, Number, Begin, End, Multiplication, Division,

Plus, Minus, Equal, NotEqual, Less, LessOrEqual, More, MoreOrEqual, Int,

Print, LeftBracket, RightBracket, Semi, Comma, EOF, Determine,

LongInt, Until, Do, EndUntil

}

Далее создаем отдельную структуру, описывающую данный тип лексемы:

///< summary>

///Ключевоеслово

///< /summary>

internalstructKeyWord

{

publicstring word;

publicLexemslex;

}

publicstaticvoid Initialize ()

{

keywords = newKeyWord[10];

keywordPointer = 0;

currentLexem = 0;

currentName = null;

AddKeyword («Begin», Lexems. Begin);

AddKeyword («End», Lexems. End);

AddKeyword («Integer», Lexems. Int);

AddKeyword («Long Integer», Lexems. LongInt);

AddKeyword («Print», Lexems. Print);

AddKeyword («UNTIL», Lexems. Until);

AddKeyword («DO», Lexems. Do);

AddKeyword («ENDUNTIL», Lexems. EndUntil);

}

В рамках класса LexicalAnalyzerбудем реализовывать методы лексического анализа: хранение ключевых слов языка и их распознавание, разбор текущей лексемы в зависимости от её типа.

///< summary>

///Лексическийанализатор

///< /summary>

publicstaticclassLexicalAnalyzer

{

privatestaticKeyWord[] keywords;

privatestaticintkeywordPointer;

privatestaticstringcurrentName;

privatestaticLexemscurrentLexem;

///< summary>

///Инициализировать

///< /summary>

publicstaticvoid Initialize ()

{

keywords = newKeyWord[10];

keywordPointer = 0;

currentLexem = 0;

currentName = null;

AddKeyword («Begin», Lexems. Begin);

AddKeyword («End», Lexems. End);

AddKeyword («Integer», Lexems. Int);

AddKeyword («Long Integer», Lexems. LongInt);

AddKeyword («Print», Lexems. Print);

AddKeyword («UNTIL», Lexems. Until);

AddKeyword («DO», Lexems. Do);

AddKeyword («ENDUNTIL», Lexems. EndUntil);

}

///< summary>

///Текущееимя

///< /summary>

publicstaticstringCurrentName

{

get

{

returncurrentName;

}

}

///< summary>

///Текущаялексема

///< /summary>

publicstaticLexemsCurrentLexem

{

get

{

returncurrentLexem;

}

}

///< summary>

///Добавитьключевоеслово

///< /summary>

///< param name="keyword"> слово</param>

///< param name="lex"> лексема</param>

///< returns></returns>

publicstaticboolAddKeyword (string keyword, Lexemslex)

{

if (keywordPointer< keywords. Length)

{

KeyWord kw = newKeyWord ();

kw. word = keyword;

kw. lex = lex;

keywords[keywordPointer++] = kw;

returntrue;

}

returnfalse;

}

///< summary>

///Получитьключевоеслово

///< /summary>

///< param name="keyword"> слово</param>

///< returns></returns>

publicstaticLexemsGetKeyword (string keyword)

{

for (inti = keywordPointer — 1; i>= 0; i--)

{

if (keywords[i]. word == keyword)

{

return keywords[i]. lex;

}

}

returnLexems. Name;

}

///< summary>

///Разоьрать следующую лексему

///< /summary>

publicstaticvoidParseNextLexem ()

{

while (char. IsWhiteSpace (Reader. CurrentChar))

Reader. ReadNextChar ();

if (char. IsLetter (Reader. CurrentChar))

ParseIdentificator ();

elseif (char. IsDigit (Reader. CurrentChar))

ParseNumber ();

elseif (Reader. CurrentChar == 'n')

{

Reader. ReadNextChar ();

currentLexem = Lexems. None;

}

elseif (Reader. CurrentChar == '< ')

{

Reader. ReadNextChar ();

if (Reader. CurrentChar == '=')

{

Reader. ReadNextChar ();

currentName = «< =»;

currentLexem = Lexems. LessOrEqual;

}

else

{

currentName = «< «;

currentLexem = Lexems. Less;

}

}

elseif (Reader. CurrentChar == '> ')

{

Reader. ReadNextChar ();

if (Reader. CurrentChar == '=')

{

Reader. ReadNextChar ();

currentName = «> =»;

currentLexem = Lexems. MoreOrEqual;

}

else

{

currentName = «> «;

currentLexem = Lexems. More;

}

}

elseif (Reader. CurrentChar == '=')

{

Reader. ReadNextChar ();

if (Reader. CurrentChar == '=')

{

Reader. ReadNextChar ();

currentName = «==»;

currentLexem = Lexems. Equal;

}

else

{

currentName = «=»;

currentLexem = Lexems. Determine;

}

}

elseif (Reader. CurrentChar == '!')

{

Reader. ReadNextChar ();

if (Reader. CurrentChar == '=')

{

Reader. ReadNextChar ();

currentName = «≠»;

currentLexem = Lexems. NotEqual;

}

else

Errors. Error («Неизвестный символ»);

}

elseif (Reader. CurrentChar == '+')

{

Reader. ReadNextChar ();

currentName = «+»;

currentLexem = Lexems. Plus;

}

elseif (Reader. CurrentChar == '*')

{

Reader. ReadNextChar ();

currentName = «*»;

currentLexem = Lexems. Multiplication;

}

elseif (Reader. CurrentChar == '/')

{

Reader. ReadNextChar ();

currentName = «/»;

currentLexem = Lexems. Division;

}

elseif (Reader. CurrentChar == ',')

{

Reader. ReadNextChar ();

currentName = «,»;

currentLexem = Lexems. Comma;

}

elseif (Reader. CurrentChar == '; ')

{

Reader. ReadNextChar ();

currentName = «; «;

currentLexem = Lexems. Semi;

}

elseif (Reader. CurrentChar == '(')

{

Reader. ReadNextChar ();

currentName = «(»;

currentLexem = Lexems. LeftBracket;

}

elseif (Reader. CurrentChar == ')')

{

Reader. ReadNextChar ();

currentName = «)»;

currentLexem = Lexems. RightBracket;

}

elseif (Reader. CurrentChar == char. MinValue)

{

currentName = «EOF»;

currentLexem = Lexems. EOF;

}

else

Errors. Error («Недопустимый символ!»);

}

///< summary>

///Разобратьидентификатор

///< /summary>

privatestaticvoidParseIdentificator ()

{

stringidentificator = string. Empty;

int count = 0;

do

{

identificator += Reader. CurrentChar;

if (identificator == «Long»)

{

Reader. ReadNextChar ();

identificator += Reader. CurrentChar;

count++;

}

Reader. ReadNextChar ();

if (++count > 20)

Errors. Error («Chars overflow»);

}

while (char. IsLetter (Reader. CurrentChar));

currentName = identificator;

currentLexem = GetKeyword (identificator);

}

///< summary>

///Разобратьчисло

///< /summary>

privatestaticvoidParseNumber ()

{

string number = string. Empty;

do

{

number += Reader. CurrentChar;

Reader. ReadNextChar ();

}

while (char. IsDigit (Reader. CurrentChar));

try

{

Int32. Parse (number);

}

catch (OverflowException)

{

Errors. Error («Не является числом»);

}

currentName = number;

currentLexem = Lexems. Number;

}

}

2. 3 Синтаксический анализатор

После того как был создан класс classReader, далее начнем заполнять его функционалом.

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

publicstaticclassPostFix

{

privatestaticList< string> res;

privatestaticStack< Lexems> stack;

///< summary>

///Инициализировать

///< /summary>

publicstaticvoid Initialize ()

{

res = newList< string>();

stack = newStack< Lexems>();

}

///< summary>

///Добавить

///< /summary>

///< param name="lexem"> </param>

publicstaticvoid Add (Lexemslexem)

{

switch (lexem)

{

caseLexems. Name:

{

string temp = LexicalAnalyzer. CurrentName;

res. Add (temp);

}

break;

caseLexems. Number:

{

string temp = LexicalAnalyzer. CurrentName;

res. Add (temp);

}

break;

caseLexems. LeftBracket:

{

stack. Push (Lexems. LeftBracket);

}

break;

caseLexems. RightBracket:

{

while (stack. Peek () ≠ Lexems. LeftBracket)

{

res. Add (ConvertToString (stack. Pop ()));

}

stack. Pop ();

}

break;

caseLexems. Minus:

caseLexems. Plus:

{

Lexemslex = newLexems ();

if (stack. Count> 0)

lex = stack. Peek ();

while (lex == Lexems. Plus

|| lex == Lexems. Minus

|| lex == Lexems. Multiplication

|| lex == Lexems. Division)

{

res. Add (ConvertToString (stack. Pop ()));

if (stack. Count> 0)

lex = stack. Peek ();

else

break;

}

stack. Push (lexem);

}

break;

caseLexems. Multiplication:

caseLexems. Division:

{

Lexemslex = newLexems ();

if (stack. Count> 0)

lex = stack. Peek ();

while (lex == Lexems. Multiplication

|| lex == Lexems. Division)

{

res. Add (ConvertToString (stack. Pop ()));

if (stack. Count> 0)

lex = stack. Peek ();

else

break;

}

stack. Push (lexem);

}

break;

caseLexems. Determine:

{

stack. Push (lexem);

}

break;

}

}

Далее создаем различные методы, для синтаксического анализа отдельных частей исходного кода: Блок объявления переменных, блок непосредственно выполнения каких либо операция, блок вывода на печать, блок цикла UNTIL.

publicstaticvoidCompille ()

{

PostFix. Initialize ();

CodeGenerator. DeclairDataSegment ();

LexicalAnalyzer. Initialize ();

NameTable. Initialize ();

ParseVariables ();

CodeGenerator. DeclairVariables ();

CodeGenerator. DeclairSegmentOfStackAndCode ();

CheckLexem (Lexems. Semi);

if (LexicalAnalyzer. CurrentLexem == Lexems. Begin)

LexicalAnalyzer. ParseNextLexem ();

ParseInstructionSequence ();

CheckLexem (Lexems. End);

CodeGenerator. DeclairEndMainProc ();

CodeGenerator. DeclairPrint ();

CodeGenerator. DeclairCodeEnd ();

if (Errors. ErrorsCount == 0)

Errors. Error («Compille success»);

}

publicstaticvoidParseCycle ()

{

CheckLexem (Lexems. Until);

CodeGenerator. AddLabel ();

stringupperLabel = CodeGenerator. GetCurrentLabel ();

CodeGenerator. AddLabel ();

stringlowerLabel = CodeGenerator. GetCurrentLabel ();

CodeGenerator. AddInstruction (upperLabel + «: «);

ParseExpression ();

CheckLexem (Lexems. Do);

ParseInstructionSequence ();

CheckLexem (Lexems. EndUntil);

CodeGenerator. AddInstruction («jmp «+ upperLabel);

CodeGenerator. AddInstruction (lowerLabel + «: «);

}

staticvoidParseVariables ()

{

CheckLexem (Lexems. None);

CheckLexem (Lexems. Int);

if (LexicalAnalyzer. CurrentLexem ≠ Lexems. Name)

Errors. Error («Не является идентификатором»);

else

{

NameTable. AddIdentificator (LexicalAnalyzer. CurrentName, tCat. Var);

LexicalAnalyzer. ParseNextLexem ();

}

while (LexicalAnalyzer. CurrentLexem == Lexems. Comma)

{

LexicalAnalyzer. ParseNextLexem ();

if (LexicalAnalyzer. CurrentLexem ≠ Lexems. Name)

Errors. Error («Не является идентификатором»);

else

{

NameTable. AddIdentificator (LexicalAnalyzer. CurrentName, tCat. Var);

LexicalAnalyzer. ParseNextLexem ();

}

}

2. 4 Генераторкода

LITconst — поместитьконстантуввершинустека.

LOAD n — поместить переменную, размещенную по адресу n в вершину

стека.

STO n — запись значения из вершины стека по адресу n (присваивание).

JMP k — безусловный переход к команде, расположенной по адресу k.

JEQ k — переход к команде, расположенной по адресу k в случае

равенства двух верхних элементов стека.

JLT k — переход к команде, расположенной по адресу k, если число в вершине стека меньше следующего за ним числа стека.

JLE k — переход к команде, расположенной по адресу k, если число в вершине стека меньше или равно следующему за ним числу стека.

JGT k — переход к команде, расположенной по адресу k, если число в вершине стека больше следующего за ним числа стека.

JGE k — переход к команде, расположенной по адресу k, если число в вершине стека больше или равно следующему за ним числу стека.

JNE k — переход к команде, расположенной по адресу k в случае неравенства двух верхних элементов стека.

ADR — содержимое регистра адреса данных помещается в вершину стека.

STAD — содержимое вершины стека помещается в регистр адреса данных.

ADD — сложение двух верхних элементов стека, результат помещается в вершину стека.

MUL — умножение двух верхних элементов стека, результат помещается в вершину стека.

SUB — вычитание элемента в вершине стека из следующего за ним элемента стека, результат помещается в вершину стека.

DIV — деление на элемент в вершине стека следующего за ним элемента стека, результат помещается в вершину стека.

AND — логическое «И» (логическое умножение) двух верхних элементов стека, результат помещается в вершину стека.

OR — логическое «ИЛИ» (логическое сложение) двух верхних элементов стека, результат помещается в вершину стека.

DIV — деление на элемент в вершине стека следующего за ним

XOR — сложение по модулю 2 двух верхних элементов стека, результат помещается в вершину стека. NOT — знаковая инверсия элемента в вершине стека

NOL — поразрядная логическая инверсия элемента в вершине стека. NOP — пустая операция.

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

///< summary>

/// Генератор кода

///< /summary>

publicstaticclassCodeGenerator

{

privateconstint MAX_NUMBER_STRINGS = 1000;

privatestaticstring[] code = newstring[MAX_NUMBER_STRINGS];

privatestaticintcodePointer = 0;

privatestaticintcountLabels = 0;

///< summary>

///Добавитьинструкцию

///< /summary>

///< param name="instraction"> </param>

publicstaticvoidAddInstruction (stringinstraction)

{

code[codePointer++] = instraction;

}

///< summary>

///Добавитьметку

///< /summary>

publicstaticvoidAddLabel ()

{

countLabels++;

}

///< summary>

///Вернутьтекущуюметку

///< /summary>

///< returns></returns>

publicstaticstringGetCurrentLabel ()

{

return"label" + countLabels. ToString ();

}

///< summary>

///Описатьсегментданных

///< /summary>

publicstaticvoidDeclairDataSegment ()

{

AddInstruction («data segment para public „data“»);

}

///< summary>

/// Описать сегмент стэка и кода

///< /summary>

publicstaticvoidDeclairSegmentOfStackAndCode ()

{

AddInstruction («PRINT_BUF DB ' ' DUP (10)»);

AddInstruction («BUFEND DB '$'»);

AddInstruction («data ends»);

AddInstruction («stk segment stack»);

AddInstruction («db 256 dup („?“)»);

AddInstruction («stk ends»);

AddInstruction («code segment para public „code“»);

AddInstruction («main proc»);

AddInstruction («assume cs: code, ds: data, ss: stk»);

AddInstruction («movax, data»);

AddInstruction («movds, ax»);

}

///< summary>

/// Описать конец главной процедуры

///< /summary>

publicstaticvoidDeclairEndMainProc ()

{

AddInstruction («mov ax, 4c00h»);

AddInstruction («int 21h»);

AddInstruction («main endp»);

}

///< summary>

/// Описать коней сегмента кода

///< /summary>

publicstaticvoidDeclairCodeEnd ()

{

AddInstruction («code ends»);

AddInstruction («end main»);

}

///< summary>

///Описатьпеременные

///< /summary>

publicstaticvoidDeclairVariables ()

{

LinkedListNode< Identificator> node = NameTable. GetIdentificators. First;

while (node ≠ null)

{

if (SyntaxAnalyzer. Type == tType. Int)

AddInstruction (node. Value. name + «dw 1»);

if (SyntaxAnalyzer. Type == tType. LInt)

AddInstruction (node. Value. name + «dl 1»);

node = node. Next;

}

}

///< summary>

///Опичать процедуру вывода на печать

///< /summary>

publicstaticvoidDeclairPrint ()

{

AddInstruction («PRINT PROC NEAR»);

AddInstruction («MOV CX, 10»);

AddInstruction («MOV DI, BUFEND — PRINT_BUF»);

AddInstruction («PRINT_LOOP: «);

AddInstruction («MOV DX, 0»);

AddInstruction («DIV CX»);

AddInstruction («ADD DL, '0'»);

AddInstruction («MOV [PRINT_BUF + DI — 1], DL»);

AddInstruction («DEC DI»);

AddInstruction («CMP AL, 0»);

AddInstruction («JNE PRINT_LOOP»);

AddInstruction («LEA DX, PRINT_BUF»);

AddInstruction («ADD DX, DI»);

AddInstruction («MOV AH, 09H»);

AddInstruction («INT 21H»);

AddInstruction («RET»);

AddInstruction («PRINT ENDP»);

}

Для реализации арифметических (и не только) операций в языке ассемблер используется работа с регистровой памятью. Так, чтобы поместить значение (числовую константу или переменную) в регистр, используется инструкция mov. Команды для арифметических операций приведены в таблице ниже.

Таблица

Операция

Инструкция ассемблера

+

add

-

sub

*

mul

/

div

Таким образом, код для выражения a + b будет выглядеть следующим образом:

mov ax, a

movbx b

addax, bx

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

3. Тестирование приложения

Так как наше приложение должно отлавливать ошибки на любом из трех этапов выполнения, для проверки правильности работы, необходимо протестировать программу. Будем подавать ей на вход несколько примеров исходного кода, как правильного, так и заведомо некорректного, для того, чтобы проверить этапы выполнения.

Пример 1:

Inta, s, r;

Begin

a=c+b;

Print a;

End

Результат выполнения программы:

Таблица

Пример 2:

Integer a, s, r;

Begin

s=5;

r=9;

u=0;

a=s+r;

s=((a*4)/2)ggg*r+10;

EndРезультат:

Таблица

Заключение

В данной курсовой работе была рассмотрена разработка транслятора, в среде VisualStudio 2008, на языке C#.

Поставленная цель была достигнута путём решения следующих задач:

· Построен лексический анализатор с отлавливанием ошибок на данном этапе трансляции.

· Построен синтаксический анализатор с отлавливанием ошибок на данном этапе трансляции.

· Построен генератор кода основных блоков исходной программы, соответствующей заданному языку, а также дополнительных блоков SWITCH и WHILE

· Проведено тестирование приложения, для проверки правильности работы.

·

ПоказатьСвернуть
Заполнить форму текущей работой