Курсовая работа по дисциплине «Системное программное обеспечение» Лексика и синтаксис языков программирования

МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ

ФЕДЕРАЛЬНОЕ АГЕНТСТВО ПО ОБРАЗОВАНИЮ

ГОСУДАРСТВЕННОЕ ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ ВЫСШЕГО

ПРОФЕССИОНАЛЬНОГО ОБРАЗОВАНИЯ

НОВОСИБИРСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ

ФАКУЛЬТЕТ АВТОМАТИКИ И ВЫЧИСЛИТЕЛЬНОЙ ТЕХНИКИ

КАФЕДРА ВЫЧИСЛИТЕЛЬНОЙ ТЕХНИКИ

Курсовая работа

по дисциплине «Системное программное обеспечение»

Лексика и синтаксис языков программирования.

Студент:

Группа: АМ-610

Вариант: 4334223

Преподаватель:

Новосибирск 2010

Содержание

1. Задание................................................................................................................................................................................ 3

1.1 Содержание работы.................................................................................................................................................. 3

1.2 Краткое описание языка........................................................................................................................................ 3

1.3 Вариант задания........................................................................................................................................................ 4

2. Цель работы....................................................................................................................................................................... 5

3. Словесное описание..................................................................................................................................................... 5

3.1 Типы данных, различаемые языком.................................................................................................................... 5

3.2 Идентификаторы и константы, различаемые языком................................................................................. 5

3.3 Арифметические операции........................................................................................................................................ 5

3.4 Логические операции................................................................................................................................................... 5

3.5 Операторы сравнения.................................................................................................................................................. 5

3.6 Основные конструкции языка................................................................................................................................. 6

3.7 Дополнительные сведения об языке..................................................................................................................... 6

4. Разработка системы регулярных выражений.................................................................................................. 6

5. Разработка лексического анализатора.............................................................................................................. 8

6. Разработка формальной грамматики языка............................................................................................... 10

7. Разработка синтаксического анализатора................................................................................................... 12

7.1 Краткое описание классов расширения синтаксического акцептора для получения ПФЗ.... 12

7.2 Правила перевода в ПФЗ........................................................................................................................................... 13

8. Пример правильной программы......................................................................................................................... 14

9. Результаты работы автомата................................................................................................................................. 17

10. Выводы.............................................................................................................................................................................. 19

11. Использованная литература.................................................................................................................................. 19

1.  Задание

1.1 Содержание работы

·  Разработать словесное описание лексики, синтаксиса и семантики заданного варианта языка. Написать простую тестовую программу (программы), содержащую все заданные элементы и конструкции языка. Вручную выполнить интерпретацию программы. Эту программу (программы) использовать впоследствии для проверки элементов разрабатываемого транслятора.

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

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

Ø  поиск в таблицах идентификаторов / констант и пополнение таблиц;

Ø  формирование лексем,

и построить лексический анализатор. Проверить его работоспособность.

·  Разработать формальную грамматику класса LL(1), определяющую синтаксис заданного языка. Используя пакет WebTransLab, построить автоматную реализацию нисходящего синтаксического акцептора, проверить его работоспособность.

·  Разработать расширение синтаксического акцептора (нисходящего) для преобразования последовательности лексем в постфиксную запись

·  Оформить расчетно-пояснительную записку.

1.2 Краткое описание языка

Разрабатываемый язык – процедурный, относится к разделу Си-подобных языков, код регистрозависим. Правильная программа на данном языке представляет собой непустой список, который содержит определения и объявления функций и объявления глобальных переменных. Функция состоит из имени функции, списка параметров и тела. При определении функции указывается тип возвращаемого результата, имя, список параметров и тело; при объявлении – тип возвращаемого результата, имя, список параметров (для каждого параметра указывается тип и идентификатор). Тело функции может содержать блок объявления локальных переменных и блок операторов. Операторы разграничиваются с помощью разделителя “;”. Операторы объединяются в блоки с помощью фигурных скобок. Для локальных и глобальных переменных допускается объявление нескольких переменных одного типа через разделитель “,” и использование оператора присваивания при объявлении. Реализована возможность использования однострочных комментариев.

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

Обозначения:

[ ] – необязательная часть

… – часть, повторяющаяся произвольное количество раз

< > – описание конструкции

<Б>|<Ц>|<пБ>|<пЦ>|<пБЦ> – буква | цифра | последовательность букв | последовательность цифр | последовательность букв и/или цифр или пусто

<И> – <имя объекта>

<В> – <выражение>

<ЛВ> – <ЛогическоеВыражение>

<ОБ> – <ОператорИлиБлок> (<О> - одиночный оператор)

<К> – <константа>

II.1  Идентификаторы и константы

Вариант:	4
Идентификаторы	<Б><Ц><пБЦ>
Константы	целые вещественные символьные 7-ричные L_T / L_F

II.2  Объявления примитивных типов (целое, вещественное, символьное, булево):

Вариант:	3
	long doub[l[e]] litera bool[e[a[n]]]

II.3  Оператор присваивания:

Вариант:	4
	<И> = <В>;

II.4  Условный оператор:

В-т:	2
	when <ЛВ> then <ОБ> [else <ОБ>]

II.5  Переключатель

В-т:	2
	switch <В> { by <К>:<ОБ> …}

II.6  Оператор цикла:

В-т:	3
	for<И>from<К> to<К> [step <К>] <ОБ>

2.  Цель работы

·  Практическое применение теоретических основ проектирования трансляторов с языков программирования

·  Освоение средств автоматизации построения трансляторов (WebTransLab)

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

3.  Словесное описание

3.1 Типы данных, различаемые языком

Название	Псевдонимы
long
double	doub, doubl
litera
bool	boole, boolea, boolean
void

3.2 Идентификаторы и константы, различаемые языком

Тип	Примеры
Идентификаторы	a7xfd, b9f, g0dgfafssaf
Целые константы	0, 1, 100, 30137
Вещественные константы	0.34, 0.0, 8., 143.65, .87
Символьные константы	b, z, i, \g, \\, \<
7-ричные константы	0s6, 0s1, 0s0
Логические константы	L_T, L_F

3.3 Арифметические операции

+	сложение
-	вычитание
/	деление
*	умножение
%	остаток от деления

3.4 Логические операции

||	Логическое ИЛИ (Дизъюнкция)
&&	Логическое И (Конъюнкция)

3.5 Операторы сравнения

==	равенство
<	меньше
>	больше
<=	меньше-равно
>=	больше-равно
!=	неравенство

3.6 Основные конструкции языка

Определение функции	<тип> <И>(<cписок параметров>){<тело>}
Объявление функции	<тип> <И>(<cписок параметров>);
Объявление переменной	<тип> <И>; <тип> <И>,...,<И>; <тип> <И> = <К>;
Оператор присваивания	<И> = <В>;
Условный оператор	when <В> then <ОБ> [else <ОБ>];
Оператор переключения	switch <В> { by <К>:<ОБ> …}
Оператор цикла	for<И>from<К> to<К> [step <К>] <ОБ>
Вызов функции	<И>(<список факт. параметров> ); <И1> = <И>(<список факт. параметров>);
Возвращение результата функции	return <В>;

3.7 Дополнительные сведения об языке

При определении и объявлении функции для каждого параметра указывается тип и идентификатор, параметры перечисляются через запятую.

Локальные переменные могут быть объявлены только в начале тела функции, до блока операторов.

Допускается пустое тело функции и пустой оператор “;”.

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

В условном операторе часть else всегда относится к последнему when.

Вызов функции, возвращающей результат типа void, производится самостоятельно (как процедура), в остальных случаях вызов функции является частью выражения.

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

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

Определены следующие незначащие символы (символы языка, разбивающие текст программы на лексемы): символ пробела, перевода строки, табуляции и возврата каретки.

4.  Разработка системы регулярных выражений

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

Система регулярных выражений со встроенными действиями и комментариями приведена на рис. 1.

Рис.1. ЛА

5.  Разработка лексического анализатора

Краткое описание классов расширения лексического акцептора до анализатора:

class universalTable

{

private Vector<lexemData> tableData;

private HashMap hashMap;

public universalTable();

public int search(lexem Img);

public void add(lexemData Item);

public int size();

public String getTable(String caption);

}

Класс предназначен для хранения ключевых слов и их атрибутов. В векторе tableData хранятся ключевые слова и информация о них. С помощью hashMap осуществляется быстрый поиск по вектору: в качестве ключа используется ключевое слово, а значение — это индекс этого слова в векторе tableData.

public universalTable();

Конструктор. Создает пустой вектор и HashMap.

public int search(lexem Img);

Поиск лексемы по таблице. Возвращает индекс лексемы в таблице, если она есть, в противном случае возвращает -1.

public void add(lexemData Item);

Добавление новой лексемы в таблицу.

public int size();

Возвращает текущей размер таблицы.

public String getTable(String caption);

Возвращает таблицу в виде html-кода. Необходимо для визуального вывода таблицы.

class myTable

{

private String debugGroupWord;

private universalTable tableKeyWords;

private universalTable tableIdent;

private universalTable tableConst;

public myTable();

public void initTableKeyWords(int groupIndex);

public int processIdent(lexem Lex);

public int processConst(lexem Lex);

public boolean isBool(String str);

public boolean isDouble(String str)

public int processKeyWords(lexem Lex);

public int processOperator(lexem Lex);

public int processBracket(lexem Lex);

public int processOperation(lexem Lex);

public int processDelimiter(lexem Lex);

public String getTable(int h);

public void debugGroupWordFill(lexem Lex);

public void debugGroupWordEndln(lexem Lex);

public String debugGroupWordGet();

}

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

public myTable();

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

public void initTableKeyWords(int groupIndex);

Инициализация таблицы ключевых слов. Вызов данной функции осуществляется в правилах для регулярных выражений группы слов keyWord для первого слова этой группы, т. к. заранее индекс группы ключевых слов неизвестен.

public int processIdent(lexem Lex);

Функция обработки идентификаторов и занесения их в таблицу при необходимости.

public int processConst(lexem Lex);

Функция обработки констант и занесения их в таблицу при необходимости.

public boolean isBool(String str);

Функции проверяет, является ли входная строка синонимом типа bool.

public boolean isDouble(String str);

Функции проверяет, является ли входная строка синонимом типа double.

public int processKeyWords(lexem Lex);

Функция обработки ключевых слов и занесения их в таблицу при необходимости.

public int processOperator(lexem Lex);

Функция обработки операторов сравнения и оператора присваивания.

public int processBracket(lexem Lex);

Функция обработки скобок.

public int processOperation(lexem Lex);

Функция обработки арифметических и логических операций.

public int processDelimiter(lexem Lex);

Функция обработки разделителей.

public String getTable(int h);

Возвращает запрашиваемую таблицу в виде html-кода.

public void debugGroupWordFill(lexem Lex);

public void debugGroupWordEndln(lexem Lex);

public String debugGroupWordGet();

Служебные функции для построения отладочного представления программы в виде <индекс_группы, строка_в_таблице>. (т. е. в виде списка лексем).

6.  Разработка формальной грамматики языка

В ходе выполнения работы была разработана формальная грамматика языка, принадлежащая классу LL(1) (значит, по ней может быть построен нисходящий синтаксический акцептор), а также классы и действия для расширения синтаксического акцептора до синтаксического анализатора и получения постфиксной записи (ПФЗ).

Таблицу формальной грамматики ввиду ее сильной громоздкости приведем без встроенных действий перевода в ПФЗ. (рис 2.)

Рис.2 а. Формальная грамматика ч.1

Рис.2 б. Формальная грамматика ч.2

7.  Разработка синтаксического анализатора

7.1 Краткое описание классов расширения синтаксического акцептора для получения ПФЗ

class pfz

{

private Vector<lexem> RPN_array;

private Stack RPN_stack;

public int countIF;

public int countREPEAT;

public int countSELECT;

public pfz();

public int getPrior(lexem Lex);

public void addUseStack(lexem Lex);

public void popStack();

public void addSimple(lexem Lex);

public void addSimpleLexem(StringBuffer Lex);

public void insertElementInEnd(lexem Lex, int index);

public void addSimpleLexemInEndByIndex(StringBuffer Lex, int index);

public String printPfz();

}

private Vector<lexem> RPN_array;

Выходной массив данных.

private Stack RPN_stack;

Необходим для учета приоритета операций.

public int countIF;

public int countREPEAT;

public int countSELECT;

Счетчики для учета вложенности конструкций.

public pfz();

Конструктор класса.

public int getPrior(lexem Lex);

Функция определения приоритета операции.

public void addUseStack(lexem Lex);

Функция добавляет лексему в выходной массив с учетом приоритета операций.

public void popStack();

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

public void addSimple(lexem Lex);

public void addSimpleLexem(StringBuffer Lex);

Добавляют новую запись в выходной массив.

public void insertElementInEnd(lexem Lex, int index);

public void addSimpleLexemInEndByIndex(StringBuffer Lex, int index);

Добавляют новую запись в выходной массив в позицию «размер массива - index».

public String printPfz();

Возвращает массив в виде строки, для распечатки.

7.2 Правила перевода в ПФЗ

Конструкция	Прямая запись	ПФЗ
Определение функции	<тип> <И>(<cписок параметров>){<тело>}	<Иарг1> <тип_арг1>… <ИаргN> <тип_аргN> N <тип> <И> func { <тело> }
Объявление функции	<тип> <И>(<cписок параметров>);	<Иарг1> <тип_арг1>… <ИаргN> <тип_аргN> N <тип> <И> func definition
Объявление переменной	<тип> <И>; <тип> <И>,...,<И>; <тип> <И> = <К>;	<тип> <И> init <тип> <И> init ...<тип> <И> init <тип> <И> init <К> =
Оператор присваивания	<И> = <В>;	<И> <В> =
Условный оператор	when <В> then <ОБ1> [else <ОБ2>];	<В> ! LabelElse1 JmpF <ОБ1> LabelEndIf1 Jmp LabelElse1: <ОБ2> LabelEndIf1:
Оператор переключения	switch <В> { by <К>:<ОБ> …}	SwitchResult1 <В> initSwitch <К> SwitchResult1 != LabelEndCase1_0 JmpF <ОБ> LabelEndCase1_0: …
Оператор цикла*	for<И>from<К1> to<К2> [step <К3>] <ОБ> *если необязательная часть отсутствует, К3=1	<И> <К1> = LabelCycle1: <ОБ> <И> <И> <К3> + = <И> <К2> <= LabelCycle1 JmpF
Вызов функции	<И>(<список факт. параметров> ); <И1> = <И>(<список факт. параметров>);	<арг1 > … <аргN> N <И> call <И1> <арг1 > … <аргN> N <И> call =
Возвращение результата функции	return <В>;	<В> ret

8.  Пример правильной программы

Рассмотрим пример правильной программы на разрабатываемом языке:

long a7x;

boolean b8sd=L_F;

double a7f, a0f;

litera c8s='\c';

void m2proc(long a7xn, doub a7fn) { a7x=a7xn; a7f=a7fn;}

bool t5rue() {return L_T;}

void a9gfdsdfsd(){}

void b8fsd(boolea f8f){;}

long a5func(boole a8fd, litera a9ccc);

doubl m8func(long a2d, long b2d);

void f8func()

{

doub g8d, g7d, g6d;

long a1cd=0;

g6d=.5;

g7d=0.12;

g8d=8.;

m2proc(0,g6d);

a1cd=a5func(b8sd, c8s);

switch a1cd%5

{

by 0:

a0f=m8func(a7x, a1cd);

by 1:

{m2proc(a1cd, g7d); a0f=g8d;}

}

}

long a5func(boole a8fd, litera a9ccc)

{

long n3n=25;

when ((a9ccc >= 'a') && (a9ccc <= 'z' ) || a8fd)

then return n3n%10+1;

return n3n;

}

double m8func(long a2d, long b2d)

{

return a2d/b2d*100;

}

void m0mainfunc()

{

long s7a=0s6;

long i1i, k2k;

doubl d8result;

m2proc(s7a,1.0);

k2k=0;

for i1i from 0 to 10 step 1

{

when ( a7x > i1i || a7x == 7 )

then {a7x=a7x-1; d8result=m8func(i1i, a7x);}

when ( k2k!=0 && k2k < 10)

then d8result=m8func(k2k, a7x);

else

d8result=m8func(k2k, 100);

k2k=k2k+1;

}

}

В постфиксной записи программа будет иметь следующий вид:

long a7x init

bool b8sd init L_F =

double a7f init double a0f init

litera c8s init \c =

a7xn long a7fn double 2 void m2proc func { a7x a7xn = a7f a7fn = }

0 bool t5rue func { L_T ret }

0 void a9gfdsdfsd func { }

f8f bool 1 void b8fsd func { }

a8fd bool a9ccc litera 2 long a5func func definition

a2d long b2d long 2 double m8func func definition

0 void f8func func

{

double g8d init double g7d init double g6d init

long a1cd init 0 =

g6d.5 =

g7d 0.12 =

g8d 8. =

0 g6d 2 m2proc call

a1cd b8sd c8s 2 a5func call =

SwitchResult1 a1cd 5 % initSwitch

0 SwitchResult1 != LabelEndCase1_0 JmpF

a0f a7x a1cd 2 m8func call =

LabelEndCase1_0:

1 SwitchResult1 != LabelEndCase1_1 JmpF

{ a1cd g7d 2 m2proc call a0f g8d = }

LabelEndCase1_1:

}

a8fd bool a9ccc litera 2 long a5func func

{

long n3n init 25 =

a9ccc a >= a9ccc z <= && a8fd || ! LabelElse1 JmpF

n3n 10 % 1 + ret

LabelEndIf1 Jmp

LabelElse1:

LabelEndIf1:

n3n ret

}

a2d long b2d long 2 double m8func func

{

a2d b2d / 100 * ret

}

0 void m0mainfunc func

{

long s7a init 0s6 =

long i1i init long k2k init

double d8result init

s7a 1.0 2 m2proc call

k2k 0 =

i1i 0 =

LabelCycle1:

{

a7x i1i > a7x 7 == || ! LabelElse1 JmpF

{ a7x a7x 1 - = d8result i1i a7x 2 m8func call = }

LabelEndIf1 Jmp

LabelElse1:

LabelEndIf1:

k2k 0 != k2k 10 < && ! LabelElse1 JmpF

d8result k2k a7x 2 m8func call =

LabelEndIf1 Jmp

LabelElse1:

d8result k2k 100 2 m8func call =

LabelEndIf1:

k2k k2k 1 + =

}

i1i i1i 1 + =

i1i 10 <= LabelCycle1 JmpF

}

9.  Результаты работы автомата

Проверим работу автомата на примере правильной программы, приведенной выше.

Последовательность лексем

<-7, 0><1, 0><-6, 1>

<-7, 3><1, 1><-10, 6><8, 0><-6, 1>

<-7, 1><1, 2><-6, 2><1, 3><-6, 1>

<-7, 2><1, 4><-10, 6><10, 1><-6, 1>

<-7, 14><1, 5><-5, 2><-7, 0><1, 6><-6, 2><-7, 1><1, 7><-5, 3><-5, 0><1, 0><-10, 6><1, 6><-6, 1><1, 2><-10, 6><1, 7><-6, 1><-5, 1>

<-7, 3><1, 8><-5, 2><-5, 3><-5, 0><-7, 13><8, 2><-6, 1><-5, 1>

<-7, 14><1, 9><-5, 2><-5, 3><-5, 0><-5, 1>

<-7, 14><1, 10><-5, 2><-7, 3><1, 11><-5, 3><-5, 0><-6, 1><-5, 1>

<-7, 0><1, 12><-5, 2><-7, 3><1, 13><-6, 2><-7, 2><1, 14><-5, 3><-6, 1>

<-7, 1><1, 15><-5, 2><-7, 0><1, 16><-6, 2><-7, 0><1, 17><-5, 3><-6, 1>

<-7, 14><1, 18><-5, 2><-5, 3>

<-5, 0>

<-7, 1><1, 19><-6, 2><1, 20><-6, 2><1, 21><-6, 1>

<-7, 0><1, 22><-10, 6><5, 3><-6, 1>

<1, 21><-10, 6><6, 4><-6, 1>

<1, 20><-10, 6><6, 5><-6, 1>

<1, 19><-10, 6><6, 6><-6, 1>

<1, 5><-5, 2><5, 3><-6, 2><1, 21><-5, 3><-6, 1>

<1, 22><-10, 6><1, 12><-5, 2><1, 1><-6, 2><1, 4><-5, 3><-6, 1>

<-7, 7><1, 22><2, 4><5, 7>

<-5, 0>

<-7, 8><5, 3><-6, 0>

<1, 3><-10, 6><1, 15><-5, 2><1, 0><-6, 2><1, 22><-5, 3><-6, 1>

<-7, 8><5, 8><-6, 0>

<-5, 0><1, 5><-5, 2><1, 22><-6, 2><1, 20><-5, 3><-6, 1><1, 3><-10, 6><1, 19><-6, 1><-5, 1>

<-5, 1>

<-5, 1>

<-7, 0><1, 12><-5, 2><-7, 3><1, 13><-6, 2><-7, 2><1, 14><-5, 3>

<-5, 0>

<-7, 0><1, 23><-10, 6><5, 9><-6, 1>

<-7, 4><-5, 2><-5, 2><1, 14><4, 4><9, 10><-5, 3><3, 5><-5, 2><1, 14><4, 2><9, 11><-5, 3><3, 6><1, 13><-5, 3>

<-7, 5><-7, 13><1, 23><2, 4><5, 12><2, 1><5, 8><-6, 1>

<-7, 13><1, 23><-6, 1>

<-5, 1>

<-7, 1><1, 15><-5, 2><-7, 0><1, 16><-6, 2><-7, 0><1, 17><-5, 3>

<-5, 0>

<-7, 13><1, 16><2, 3><1, 17><2, 2><5, 13><-6, 1>

<-5, 1>

<-7, 14><1, 24><-5, 2><-5, 3>

<-5, 0>

<-7, 0><1, 25><-10, 6><7, 14><-6, 1>

<-7, 0><1, 26><-6, 2><1, 27><-6, 1>

<-7, 1><1, 28><-6, 1>

<1, 5><-5, 2><1, 25><-6, 2><6, 15><-5, 3><-6, 1>

<1, 27><-10, 6><5, 3><-6, 1>

<-7, 9><1, 26><-7, 10><5, 3><-7, 11><5, 12><-7, 12><5, 8>

<-5, 0>

<-7, 4><-5, 2><1, 0><4, 3><1, 26><3, 6><1, 0><4, 0><5, 16><-5, 3>

<-7, 5><-5, 0><1, 0><-10, 6><1, 0><2, 0><5, 8><-6, 1><1, 28><-10, 6><1, 15><-5, 2><1, 26><-6, 2><1, 0><-5, 3><-6, 1><-5, 1>

<-7, 4><-5, 2><1, 27><4, 5><5, 3><3, 5><1, 27><4, 1><5, 12><-5, 3>

<-7, 5><1, 28><-10, 6><1, 15><-5, 2><1, 27><-6, 2><1, 0><-5, 3><-6, 1>

<-7, 6>

<1, 28><-10, 6><1, 15><-5, 2><1, 27><-6, 2><5, 13><-5, 3><-6, 1>

<1, 27><-10, 6><1, 27><2, 1><5, 8><-6, 1>

<-5, 1>

<-5, 1>

ПФЗ

long a7x init bool b8sd init L_F = double a7f init double a0f init litera c8s init \c = a7xn long a7fn double 2 void m2proc func { a7x a7xn = a7f a7fn = } 0 bool t5rue func { L_T ret } 0 void a9gfdsdfsd func { } f8f bool 1 void b8fsd func { } a8fd bool a9ccc litera 2 long a5func func definition a2d long b2d long 2 double m8func func definition 0 void f8func func { double g8d init double g7d init double g6d init long a1cd init 0 = g6d.5 = g7d 0.12 = g8d 8. = 0 g6d 2 m2proc call a1cd b8sd c8s 2 a5func call = SwitchResult1 a1cd 5 % initSwitch 0 SwitchResult1 != LabelEndCase1_0 JmpF a0f a7x a1cd 2 m8func call = LabelEndCase1_0: 1 SwitchResult1 != LabelEndCase1_1 JmpF { a1cd g7d 2 m2proc call a0f g8d = } LabelEndCase1_1: } a8fd bool a9ccc litera 2 long a5func func { long n3n init 25 = a9ccc a >= a9ccc z <= && a8fd || ! LabelElse1 JmpF n3n 10 % 1 + ret LabelEndIf1 Jmp LabelElse1: LabelEndIf1: n3n ret } a2d long b2d long 2 double m8func func { a2d b2d / 100 * ret } 0 void m0mainfunc func { long s7a init 0s6 = long i1i init long k2k init double d8result init s7a 1.0 2 m2proc call k2k 0 = i1i 0 = LabelCycle1: { a7x i1i > a7x 7 == || ! LabelElse1 JmpF { a7x a7x 1 - = d8result i1i a7x 2 m8func call = } LabelEndIf1 Jmp LabelElse1: LabelEndIf1: k2k 0 != k2k 10 < && ! LabelElse1 JmpF d8result k2k a7x 2 m8func call = LabelEndIf1 Jmp LabelElse1: d8result k2k 100 2 m8func call = LabelEndIf1: k2k k2k 1 + = } i1i i1i 1 + = i1i 10 <= LabelCycle1 JmpF }

10.  Выводы

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

Разработана формальная грамматика языка класса LL(1), определяющая синтаксис заданного языка, разработано расширение синтаксического акцептора для преобразования последовательности лексем в постфиксную запись.

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

11.  Использованная литература

1.  Малявко формальных языков / Учебное пособие, Ч.1,2,3. – Новосибирск: Изд-во НГТУ, .

2.  Малявко программное обеспечение ЭВМ. Трансляторы. / Методические указания. – Новосибирск: Изд-во НГТУ, 2006.