Конвертор на языке Си для перевода программ на языке Паскаль в текст программы на языке Си

Государственное образовательное учреждение высшего профессионального образования

«Северо-Кавказский государственный технический университет»

Курсовой проект

по дисциплине «Программирование на языке высокого уровня»

Вариант 6

Исполнитель:

Гусев А.Д.

Группа АСОУ-091

Руководитель:

Братченко Н.Ю.

Ставрополь, 2011

1. Постановка задачи

2. Внешняя спецификация

3. Описание алгоритма

4. Описание функций и операторов

4.1 Назначение подпрограмм

4.2 Константы

4.3 Переменные

4.4 Таблицы идентификаций

5. Код программы

6. Тестирование Вывод Список используемой литературы

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

1. Постановка задачи

Разработать конвертор на языке Си для перевода программ на языке Паскаль в текст программы на языке Си.

Согласно варианту следует перевести следующие конструкции:

— real;

— goto;

— label;

— read, readln;

— арифметическое выражение (рис. 1.1);

— логическое выражение (рис. 1.2).

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

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

Арифметическое выражение Ae3:

Рисунок 1.1 — Разбор арифметического выражения

Логическое выражение Le2:

Рисунок 1.2 — Разбор логического выражения

2. Внешняя спецификация

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

1. Об успешности операции.

2. Сообщение об ошибке.

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

При втором варианте развития событий на экран будет выведено сообщение об ошибке ввода. То же самое предусмотрено и для исходящего файла.

Сообщение об ошибке для открытия файла:

Ошибка! Невозможно открыть файл! Проверьте правильность пути и имя файла.

Сообщение об ошибке для создания файла:

Ошибка! Невозможно создать файл! Возможно использование данного имени запрещенно или указан неверный путь.

Требование к аппаратному и системному обеспечению:

— Операционная система: DOS, ОС семейства Windows.

— Процессор с тактовой частотой неменее 300 Гц

— Оперативная память: 16 Мб и выше.

— клавиатура

3. Описание алгоритма

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

Работа лексического анализатора состоит в том, чтобы сгруппировать определенные терминальные символы в единые синтаксические объекты, называемые лексемами. Лексема — это цепочка терминальных символов, с которой мы связываем лексическую структуру, состоящую из пары вида (тип* лексемы, некоторые данные). Первой компонентой пары является синтаксическая категория, такая, как «константа» или «идентификатор», а вторая—указатель: в ней указывается адрес ячейки, хранящей информацию об этой конкретной лексеме. Таким образом, лексический анализатор—это транслятор, входом которого служит цепочка символов, представляющая исходную программу, а выходом — последовательность лексем. ходом лексического анализатора является цепочка лексем. Эта цепочка образует вход синтаксического анализатора, исследующего только первые компоненты лексем — их типы.

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

4. Описание функций и операторов

4.1 Назначение подпрограмм

конвертор алгоритм перевод паскаль константа

put_stroku — Процедура записи строки в выходной буфер.

put_simvol — Процедура записи символа в выходной буфер.

skip_space — Процедура пропуска пробела.

inc_otstuр — Процедура увелечения отступа.

dec_otstup — Процедура уменьшения отступа.

put_otstup — Процедура вывода отступа.

Open_Text — Функция открывающая файл.

Put_Text — Функция вывода обработанного текста.

func_Error — Функция обработки ошибок. Заносит данные о количестве ошибок в специальную переменную.

func_Comment, func_CommentEnd — Функция проверки строки на наличие комментария, и обработка его, если это так.

func_begin — Функция обработки блока операторов, запускается после того как во входном файле встречено слово begin.

func_Real_Bool_Label — Функция обработки переменных. Начинает обработку после слова var.

func_var — Функция описывающая блок переменных.

func_vardescr — Функция обрабатывающая блок описания переменных.

read_slovo — Функция посимвольно просматривает файл и определяет к чему можно отнести данный символ.

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

func_gotoФункция обработки конструкции goto в тексте. Проверяет слово после оператора goto в соответствии с введенными ранее в блоке операторов переменной. Если такой переменной нет, то выдает сообщение об ошибке.

func_read — Функция обработки оператора read и readln.

ae — Функция обработки арифметического выражения.

func_le — Функция описания логического выражения.

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

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

f_KS — Функция обрабатывает массив с ключевыми словами. Если слово было найдено, то присваивает ему номер. Если конструкция неопределена, то возвращает 0, что означает, что встреченное слово не является ключевым словом.

4.2 Константы

KS_kol — число, обозначающее размер словаря ключевых слов.

max_dlin — число, обозначающее максимальное количество символов в программе.

4.3 Переменные

in_str[max_dlin]- строка, в которую записывается входящий файл

out_str[max_dlin]- строка, в которую записывается выходящий файл

in_len — длина входного файла.

out_len — длина выходного файла.

in_pos — позиция во входной строке

kol_oper₁ — количество операторов во входящем файле

kol_oper₂ — количество операторов в выходящем файле

k_er — количество ошибок.

s_dlin — длина слова

s_type — тип слова

otstup — длина отступа

in_str[max_dlin] - входной файл.

out_str[max_dlin]; - выходной файл.

*lvars — ссылка на конструкцию с локальными переменными.

*vars — ссылка на структуру с глобальными переменными.

4.3 Таблицы идентификаций

Таблица 1 — Таблица номеров идентификации для ключевых слов

Таблица 2 — Таблица идентификаторов типов переменных

Таблица 3 — Таблица типов слов

5. Код программы

#include

#include

#include

#include

#include

FILE *in_file, *out_file;

const int max_dlin = 10 000;

const int KS_kol = 13;

// массив ключевых слов

char * KS_mas[KS_kol] =

{

" begin", «end», «var», «real» ,

" boolean", «false», «true» ,

" read", «readln», «and» ,

" or", «label», «goto»

};

#define ks_begin 1

#define ks_end 2

#define ks_var 3

#define ks_real 4

#define ks_boolean 5

#define ks_false 6

#define ks_true 7

#define ks_read 8

#define ks_readln 9

#define ks_and 10

#define ks_or 11

#define ks_label 12

#define ks_goto 13

#define type_Real 1

#define type_Bool 2

#define type_Label 3

#define s_error 0

#define s_space 1

#define s_str 2

#define s_numb 3

#define s_char 4

typedef struct var{

char s[64];

int tp;

var * next;

};

var *vars, *lvars;

char in_str[max_dlin], out_str[max_dlin];

int in_len, out_len, in_pos;

int kol_err₁, kol_err₂, k_er;

int s_dlin;

int s_type;

int s_numf;

int otstup;

//добавить переменную в список

int dob_var (int gl){

var *np, *p;

if (gl) p = vars; else p = lvars;

while (p) {

if (strlen (p->s)==s_dlin&&

!memcmp (p->s,&in_str[in_pos], s_dlin)) return 0;

p = p->next;

}

np = new var;

memcpy (np->s,&in_str[in_pos], s_dlin);

np->s[s_dlin]=0;

np->tp = -1;

if (gl) {

np->next = vars;

vars = np;

} else {

np->next = lvars;

lvars = np;

}

return 1;

}

void set_type (int gl, int type){

var *p;

if (gl) p = vars; else p = lvars;

while (p) {

if (p->tp==-1) p->tp = type;

p = p->next;

}

}

// получение типа переменной

int type_var (){

var * p;

p = lvars;

while (p) {

if (strlen (p->s)==s_dlin&&

!memcmp (p->s,&in_str[in_pos], s_dlin)) return p->tp;

p = p->next;

}

p = vars;

while (p) {

if (strlen (p->s)==s_dlin&&

!memcmp (p->s,&in_str[in_pos], s_dlin)) return p->tp;

p = p->next;

}

return 0;

}

// освобождение списка переменных

void osv_vars (int gl){

var *p, *pp;

p = lvars;

while (p) {

pp = p;

p = p->next;

delete pp;

}

lvars = NULL;

if (gl) {

p = vars;

while (p) {

pp = p;

p = p->next;

delete pp;

}

vars = NULL;

}

}

// чтение слова

int read_slovo ()

{

int st = 0;

char c;

s_dlin = 0;

while (s_dlin+in_pos

c = in_str[in_pos+s_dlin];

switch (st){

case 0:

if (c==' ' || c=='t' || c=='n') st = 1;

else

if ((c>='A' && c<='Z')||(c>='a' && c<='z')) st = 2;

else

if (c>='0' && c<='9') st = 3;

else

if (

c=='.' || c<=',' || c >=':' || c<=';' ||

c=='+' || c<='-' || c>='*' || c<='/' ||

c=='''

)

{ s_dlin = 1; return s_type = s_char; }

else { s_dlin = 0; return s_type = s_error; }

break;

case 1:

if (c==' ' || c=='t' || c=='n') s_dlin++;

else return s_type = s_space;

break;

case 2:

if (

(c>='A' && c<='Z') ||

(c>='a' && c<='z') ||

(c>='0' && c<='9') ||

c=='_'

) s_dlin++;

else return s_type = s_str;

break;

case 3:

if (c>='0' && c<='9') s_dlin++; else

if (c=='.'&& in_str[in_pos+s_dlin+1]≠'.') {

s_dlin++;

st = 5;

}

else{

s_numf = 0;

return s_type = s_numb;

}

break;

case 5:

if (c>='0' && c<='9') s_dlin++; else {

s_numf = 1;

return s_type = s_numb;

}

}

}

s_dlin = 0;

return 0;

}

//запись строки в выходной буфер

void put_stroku (char * s){

int l = strlen (s);

memcpy (&out_str[out_len], s, l);

out_len += l;

}

int scmp (char * m, char * s, int n){

int l = strlen (s);

if (n>l) l = n;

return memicmp (m, s, l);

}

//запись символа в выходной буфер

void put_simvol (char c){

out_str[out_len] = c;

out_len++;

}

void f_copy (){

memcpy (&out_str[out_len],&in_str[in_pos], s_dlin);

in_pos += s_dlin;

out_len += s_dlin;

}

int wequ (char * s){

return (!scmp (&in_str[in_pos], s, s_dlin));

}

//процедура пропуска пробела

void skip_space (){

in_pos += s_dlin;

}

//получение слов

int read_Slova (){

read_slovo ();

if (s_type==s_space) {

skip_space ();

read_slovo ();

}

return s_type;

}

//увеличение отступа

void inc_otstup ()

{

otstup += 2;

}

//уменьшение отступа

void dec_otstup ()

{

otstup -= 2;

}

//вывод отступа

void put_otstup ()

{

for (int i=0; i

}

//открытие файла

int Open_Text (char * s1)

{

if ((in_file = fopen (s1, «rt»)) == NULL){

return 0;

}

fseek (in_file, 0, SEEK_END);

in_len = ftell (in_file);

fseek (in_file, 0, SEEK_SET);

if (in_len>max_dlin) in_len = max_dlin;

in_len = fread (in_str, 1, in_len, in_file);

in_str[in_len] = 0;

in_pos = 0;

out_len = 0;

return 1;

}

//вывод обработанного текста

int Put_Text (char * s2)

{

if ((out_file = fopen (s2, «wt»)) == NULL){

return 0;

}

fwrite (out_str, out_len, 1, out_file);

return 1;

}

//вывод ошибочного оператора

void func_Error ()

{

put_stroku («< Ошибка! >»);

int k;

put_simvol ('<');

while (1){

read_Slova ();

if (in_str[in_pos]== ';' || in_pos>= in_len) {

f_copy ();

break;

};

f_copy ();

}

put_simvol ('>');

k_er++;

}

//проверка на комментарий

int func_Comment (){

return (in_str[in_pos]=='

//проверка на закрытие комментария

void func_CommentEnd (){

if (in_str[in_pos]=='{'){

out_str[out_len] = '/';

out_str[out_len+1] = '*';

in_pos++;

out_len += 2;

while (in_str[in_pos]≠'}' && in_pos

if (in_pos>=in_len) return;

out_str[out_len] = in_str[in_pos];

in_pos++;

out_len++;

}

out_str[out_len] = '*';

out_str[out_len+1] = '/';

in_pos++;

out_len += 2;

}

else{

out_str[out_len] = '/';

out_str[out_len+1] = '*';

in_pos += 2;

out_len += 2;

while (!(in_str[in_pos]=='*' && in_str[in_pos+1]==')')

&& in_pos

if (in_pos>=in_len) return;

out_str[out_len] = in_str[in_pos];

in_pos++;

out_len++;

}

out_str[out_len] = '*';

out_str[out_len+1] = '/';

in_pos += 2;

out_len += 2;

}

put_simvol ('n');

}

// проверка на ключевое слово

int f_KS (){

for (int i=0; i

if (!scmp (&in_str[in_pos], KS_mas[i], s_dlin))

return i+1;

}

return 0;

}

//функция обработки label

int func_label (int gl)

{

skip_space ();

while (1){

if (s_type≠s_str||f_KS ()|| gl>0&&type_var ()) return 0;

read_Slova ();

dob_var (gl);

set_type (gl, type_Label);

skip_space ();

if (in_str[in_pos]==','){

in_pos++;

} else break;

};

if (in_str[in_pos]≠';') return 0;

in_pos++;

return 1;

}

//функция объявления переменных

int func_Real_Bool_Label (int svar, int gl){

char s[256];

int label;

int sp = 0;

read_Slova ();

while (1){

if (s_type≠s_str||f_KS ()|| gl>0&&type_var ()) return 0;

dob_var (gl);

if (svar) {

s[sp] = '&';

s[sp+1] = ' ';

sp += 2;

}

memcpy (&s[sp],&in_str[in_pos], s_dlin);

in_pos += s_dlin;

sp += s_dlin;

read_Slova ();

if (in_str[in_pos]==','){

s[sp]=',';

in_pos++;

sp++;

} else break;

read_Slova ();

}

if (in_str[in_pos]==':'){

in_pos++;

read_Slova ();

if (s_type≠s_str) return 0;

if (!scmp (&in_str[in_pos]," boolean", s_dlin)){

set_type (gl, type_Bool);

put_stroku («int «);

skip_space ();

memcpy (&out_str[out_len],&s[0], sp);

out_len += sp;

}

else

if (!scmp (&in_str[in_pos]," real", s_dlin)){

set_type (gl, type_Real);

put_stroku («float «);

skip_space ();

memcpy (&out_str[out_len],&s[0], sp);

out_len += sp;

}

}

else if (label==ks_label) return 1;

else return 0;

return 1;

}

//обработка описания блока переменных

int func_var (int gl){

in_pos += s_dlin;

read_Slova ();

do{

kol_err₁++;

if (func_Comment ()){

func_CommentEnd ();

kol_err₂++;

continue;

}

put_otstup ();

if (f_KS ()==ks_label)

{func_label (gl);}

if (!func_Real_Bool_Label (0,gl)) {func_Error ();}

else kol_err₂++;

read_Slova ();

if (in_str[in_pos]≠';')

return 0;

skip_space ();

put_stroku («;n»);

read_Slova ();

if (s_type≠s_str || f_KS ())

return 1;

}while (1);

}

//обработка блока описания переменных

int func_vardescr (){

in_pos += s_dlin;

int k, svar;

read_Slova ();

do{

k = f_KS ();

svar = k==ks_var;

if (svar) {

skip_space ();

read_Slova ();

}

if (!func_Real_Bool_Label (svar, 0)) return 0;

read_Slova ();

if (in_str[in_pos]≠';') return 1;

skip_space ();

put_stroku («, «);

read_Slova ();

k= f_KS ();

if (s_type≠s_str || k&&k≠ks_var) return 0;

}while (1);

}

//функция обработки goto

int func_goto ()

{

skip_space ();

put_otstup ();

put_stroku («goto «);

read_Slova ();

f_copy ();

if (in_str[in_pos]≠';') return 0;

put_stroku («;n»);

in_pos++;

return 1;

}

//функция обработки read

int func_read (int ln){

char s[256];

int sp;

int t;

skip_space ();

put_otstup ();

put_stroku («scanf»);

read_Slova ();

if (in_str[in_pos]≠'(') return 0;

in_pos++;

put_stroku («(» «);

sp=0;

while (1) {

read_Slova ();

if (s_type≠s_str) return 0;

t = type_var ();

if (t==type_Real) put_stroku («%f»);

else return 0;

s[sp] = '&';

sp += s_dlin;

memcpy (&s[sp],&in_str[in_pos], s_dlin);

in_pos += s_dlin;

sp += s_dlin;

read_Slova ();

if (in_str[in_pos]≠',') break;

s[sp] = in_str[in_pos];

in_pos++;

sp++;

}

put_stroku (««,»);

memcpy (&out_str[out_len], s, sp);

out_len += sp;

read_Slova ();

if (in_str[in_pos]≠')') return 0;

in_pos++;

put_simvol (')');

read_Slova ();

if (in_str[in_pos]≠';') return 0;

in_pos++;

if (ln) put_stroku («; printf („\n“);n»);

else put_stroku («;n»);

return 1;

}

int func_ae () {

read_Slova ();

if (in_str[in_pos]=='+'){

f_copy ();

}

else

if (in_str[in_pos]=='-'){

f_copy ();

}

while (1)

}

//обработка арифметического выражения

int ae (){

char c, c1;

if (!func_ae ()) return 0;

read_Slova ();

c = in_str[in_pos];

c1 = in_str[in_pos+1];

if (c=='<'&&c1=='>') {

in_pos += 2;

put_stroku («≠»);

}

else

if (c=='=') {

in_pos++;

put_stroku («==»);

}

else

if (c=='>'||c=='<') {

if (c1=='='){

in_pos += 2;

}

else f_copy ();

}

read_Slova ();

if (!func_ae ()) return 0;

return 1;

}

//обработка логического выражения

int func_le () {

int k;

char c, c1;

int arifm, ip, op;

while (1){

read_Slova ();

k = f_KS ();

int ip, op;

ip = in_pos;

op = out_len;

arifm = 0;

if (in_str[in_pos]=='+'||

in_str[in_pos]=='('||

in_str[in_pos]=='-'||

s_type==s_str&&!f_KS () ||

s_type==s_numb)

arifm = ae ();

if (!arifm){

in_pos = ip;

out_len = op;

read_Slova ();

k = f_KS ();

if (s_type==s_str&&k==ks_true){

skip_space ();

put_simvol ('1');

}

else

if (s_type==s_str&&k==ks_false) {

skip_space ();

put_simvol ('0');

}

else

if (s_type==s_str&&type_var ()==type_Bool) f_copy (); else

if (in_str[in_pos]=='('){

f_copy ();

if (!func_le ()) return 0;

read_Slova ();

if (in_str[in_pos]≠')') return 0;

in_pos++;

put_simvol (')');

}

else return 0;

}

read_Slova ();

k = f_KS ();

if (k==ks_or) put_stroku («||»); else

if (k==ks_and) put_stroku («&&»);

else return 1;

skip_space ();

}

}

// функция обработки присваивания

int func_asign (){

int type = type_var ();

if (!(type==type_Bool||type==type_Real||type==type_Label)) return 0;

put_otstup ();

f_copy ();

read_Slova ();

if ((type==type_Label)&&in_str[in_pos]==':')

{

f_copy ();

in_pos++;

put_simvol ('n');

return 1;

}

if (in_str[in_pos]≠':'||in_str[in_pos+1]≠'=')

return 0;

put_simvol ('=');

in_pos +=2;

if (type==type_Bool) {

if (!func_le ()) return 0;

}

else

if (!func_ae ()) return 0;

read_Slova ();

if (in_str[in_pos]≠';') return 0;

f_copy ();

put_simvol ('n');

return 1;

}

//функция обработки основной программы

int func_begin (int gl){

int rep_n = 0;

if (gl≠3) skip_space ();

if (gl==1) put_stroku («nnvoid main ()n»);

if ((gl≠2)||(gl≠3)) {

put_otstup ();

put_stroku («{n»);

inc_otstup ();

}

int b;

do{

b = 1;

read_Slova ();

if (func_Comment ()){

func_CommentEnd ();

continue;

}

switch (f_KS ()){

case ks_begin:

kol_err₁++;

if (!func_begin (0)) return 0;

kol_err₂++;

break;

case ks_read:

kol_err₁++;

if (!func_read (0)) return 0;

kol_err₂++;

break;

case ks_readln:

kol_err₁++;

if (!func_read (1)) return 0;

kol_err₂++;

break;

case ks_goto:

kol_err₁++;

if (!func_goto ()) return 0;

break;

case ks_end:

kol_err₁++;

if (gl == 3) return 3;

skip_space ();

dec_otstup ();

put_otstup ();

put_stroku («}n»);

read_Slova ();

if (gl==1&&in_str[in_pos]=='.' ||

gl≠1&&in_str[in_pos]==';'){

skip_space ();

kol_err₂++;

return 1;

}

else

{

skip_space ();

return 0;

}

case 0:

if (!func_asign ()) return 0;

break;

default:

return 0;

}

} while (b);

return 1;

}

//функция преобразование текста

int Translate ()

{

int b;

int k;

kol_err₁ = kol_err₂ = 0;

put_stroku («#include nn»);

do{

b = 1;

read_Slova ();

k = f_KS ();

if (k==ks_var){

kol_err₁++;

if (!func_var (1)) {

func_Error ();

}

else kol_err₂++; }

else

if (k==ks_label)

{

kol_err₁++;

if (!func_label (1)){ func_Error ();}

}

else

if (k==ks_begin){

if (!func_begin (1)) {

func_Error ();

}

b = 0;

}

else

if (func_Comment ()) func_CommentEnd ();

else {

kol_err₁++;

func_Error ();

};

} while (b==1);

if (in_str[in_pos]≠'.') return 0;

in_pos++;

return 1;

}

void main ()

{

int pr=1;

setlocale (LC_ALL," Russian");

char s[128];

printf («Введите имя входного файла: «);

scanf («%s», s);

if (!Open_Text (s))

{

printf («nОшибка! Невозможно открыть файл! nПроверьте правильность пути и имя файла.»);

}

vars = NULL;

lvars = NULL;

Translate ();

osv_vars (1);

printf («nВведите имя выходного файла:»);

scanf («%s», s);

if (!Put_Text (s))

{

printf («nОшибка! Невозможно создать файл! nВозможно использование данного имени запрещенно или указан неверный путь.»);

pr=0;

}

if (pr==1) {

printf («nКоличество операторов в исходном файле: %d», kol_err₁);

printf («nКоличество операторов в полученном файле: %d», kol_err₂);

printf («nКоличество ошибочных операторов которые не были обработаны: %d», k_er);

printf («nnРезультат хранится в %s», s);

}

fclose (in_file);

fclose (out_file);

while (!kbhit ()) ;

}

6. Тестирование

Тест 1

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

Рисунок 6.1 — Вид консоли при обработке текста без ошибочной конструкции

Текст test. pas:

(* comment1 *)

label k;

var

r, n, m: real;

begin

read®;

goto k;

{ comment2 }

r:=m+n;

k: readln®;

end.

Текст test. cpp:

#include

/* comment1 */

float r, n, m;

void main ()

{

scanf («%f» ,&r);

goto k;

/* comment2 */

r=m+n;

k:

scanf («%f» ,&r); printf («n»);

}

Тест 2

Введем файл с текстом содержащую ошибочную конструкцию.

Рисунок 6.2 — Вид консоли при обработке текста с ошибочной конструкцией

Текст test2. pas:

(* comment1 *)

label k;

var

r, n, m: real;

begin

read®;

writeln ('privet');

goto k;

{ comment2 }

r:=m+n;

k: readln®;

end.

Текст test2. cpp:

#include

/* comment1 */

float r, n, m;

void main ()

{

scanf («%f» ,&r);

< Ошибка! >

Тест 3

Укажем путь в несуществующий файл.

Рисунок 6.3 — Вид консоли при вводе несуществующего файла

Тест 4

Присвоим выходящему файлу запрещенное имя.

Рисунок 6.4 — Вид консоли при неправильном вводе имени выходящего файла

Комментарий к полученным результатам

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

Вывод

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

Список используемой литературы

1. Компиляторы: принципы, технологии и инструменты. — М: Вильямс, — А. Ахо (2001)

2. Си, Язык программирования.- М: Вильямс. Б. Керниган, Д. Р. (2009).

3. Язык программирования Си. Практический курс. — Поляков К. Ю. (2009)

4. Алгоритмические языки и программирование — М.: МГГУ, Зайцева, Л. В. (1996).