Конструирование моделей лексического и синтаксического анализа

Размещено на http://www.allbest.ru/

МИНОБРНАУКИ РОССИИ

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

«ЧЕРЕПОВЕЦКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ»

Институт (факультет) Информационных технологий

Кафедра Математического и программного обеспечения ЭВМ

КУРСОВАЯ РАБОТА

по дисциплине Теория автоматов и формальных языков

на тему Конструирование моделей лексического и синтаксического анализа

Выполнил студент группы

ИСб-00-21оп

Дьяков Максим Сергеевич

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

Ганичева Оксана Георгиевна

Череповец, 2017год



Аннотация

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

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



Введение

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

Лексема - это структурная единица языка, которая состоит из элементарных символов языка и не содержит в своем составе других структурных единиц языка.

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

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

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

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

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



Изучение и описание предметной области

Лексический анализатор - это часть компилятора, которая читает исходную программу и выделяет в ее тексте лексемы.

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

Основные функции:

1)исключение из текста исходной программы комментариев

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

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

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

Анализатор должен выполнить следующие действия:

- четко определить границы лексемы, которые в исходном тексте явно не заданы

- выполнить действия для сохранения информации об обнаруженной лексеме

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

Лексические анализаторы действуют по следующему принципу:

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

2)если символ не может быть отнесен к лексемам, то он является границей лексемы и началом следующей.

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

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

I. Разработайте грамматику для моделирования работы компилятора согласно своему варианту. Для синтаксического анализа - КС-грамматику, для лексического анализа - регулярную грамматику.

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

III. Постройте КС-грамматику, описывающую синтаксис инструкции языка программирования для оператора операторов for и do-while.

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

V. Путем эквивалентных преобразований получите приведенную грамматику.

Примечание 1:

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

2. В задании I заданную грамматику представить в виде: правил КС-грамматики, в форме БНФ и регулярной грамматики.

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

Примечание 2:

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

2. В ходе работы ЛА должны удаляться лишние пробелы и комментарии

Описание конечного автомата

other-любая цифра и буква английского алфавита

б- английская буква (любого регистра), ц- цифра



M=(Q, V, R, q0, P) ), где:

Q - конечное множество состояний автомата; V - конечное множество допустимых входных символов; P - функция переходов автомата; S₀ - начальное состояние автомата; R - непустое множество конечных состояний автомата

V={a..z, A..Z, 0..9, -, +, /, *, =, ;,:, , , , #, &, !, (, ), {, }, <, >, [, ], |}

Q={S₀, S₁, ..S₈₉}

R={ S_3, S_8, S_15, S_19, S_24, S_30, S_34, S_39, S₄₄S_47, S_50, S_54, S_60, S_65, S_70, S_71, S_76, S_78, S_82, S_85, S₈₉} P:

(S0, i)>S1	(S1, n)>S2	(S7, e)>S8	(S13, other)>S85	(S21, o)>S22	(S27, other)>S85
(S0, v)>S86	(S1, o)>S9	(S7, other)>S85	(S14, m)>S15	(S21, other)>S85	(S28, l)>S29
(S0, s)>S48	(S1, other)>S85	(S8, other)>S85	(S15, other)>S85	(S22, a)>S23	(S28, other)>S85
(S0, f)>S20	(S2, t)>S3	(S9, s)>S10	(S16, a)>S17	(S22, other)>S85	(S29, e)>S30
(S0, n)>S66	(S2, c)>S4	(S9, other)>S85	(S16, other)>S85	(S23, t)>S24	(S29, other)>S85
(S0, u)>S61	(S2, other)>S85	(S10, t)>S11	(S17, i)>S18	(S23, other)>S85	(S30, other)>S85
(S0, r)>S55	(S3, other)>S85	(S10, other)>S85	(S17, other)>S85	(S24, other)>S85	(S31, h)>S32
(S0, w)>S40	(S4, l)>S5	(S11, r)>S12	(S18, n)>S19	(S25, o)>S26	(S31, i)>S35
(S0, d)>S25	(S4, other)>S85	(S11, other)>S85	(S19, other)>S85	(S25, other)>S85	(S31, o)>S37
(S0, f)>S20	(S5, u)>S6	(S12, e)>S13	(S20, l)>S21	(S26, u)>S27	(S31, other)>S85
(S0, m)>S16	(S5, other)>S85	(S12, other)>S85	(S20, f)>S46	(S26, other)>S85	(S32, a)>S33
(S0, c)>S31	(S6, d)>S7	(S13, a)>S14	(S20, other)>S85	(S27, b)>S28	(S32, other)>S85
(S0, б)>S85	(S6, other)>S85	(S0, .)>S70	(S72, =)>S78	(S75, ц)>S76	(S80, =)>S82
(S33, r)>S34	(S52, s)>S53	(S0, , )>S70	(S72, -)>S78	(S76, ц)>S76	(S85, other)>S85
(S33, other)>S85	(S52, other)>S85	(S0, ;)>S70	(S71, ц)>S71	(S77, +)>S78	(S86, o)>S87
(S34, other)>S85	(S53, e)>S54	(S0,:)>S70	(S71, .)>S73	(S77, =)>S78	(S86, other)>S85
(S35, n)>S36	(S53, other)>S85	(S0, ')>S70	(S71, E)>S74	(S83, <)>S78	(S87, i)>S88
(S35, other)>S85	(S54, other)>S85	(S0, '')>S70	(S71, e)>S74	(S84, >)>S78	(S87, other)>S85
(S36, other)>S85	(S55, e)>S56	(S0, ()>S70	(S73, ц)>S76	(S83, =)>S82	(S88, d)>S89
(S32, other)>S85	(S55, other)>S85	(S0, ))>S70	(S74, +)>S75	(S84, =)>S82	(S88, other)>S85
(S37, u)>S38	(S56, t)>S57	(S0, [)>S70	(S74, -)>S75	(S79, =)>S82	(S89, other)>S85
(S37, other)>S85	(S56, other)>S85	(S0, ])>S70	(S43, other)>S85	(S63, n)>S64	(S0, *)>S77
(S38, t)>S39	(S57, u)>S85	(S0, {)>S70	(S44, other)>S85	(S63, other)>S85	(S0, +)>S78
(S38, other)>S85	(S57, other)>S85	(S0, })>S70	(S46, r)>S47	(S64, g)>S65	(S0, +)>S77
(S32, other)>S85	(S58, r)>S59	(S0, ц)>S71	(S46, other)>S85	(S64, other)>S85	(S0, -)>S78
(S39, other)>S85	(S58, other)>S85	(S0, -)>S72	(S47, other)>S85	(S65, other)>S85	(S0, =)>S78
(S40, h)>S41	(S59, n)>S60	(S0, &)>S78	(S48, t)>S49	(S66, a)>S67	(S0, =)>S79
(S40, other)>S85	(S59, other)>S85	(S0, &)>S77	(S48, p)>S51	(S66, other)>S85	(S0, <)>S83
(S41, i)>S42	(S60, other)>S85	(S0, /)>S78	(S48, other)>S85	(S67, m)>S68	(S0, >)>S84
(S41, other)>S85	(S61, s)>S62	(S0, /)>S77	(S49, d)>S50	(S67, other)>S85	(S0, <)>S82
(S42, l)>S43	(S61, other)>S85	(S0, %)>S78	(S49, other)>S85	(S68, e)>S69	(S0, >)>S82
(S42, other)>S85	(S62, i)>S63	(S0, %)>S77	(S51, a)>S52	(S68, other)>S85	(S0, !)>S80
(S45, other)>S85	(S69, s)>S45	(S45, p)>S51	(S51, other)>S85	(S69, other)>S85	(S72, ц)>S71
(S43, e)>S44	(S62, other)>S85	(S0, *)>S78



Регулярная грамматика для лексического анализа

регулярная грамматика -- формальная грамматика типа 3 по иерархии Хомского. Регулярные грамматики определяют в точности все регулярные языки, и поэтому эквивалентны конечным автоматам и регулярным выражениям.

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

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

1. A > a

2. A > aB

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

1. A > a

2. A > Ba

Где заглавные буквы (A, B) обозначают нетерминалы, строчные буквы (a, b) обозначают терминалы

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

Регулярная грамматика по конечному автомату:

G=(N, T, P, S)

N={Q}={S₀, S₁, … S₈₉}

T={V}={a..z, A..Z, 0..9, -, +, /, *, =, ;,:, , , , , &, !, (, ), {, }, <, >, [, ]}

S={q0}={S0}



P:

S0>iS1	S1>nS2	S7>eS8	S13>otherS85	(S21, o)>oS22	S27>otherS85
S0>vS86	S1>oS9	S7>otherS85	S14>mS15	S21>otherS85	S28>lS29
S0>sS48	S1>otherS85	S8>otherS85	S15>otherS85	S22>aS23	S28>otherS85
S0>fS20	S2>tS3	S9>sS10	S16>aS17	S22>otherS85	S29>eS30
S0>nS66	S2>cS4	S9>otherS85	S16>otherS85	S23>tS24	S29>otherS85
S0>uS61	S2>otherS85	S10>tS11	S17>iS18	S23>otherS85	S30>otherS85
S0>rS55	S3>otherS85	S10>otherS85	S17>otherS85	S24> otherS85	S31>hS32
S0>wS40	S4>lS5	S11>rS12	S18>nS19	S25>oS26	S31>iS35
S0>dS25	S4> otherS85	S11> otherS85	S19>otherS85	S25>otherS85	S31>oS37
S0>fS20	S5>uS6	S12>eS13	S20>lS21	S26>uS27	S31>otherS85
S0>mS16	S5>otherS85	S12>otherS85	S20>fS46	S26>otherS85	S32>aS33
S0>cS31	S6>dS7	S13>aS14	S20> otherS85	S27>bS28	S32>otherS85
S0>бS85	S6>otherS85	S0>.S70	S72>=S78	S75>цS76	S80>=S82
S33>rS34	S52>sS53	S0>, S70	S72>-S78	S76>цS76	S85>otherS85
S33>otherS85	S52>otherS85	S0>;S70	S71>цS71	S77>+S78	S86>oS87
S34>otherS85	S53>eS54	S0>:S70	S71>.S73	S77>=S78	S86>otherS85
S35>nS36	S53> other S85	S0>'S70	S71>ES74	S83><S78	S87>iS88
S35>otherS85	S54>otherS85	S0>”S70	S71>eS74	S84>>S78	S87>otherS85
S36>otherS85	S55>eS56	S0>(S70	S73>цS76	S83>=S82	S88>dS89
S32>otherS85	S55>otherS85	S0>)S70	S74>+S75	S84>=S82	S88>otherS85
S37>uS38	S56>tS57	S0>[S70	S74>-S75	S79>=S82	S89>otherS85
S37>otherS85	S56>otherS85	S0>]S70	S43>otherS85	S63>nS64	S0>*S77
S38>tS39	S57>uS85	S0>{S70	S44>otherS85	S63>otherS85	S0>+S78
S38>otherS85	S57>otherS85	S0>}S70	S46>rS47	S64>gS65	S0>+S77
S32>otherS85	S58>rS59	S0>цS71	S46>otherS85	S64>otherS85	S0>-S78
S39>otherS85	S58>otherS85	S0>-S72	S47>otherS85	S65>otherS85	S0>=S78
S40>hS41	S59>nS60	S0>&S78	S48>tS49	S66>aS67	S0>=S79
S40>otherS85	S59>otherS85	S0>&S77	S48>pS51	S66>otherS85	S0><S83
S41>iS42	S60>otherS85	S0>/S78	S48>otherS85	S67>mS68	S0>>S84
S41>otherS85	S61>sS62	S0>/S77	S49>dS50	S67>otherS85	S0><S82
S42>lS43	S61>otherS85	S0>%S78	S49>otherS85	S68>eS69	S0>>S82
S42>otherS85	S62>iS63	S0>%S77	S51>aS52	S68>otherS85	S0>!S80
S45>otherS85	S69>sS45	S45>pS51	S51>otherS85	S69>otherS85	S72>цS71
S43>eS44	S62>otherS85	S0>*S78	S78>е	S82>е	S85>е
S70>е	S71>е	S76>е	S19>е	S24>е	S47>е
S34>е	S36>е	S39>е	S69>е	S65>е	S3>е
S30>е	S26>е	S44>е	S50>е	S54>е	S85>е
S8>е	S15>е	S89>е	S70>е	S71>е	S76>е
S70>е	S70>е	S70>е	S70>е	S70>е	S70>е
S70>е	S70>е	S70>е

КС-грамматика. Низходящий синтаксический анализатор

Код для кс-грамматики

do {

for (int i=0;i<n;i++){

x=2*i;

y+=x;}}

while(y<=1000)

for ( int i=100;j>n;j-){

y-=j;

do{x+=y;}while(x<=y)

}

G=(T, N, P, S)

Где T -- конечный алфавит терминальных символов (совпадает с алфавитом языка, задаваемого грамматикой);

N -- конечный алфавит нетерминальных символов;

P -- конечное множество правил порождения;

S -- начальный нетерминал грамматики G.

T={id, const, -, *, ?, >, <, /, +, =, ;, (, ), {, }, >=, <=}

N={S, E, B O, C, K, I, Z, L, P}

S=S

P:

1. S> do LEL while (UL / for (I) LEL

2. E> CS/C

3. U> BOB

4. O> >/</>= /<=/!=/==

5. C> BPK;/BPB;/CC/ е

6. P> +/-/*/Z/+=/-=

7. Z> =

8. K> BPB

9. I>int BZB;BOB;BPP;

10. B>const/id

11. L>(/)/{/}/}S/)S/{S/(S

Порождение грамматики

S ? do LEL while (UL ? do {EL while (UL ? do {CSL while(UL ?

do { SL while(UL? do { for(I)LELL while (UL ? do {for(int BZB;BOB;BPP; ) LELL while (UL? do {for(int id ZB;BOB;BPP; ) LELL while (UL? do {for(int id =B;BOB;BPP; ) LELL while (UL? do {for(int id =const;BOB;BPP; ) LELL while (UL? do {for(int id =const;idOB;BPP; ) LELL while (UL? do {for(int id =const;id<B;BPP; ) LELL while (UL? do {for(int id =const;id<id;BPP; ) LELL while (UL? do {for(int id =const;id<id;idPP; ) LELL while (UL? do {for(int id =const;id<id;id+P; ) LELL while (UL? do {for(int id =const;id<id;id++; ) LELL while (UL?

do {for(int id =const;id<id;id++; ) {ELL while (UL? do {for(int id =const;id<id;id++; ) { CLL while (UL? do {for(int id =const;id<id;id++; ) { CCLL while (UL? do {for(int id =const;id<id;id++; ) { BPK;CLL while (UL? do {for(int id =const;id<id;id++; ) { idPK;CLL while (UL? do {for(int id =const;id<id;id++; ) { id=K;CLL while (UL? do {for(int id =const;id<id;id++; ) { id=BPB;CLL while (UL? do {for(int id =const;id<id;id++; ) { id=constPB;CLL while (UL? do {for(int id =const;id<id;id++; ) { id=const*B;CLL while (UL? do {for(int id =const;id<id;id++; ) { id=const*id;CLL while (UL? do {for(int id =const;id<id;id++; ) { id=const*id;BPB;LL while (UL? do {for(int id =const;id<id;id++; ) { id=const*id;idPB;LL while (UL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=B;LL while (UL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;LL while (UL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;LL while (UL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}L while (UL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (UL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (BOBL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (idOBL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=BL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=constL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}S? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(I)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int BZB;BOB;BPP)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int idZB;BOB;BPP)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=B;BOB;BPP)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;BOB;BPP)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id OB;BPP)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >B;BPP)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;BPP)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;idPP)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-P)LEL?

do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-)LEL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){EL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){CSL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){BPB;SL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){idPB;SL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=B;SL?

do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;SL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do LEL while (ULL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {EL while (ULL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {BPB;L while (ULL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {idPB;L while (ULL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {id+=B;L while (ULL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {id+=id;L while (ULL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {id+=id;} while (ULL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {id+=id;} while (BOBLL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {id+=id;} while (idOBLL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {id+=id;} while (id<=BLL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {id+=id;} while (id<=idLL? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {id+=id;} while (id<=id)L? do {for(int id =const;id<id;id++; ) { id=const*id;id+=id;}} while (id<=const}for(int id=const;id >id;id-){id-=id;do {id+=id;} while (id<=id)}



Логическое проектирование

Для написания программы, был разработан алгоритм, а по нему составлена упрощённая Блок-схема. Блок-схема программы представлена на Рис. 5.

Рис. 5. Блок-схема



Проектирование интерфейса

Таблица 1 Таблица проектирования интерфейса

Элемент интерфейса	Реализация	Выполняемое действие
Поле для ввода текста программы	Поле TextBox	Действий не выполняется
Кнопка обработка	Кнопка	Удаление коментариев и лишних пробелов в тексте введённой программы
Кнопка сброс	Кнопка	Возврат программы в изначальное состояние
Таблица ключевых слов	Таблица	Вывод результата
Таблица идентификаторов	Таблица	Вывод результата
Таблица числовых переменных	Таблица	Вывод результата
Таблица знаков пунктуации	Таблица	Вывод результата
Поле для вывода дескрипторного кода	Поле TextBox	Вывод результата
Поле для вывода псевдокода	Поле TextBox	Вывод результата
Поле для вывода текста программы после обработки	Поле TextBox	Действий не выполняется

Кодирование

Реализация разработанных алгоритмов и составленный по ним текст программы (с комментариями) в Приложении 3.

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

На этапе тестирования разработаны тестовые данные и оформлены в виде таблицы.

Таблица 2 Таблица тестовых данных

№	Исходные данные	Тестируемый модуль или подпрограммы	Ожидаемый результат
1	int x=5;	Form1	Выделение лексем
2	int xQx3=5.5;	Form1	Выделение лексем
3	do{for(int i=0;i<n;i++){}}while	Form1	Выделение лексем
4	int x=5; //sadsad	Form1	Выделение лексем и удаление коментариев
5	//int x=5;	Form1	Пропуск

Проведение тестирования по таблице тестовых данных

Таблица 3 Результаты выполнения тестирования

№	Дата и время	Тестируемый модуль или подпрограмма	Кто проводил тестирование	Описание теста	Результаты тестирования
1	25.12.2017	Form1	Волков А.A	Ввод текста программы для проверки на определение лексем	Успех
2	25.12.2017	Form1	Волков А.A	Ввод текста на проверку определения введённых переменных и констант	Успех
3	25.12.2017	Form1	Волков А.A	Проверка на определение конструкций оператора Do-while и for	Успех
4	25.12.2017	Form1	Волков А.A	Проверка на пропуск пробелов и комментариев:	Успех
5	25.12.2017	Form1	Волков А.A	Проверка на пропуск комментария	Успех



Заключение

Для моделирования работы компилятора мной была разработана регулярная грамматика, а для синтаксического анализа - КС-грамматика.

Был решён ряд задач:

· определил требования к программному продукту;

· выбрал типы данных, необходимые для решения задачи;

· написал программный код;

· произвел тестирование.



Источники информации

1. Ю.Г.Карпов “ Теория и технология программирования. Основы построения трансляторов.” СПБ.: БХВ-Петербург, 2005.

2.Справочник С# https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/



Приложение

Введение

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

1.Назначение разработки

Программа должна моделировать работу компилятора для операторов do-while и for языка С++.

2.Требования к программе

1. Программа должна выделять из текста входной программы все лексемы, входящие в заданную языковую конструкцию операторов do-while и for языка С++

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

3. Программа должна преобразовывать исходный текст программы в псевдокод

4. Программа должна преобразовывать исходный текст программы в дескрипторный код

5. Программа должна выводить сообщения об ошибках.

3. Требования к надежности:

· программа должна выполнять предписанные функциональные характеристики без сбоев;

· обеспечение контроля входной и выходной информации;

· защита при неверных действиях пользователя;

· контроль соответствия типов данных.

4. Требования к программной документации

Расчетно-пояснительная записка.

Руководство пользователя.

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

5. Технико-экономические показатели

Требования не предъявляются

6. Стадии и этапы разработки

Наименование этапа разработки ПО	Сроки разработки	Результат выполнения	Отметка о выполнении
Получение задания	9.10.2017	Успешно	Выполнено
Анализ требований	23.12.17	Успешно	Выполнено
Реализация	23.12.17-25.12.17	Успешно	Выполнено
Тестирование	25.12.17	Успешно	Выполнено
Внедрение и поддержка	26.12.17-27.12.17	Успешно	Выполнено

7. Порядок контроля и приемки

Наименование контрольного этапа выполнения курсовой работы	Сроки контроля	Результат выполнения	Отметка о выполнении
1.Разработка технического задания	с 23 февраля по 24 февраля	Техническое задание	Выполнено
2.Начальная разработка программы	с 23 февраля по 24 февраля	Блок - схема, либо словесное описание программы, регулярная граматика по КА	Выполнено
3. Написание кода программы	с 23 февраля по 25 февраля	Готовая программа	Выполнено
4. Тестирование программы	25 февраля	Рабочая программа	Выполнено
5. Расчётно -пояснительная записка	с 24 февраля по 25 февраля	Расчётно-пояснительная записка	Выполнено
6.Защита курсовой работы	27 февраля	Защита	Выполнено

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

· для запуска программы требуется Windows XP или более поздняя версия и Super VGA видеоадаптер;

· процессор 233 МГц или лучше;

· как минимум 64 МБ Мб ОЗУ;

· не менее 1, 5 ГБ свободного дискового пространства;

· для установки Windows требуется устройство для чтения компакт-дисков (или же поддержка других устройств, таких как флэш-накопителей);

· необходим монитор Super VGA с разрешением 800x600 или более высоким, отображающий 256 и более цветов;

· необходимы клавиатура и мышь.

Требования к информационной и программной совместимости:

· язык программирования (C++);

· среда для разработки программы (Visual Studio C++)

· операционная система (Windows XP);

· уровень защиты (без защиты).



Приложение 2

Текст программы

1. using System;

2. using System.Collections.Generic;

3. using System.ComponentModel;

4. using System.Data;

5. using System.Drawing;

6. using System.Linq;

7. using System.Text;

8. using System.Threading.Tasks;

9. using System.Windows.Forms;

10. using System.IO;

11. namespace automata

12. {

13. public partial class Form1: Form

14. {

15. int v_id = 0, v_op = 0, v_sy = 0, v_k = 0, v_con = 0, v_nu=0;

16. //добавить идентификатор

17. void add_ident(string cell, ref int v_id) {

18. if (!check_ident(cell))

19. {

20. id.Rows.Add(" ");

21. id[0, v_id ].Value = Convert.ToString(v_id + 1);//запись в таблицу номера слова

22. id[1, v_id ].Value = cell;//в таблицу заносится слово

23. id[2, v_id ].Value = Convert.ToString("(10, "+(v_id+1)+ ")");//запись дискрипторного кода

24. dk.Text += id[2, v_id].Value.ToString();

25. pk.Text += Convert.ToString("id" + (v_id + 1)+ " "); pk.SelectionStart = pk.Text.Length;

26. v_id++;}

27. }

28. //добавить знак операции

29. void add_op(string cell, ref int v_op) {

30. if (!check_op(cell))

31. {

32. op.Rows.Add(" ");

33. op[0, v_op].Value = Convert.ToString(v_op + 1);//запись в таблицу номера слова

34. op[1, v_op].Value = cell;//в таблицу заносится слово

35. op[2, v_op].Value = Convert.ToString("(20, " + (v_op + 1) + ")");//запись дискрипторного кода

36. dk.Text += op[2, v_op].Value.ToString();//запись дискрипторного кода

37. pk.Text += cell+" "; pk.SelectionStart = pk.Text.Length;

38. v_op++;

39. }

40. }

41. //добавить знак синтаксиса

42. void add_synt(string cell, ref int v_sy) {

43. if (!check_synt(cell))

44. {synt.Rows.Add();

45. synt[0, v_sy].Value = Convert.ToString(v_sy + 1);//запись в таблицу номера слова

46. synt[1, v_sy].Value = cell;//в таблицу заносится слово

47. synt[2, v_sy].Value = Convert.ToString("(50, " + (v_sy + 1) + ")");//запись дискрипторного кода

48. dk.Text += synt[2, v_sy].Value.ToString();//запись дискрипторного кода

49. pk.Text += Convert.ToString(cell) + " ";

50. pk.SelectionStart = pk.Text.Length;

51. v_sy++;}

52. }

53. //добавить ключевое слово

54. void add_key(string cell, ref int v_k) {

55. if (!check_key(cell))

56. {

57. key.Rows.Add();

58. key[0, v_k].Value = Convert.ToString(v_k + 1);//запись в таблицу номера слова

59. key[1, v_k].Value = cell;//в таблицу заносится слово

60. key[2, v_k].Value = Convert.ToString("(40, " + (v_k + 1) + ")");//запись дискрипторного кода

61. dk.Text += key[2, v_k].Value.ToString();//запись дискрипторного кода

62. pk.Text += Convert.ToString(cell) + " "; pk.SelectionStart = pk.Text.Length;

63. v_k++;}

64. }

65. //добавить знак отношений

66. void add_cond(string cell, ref int v_con) {

67. if (!check_cond(cell))

68. {

69. cond.Rows.Add();

70. cond[0, v_con].Value = Convert.ToString(v_con + 1);//запись в таблицу номера слова

71. cond[1, v_con].Value = cell;//в таблицу заносится слово

72. cond[2, v_con].Value = Convert.ToString("(30, " + (v_con + 1) + ")");//запись дискрипторного кода

73. dk.Text += cond[2, v_con].Value.ToString();//запись дискрипторного кода

74. pk.Text += cell + " "; pk.SelectionStart = pk.Text.Length;

75. v_con++;

76. }

77. }

78. //добавить нераспознанный знак

79. void add_unId(char[] cell, ref int j, int i)

80. {

81. err.Text += "Error line: " + Convert.ToString(i+1)+Environment.NewLine;

82. while (j!=cell.Length-1) { j++;

83. if (cell[j] == ' ' || cell[j] == '\n') return;

84. }

85. return;

86. }

87. void add_nu(string cell, ref int v_nu)

88. {

89. if (!check_nu(cell))

90. {

91. nu.Rows.Add(" ");

92. nu[0, v_nu].Value = Convert.ToString(v_nu + 1);//запись в таблицу номера слова

93. nu[1, v_nu].Value = cell;//в таблицу заносится слово

94. nu[2, v_nu].Value = Convert.ToString("(60, " + (v_nu + 1) + ")");//запись дискрипторного кода

95. pk.Text += "const "; pk.SelectionStart = pk.Text.Length;

96. dk.Text += nu[2, v_nu].Value.ToString();

97. v_nu++;

98. }

99. }

100. //проверить наличие идентификатора

101. bool check_ident(string cell) {

102. if (id.Rows.Count != 0)

103. {

104. for (int i = 0; i < id.Rows.Count; i++)

105. {//если значения совпадают, то в таблицу не заносится, а в дискрипторный код записывается текущее полученное значение

106. if (id[1, i].Value.ToString() == cell)

107. {

108. dk.Text += id[2, i].Value.ToString(); pk.Text += Convert.ToString("id" + (i + 1) + " "); pk.SelectionStart = pk.Text.Length;

109. return true;

110. }

111. }

112. }

113. return false;

114. }

115. //проверить наличие операции

116. bool check_op(string cell) {

117. if (op.Rows.Count != 0)

118. {

119. for (int i = 0; i < op.Rows.Count; i++)

120. {//если значения совпадают, то в таблицу не заносится, а в дискрипторный код записывается текущее полученное значение

121. if (op[1, i].Value.ToString() == cell) { dk.Text += op[2, i].Value.ToString();

122. pk.Text += cell+" ";

123. pk.SelectionStart = pk.Text.Length;

124. return true; }}}

125. return false;

126. }

127. //проверить наличие синтаксиса

128. bool check_synt(string cell) {

129. if (synt.Rows.Count != 0)

130. {

131. for (int i = 0; i < synt.Rows.Count; i++)

132. {//если значения совпадают, то в таблицу не заносится, а в дискрипторный код записывается текущее полученное значение

133. if (synt[1, i].Value.ToString() == cell) { dk.Text += synt[2, i].Value.ToString(); pk.Text += Convert.ToString(cell) + " ";

134. pk.SelectionStart = pk.Text.Length; return true; }

135. }

136. }

137. return false;

138. }

139. //проверить наличие ключевого слова

140. bool check_key(string cell) {

141. if (key.Rows.Count != 0)

142. {

143. for (int i = 0; i < key.Rows.Count; i++)

144. {//если значения совпадают, то в таблицу не заносится, а в дискрипторный код записывается текущее полученное значение

145. if (key[1, i].Value.ToString() == cell)

146. {

147. dk.Text += key[2, i].Value.ToString(); pk.Text += Convert.ToString(cell) + " "; pk.SelectionStart = pk.Text.Length;

148. return true;

149. }

150. }

151. }

152. return false;

153. }

154. //проверить наличие отношений

155. bool check_cond(string cell) {

156. if (cond.Rows.Count != 0)

157. {

158. for (int i = 0; i < cond.Rows.Count; i++)

159. { //если значения совпадают, то в таблицу не заносится, а в дискрипторный код записывается текущее полученное значение

160. if (cond[1, i].Value.ToString() == cell) { dk.Text += cond[2, i].Value.ToString(); pk.Text += cell + " "; pk.SelectionStart = pk.Text.Length;

161. return true; }

162. }

163. }

164. return false;

165. }

166. bool check_nu(string cell)

167. {

168. if (nu.Rows.Count != 0)

169. {

170. for (int i = 0; i < nu.Rows.Count; i++)

171. {//если значения совпадают, то в таблицу не заносится, а в дискрипторный код записывается текущее полученное значение

172. if (nu[1, i].Value.ToString() == cell)

173. {

174. dk.Text += nu[2, i].Value.ToString(); pk.Text += "const "; pk.SelectionStart = pk.Text.Length;

175. return true;

176. }

177. }

178. }

179. return false;

180. }

181. bool alf (char b){

182. if (b >= 'A' && b <= 'Z' || b >= 'a' && b <= 'z') return false;

183. else return true;

184. }

185. bool numb(char b)

186. {

187. if (b >= '0' && b <= '9') return true;

188. else return false;

189. }

190. bool f_synt(char b)

191. {

192. if (b == ', ' || b == ':' || b == ';' || b == '(' || b == ')' || b == '{' || b == '}' || b == '[' || b == ']' || b == '"'|| b=='<' || b == '>' || b == '=' || b == '+' || b == '-' || b == '*' || b == '/' || b == '%') return true;

193. else return false;

194. }

195. void clear()

196. {

197. rich2.Clear(); err.Clear(); key.Rows.Clear(); op.Rows.Clear(); cond.Rows.Clear(); synt.Rows.Clear(); id.Rows.Clear(); nu.Rows.Clear(); dk.Clear(); pk.Clear(); v_id = 0; v_op = 0; v_sy = 0; v_k = 0; v_con = 0; v_nu = 0;

198. }

199. bool f_cond(char b)

200. {

201. if (b == '=' || b == '>' || b == '<' || b == '!') return true;

202. else return false;

203. }

204. public Form1()

205. {

206. InitializeComponent();

207. }

208. // создание начальных колонок в таблице

209. private void Form1_Load(object sender, EventArgs e)

210. {

211. }

212. //кнопка для ручного прохода по слову

213. private void Form1_SizeChanged(object sender, EventArgs e)

214. {

215. }

216. private void button3_Click(object sender, EventArgs e)

217. {

218. v_id = 0; v_op = 0; v_sy = 0; v_k = 0; v_con = 0;

219. }

220. private void button3_Click_1(object sender, EventArgs e)

221. {

222. clear(); //отчистка таблиц и текстовых полей

223. string str = null;

224. if (rich1.Text != "") //проверка на пустое поле

225. {

226. button2.Enabled = true; //активизация кнопки анализа

227. char[] h = Encoding.Default.GetChars(Encoding.Default.GetBytes(rich1.Text)); //инициализация текстового блока в массив символов

228. for (int i = 0; i < h.Length; i++)

229. {

230. if (h[i] == '/' && h[i + 1] == '/')

231. { //поиск 2-х слешей

232. while (h[i] != '\n') { h[i++] = ' '; } //замена значений на пробелы после двух слешей

233. str += h[i];//новая строка в буфер

234. }

235. else str += h[i]; //инициализация буфера

236. }

237. string h_1 = Convert.ToString(str); //конвертация буфера символов в строкговую переменную

238. string[] h1 = h_1.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries); //дробление строки по символу окончания строки

239. for (int j = 0; j < h1.Length; j++)

240. {

241. h = Encoding.Default.GetChars(Encoding.Default.GetBytes(h1[j])); //инициализация строки в массив символов

242. if (h[0] != '/')

243. { rich2.Text += Convert.ToString(h1[j]) + Environment.NewLine; } //первый символ не одиночный слеш. Производится сбор новой переменной

244. }

245. string s1 = rich2.Text; string s2, s3; //инициализация для удаления пробелов

246. s3 = s1;

247. do { s2 = s3; s3 = s2.Replace(" ", " "); } //Replace - замена двойного пробела на одиночный

248. while (s2 != s3); //пока строки не окажутся равны. То есть пока все пробелы не станут в единичном количестве

249. rich2.Text = s3; //инициализация текстового блока для анализа обработанным текстом

250. }

251. else { MessageBox.Show("Вы ничего не ввели!", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); } //ошибка, если ничего не введено

252. }

253. private void button4_Click(object sender, EventArgs e)

254. {

255. rich1.Text = File.ReadAllText("Source.cpp");

256. }

257. private void button1_Click(object sender, EventArgs e)

258. {

259. rich1.Clear();rich2.Clear(); err.Clear(); key.Rows.Clear(); op.Rows.Clear(); cond.Rows.Clear(); synt.Rows.Clear(); id.Rows.Clear(); nu.Rows.Clear(); dk.Clear(); pk.Clear(); v_id = 0; v_op = 0; v_sy = 0; v_k = 0; v_con = 0; v_nu = 0;

260. }

261. private void button2_Click(object sender, EventArgs e)

262. { int num_si = 0;

263. char[] num_tex;

264. string token = null;

265. string automa = rich2.Text + " "; //инициализация строки слов

266. string[] cell_x = automa.Split(new char[] { ' ', '\n' }, StringSplitOptions.RemoveEmptyEntries); // дробление строки по символам

267. if (rich1.Text == "") { MessageBox.Show("Вы ничего не ввели!", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); }

268. else

269. {for (int i = 0; i < cell_x.Length; i++) //начало работы цикла перебора слов

270. {

271. num_tex = Encoding.Default.GetChars(Encoding.Default.GetBytes(cell_x[i] + ' ')); //инициализация строки в массив символов

272. for (int j = 0; j < num_tex.Length; j++) //начало работы цикла перебора символов

273. {

274. switch (num_si)

275. {

276. case 0:

277. if (num_tex[j] == 'c')

278. {

279. num_si = 31; token += Convert.ToString(num_tex[j]);

280. }

281. Else

282. {

283. if (num_tex[j] == 'm')

284. {

285. num_si = 16; token += Convert.ToString(num_tex[j]);

286. }

287. Else

288. {

289. if (num_tex[j] == 'f')

290. {

291. num_si = 20; token += Convert.ToString(num_tex[j]);

292. }

293. Else

294. {

295. if (num_tex[j] == 'd')

296. {

297. num_si = 25; token += Convert.ToString(num_tex[j]);

298. }

299. Else

300. {

301. if (num_tex[j] == 'w')

302. {

303. num_si = 40; token += Convert.ToString(num_tex[j]);

304. }

305. Else

306. {

307. if (num_tex[j] == 'r')

308. {

309. num_si = 55; token += Convert.ToString(num_tex[j]);

310. }

311. Else

312. {

313. if (num_tex[j] == 'u')

314. {

315. num_si = 61; token += Convert.ToString(num_tex[j]);

316. }

317. Else

318. {

319. if (num_tex[j] == 'n')

320. {

321. num_si = 66; token += Convert.ToString(num_tex[j]);

322. }

323. Else

324. {

325. if (num_tex[j] == 'i')

326. {

327. num_si = 1; token += Convert.ToString(num_tex[j]);

328. }

329. Else

330. {

331. if (num_tex[j] == 's')

332. {

333. num_si = 48; token += Convert.ToString(num_tex[j]);

334. }

335. Else

336. {

337. if (num_tex[j] == 'v')

338. {

339. num_si = 86; token += Convert.ToString(num_tex[j]);

340. }

341. Else

342. {if (num_tex[j] == '.' || num_tex[j] == ', ' || num_tex[j] == ':' || num_tex[j] == ';' || num_tex[j] == '(' || num_tex[j] == ')' || num_tex[j] == '{' || num_tex[j] == '}' || num_tex[j] == '[' || num_tex[j] == ']' || num_tex[j] == '"')

343. {

344. num_si = 70; token += Convert.ToString(num_tex[j]);

345. }

346. Else

347. {

348. if (num_tex[j] == '-' && (num_tex[j + 1] == '0' || num_tex[j + 1] == '1' || num_tex[j + 1] == '2' || num_tex[j + 1] == '3' || num_tex[j + 1] == '4' || num_tex[j + 1] == '5' || num_tex[j + 1] == '6' || num_tex[j + 1] == '7' || num_tex[j + 1] == '8' || num_tex[j + 1] == '9'))

349. {

350. num_si = 72; token += Convert.ToString(num_tex[j]);

351. }

352. Else

353. {

354. if (num_tex[j] == '-')

355. {

356. num_si = 72; token += Convert.ToString(num_tex[j]);

357. }

358. Else

359. {

360. if (num_tex[j] == '0' || num_tex[j] == '1' || num_tex[j] == '2' || num_tex[j] == '3' || num_tex[j] == '4' || num_tex[j] == '5' ||

361. num_tex[j] == '6' || num_tex[j] == '7' || num_tex[j] == '8' || num_tex[j] == '9')

362. {

363. num_si = 71; token += Convert.ToString(num_tex[j]);

364. }

365. Else

366. {

367. if ((num_tex[j] == '/' || num_tex[j] == '+' || num_tex[j] == '-' || num_tex[j] == '&' || num_tex[j] == '%' || num_tex[j] == '*') &&

368. (num_tex[j + 1] == '=' || num_tex[j + 1] == '+'))

369. {

370. num_si = 77; token += Convert.ToString(num_tex[j]);

371. }

372. Else

373. {

374. if (num_tex[j] == '/' || num_tex[j] == '+' || num_tex[j] == '-' || num_tex[j] == '&' || num_tex[j] == '%' || num_tex[j] == '*')

375. {

376. num_si = 78; token += Convert.ToString(num_tex[j]);

377. }

378. Else

379. {

380. if (num_tex[j] == '!')

381. {

382. num_si = 80; token += Convert.ToString(num_tex[j]);}

383. else{

384. if (num_tex[j] == '=' && num_tex[j + 1] == '=')

385. {

386. num_si = 79; token += Convert.ToString(num_tex[j]);

387. }

388. Else

389. {

390. if (num_tex[j] == '=')

391. {num_si = 78; token += Convert.ToString(num_tex[j]);

392. }

393. Else

394. {

395. if (num_tex[j] == '<' && (num_tex[j + 1] == '<' || num_tex[j + 1] == '='))

396. {

397. num_si = 83; token += Convert.ToString(num_tex[j]);

398. }

399. Else

400. {

401. if (num_tex[j] == '>' && (num_tex[j + 1] == '>' || num_tex[j + 1] == '='))

402. {

403. num_si = 84; token += Convert.ToString(num_tex[j]);

404. }

405. Else

406. {

407. if (num_tex[j] == '>' || num_tex[j] == '<')

408. {

409. num_si = 82; token += Convert.ToString(num_tex[j]);

410. }

411. Else

412. {

413. if (num_tex[j] >= 'A' && num_tex[j] <= 'Z' || num_tex[j] >= 'a' && num_tex[j] <= 'z')

414. {

415. num_si = 85; token += Convert.ToString(num_tex[j]);

416. }

417. Else

418. {

419. if (num_tex[j] == '_') { num_si = 85; token += Convert.ToString(num_tex[j]); }

420. }}}}}}}}}}}}}}}}}}}}}}}}

421. break;

422. case 1:

423. if (num_tex[j] == ' ' || num_tex[j] == '\n') { add_ident(token, ref v_id); token = null; num_si = 0; }

424. else

425. {

426. if (num_tex[j] == 'n') { num_si = 2; token += Convert.ToString(num_tex[j]); }

427. else

428. {

429. if (num_tex[j] == 'o') { num_si = 9; token += Convert.ToString(num_tex[j]); }

430. else

431. {

432. if (num_tex[j] == '.') { add_unId(num_tex, ref j, i); token = null; num_si = 0; }

433. else

434. {

435. if (f_synt(num_tex[j])) { add_ident(token, ref v_id); token = null; num_si = 0; j-; }

436. else { num_si = 85; token += Convert.ToString(num_tex[j]); }

437. }

438. }

439. }

440. }

441. break;

442. case 2:

443. if (num_tex[j] == ' ' || num_tex[j] == '\n') { add_ident(token, ref v_id); token = null; num_si = 0; }

444. else

445. {

446. if (num_tex[j] == 't') { num_si = 3; token += Convert.ToString(num_tex[j]); }

447. else

448. {

449. if (num_tex[j] == 'c') { num_si = 4; token += Convert.ToString(num_tex[j]); }

450. else

451. {

452. if (num_tex[j] == '.') { add_unId(num_tex, ref j, i); token = null; num_si = 0; }

453. else if (f_synt(num_tex[i])) { add_ident(token, ref v_id); token = null; num_si = 0; j-; }

454. else { num_si = 85; token += Convert.ToString(num_tex[j]); }

455. }

456. }

457. }

458. break;

459. case 3:

460. if (num_tex[j] == ' ' || num_tex[j] == '\n')

461. {

462. add_key(token, ref v_k); token = null; num_si = 0;

463. }

464. else

465. {

466. if (num_tex[j] == '.') { add_unId(num_tex, ref j, i); token = null; num_si = 0; }

467. else if (f_synt(num_tex[j])) { add_key(token, ref v_k); token = null; num_si = 0; j-; }

468. else { num_si = 85; token += Convert.ToString(num_tex[j]); }

469. }

470. break;

471. case 4:

472. if (num_tex[j] == ' ' || num_tex[j] == '\n') { add_ident(token, ref v_id); token = null; num_si = 0; }

473. else {

474. if (num_tex[j] == 'l') { num_si = 5; token += Convert.ToString(num_tex[j]); }

475. else

476. {

477. if (num_tex[j] == '.') { add_unId(num_tex, ref j, i); token = null; num_si = 0; }

478. else if (f_synt(num_tex[j])) { add_ident(token, ref v_id); token = null; num_si = 0; j-; }

479. else { num_si = 85; token += Convert.ToString(num_tex[j]); }

480. }

481. }

482. break;

483. case 5:

484. if (num_tex[j] == ' ' || num_tex[j] == '\n') { add_ident(token, ref v_id); token = null; num_si = 0; }

485. else {

486. if (num_tex[j] == 'u') { num_si = 6; token += Convert.ToString(num_tex[j]); }

487. else

488. {

489. if (num_tex[j] == '.') { add_unId(num_tex, ref j, i); token = null; num_si = 0; }

490. else if (f_synt(num_tex[j])) { add_ident(token, ref v_id); token = null; num_si = 0; j-; }

491. else { num_si = 85; token += Convert.ToString(num_tex[j]); }

492. }

493. }

494. break;

495. case 6:

496. if (num_tex[j] == ' ' || num_tex[j] == '\n') { add_ident(token, ref v_id); token = null; num_si = 0; }

497. else {

498. if (num_tex[j] == 'd') { num_si = 7; token += Convert.ToString(num_tex[j]); }

499. else

500. {

501. if (num_tex[j] == '.') { add_unId(num_tex, ref j, i); token = null; num_si = 0; }

502. else if (f_synt(num_tex[j])) { add_ident(token, ref v_id); token = null; num_si = 0; j-; }

503. else { num_si = 85; token += Convert.ToString(num_tex[j]); }

504. }

505. }

506. break;

507. case 7:

508. if (num_tex[j] == ' ' || num_tex[j] == '\n') { add_ident(token, ref v_id); token = null; num_si = 0; }

509. else {

510. if (num_tex[j] == 'e') { num_si = 8; token += Convert.ToString(num_tex[j]); }

511. else

512. {

513. if (num_tex[j] == '.') { add_unId(num_tex, ref j, i); token = null; num_si = 0; }

514. else if (f_synt(num_tex[j])) { add_ident(token, ref v_id); token = null; num_si = 0; j-; }

515. else { num_si = 85; token += Convert.ToString(num_tex[j]); }

516. }

517. }

518. break;

519. case 8:

520. if (num_tex[j] == ' ' || num_tex[j] == '\n')

521. {

522. add_key(token, ref v_k); token = null; num_si = 0;

523. }

524. else

525. {

526. if (num_tex[j] == '.') { add_unId(num_tex, ref j, i); token = null; num_si = 0; }

527. else if (f_synt(num_tex[j])) { add_key(token, ref v_k); token = null; num_si = 0; j-; }

528. else { num_si = 85; token += Convert.ToString(num_tex[j]); }