|
prog
|
end.
|
;
|
or
|
and
|
not
|
<
|
>
|
=
|
(
|
)
|
if
|
then
|
else
|
do
|
while
|
:=
|
-
|
+
|
-
|
c
|
g
|
begin
|
end
|
over
|
prog
|
-
|
<
|
<
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
<
|
-
|
<
|
<
|
-
|
-
|
-
|
-
|
-
|
<
|
-
|
<
|
-
|
-
|
end.
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
>
|
;
|
-
|
>
|
>
|
>
|
-
|
-
|
-
|
-
|
-
|
-
|
>
|
<
|
-
|
>
|
<
|
>
|
<
|
-
|
-
|
-
|
<
|
-
|
<
|
>
|
-
|
or
|
-
|
-
|
-
|
>
|
<
|
<
|
<
|
<
|
<
|
<
|
>
|
-
|
-
|
-
|
-
|
-
|
-
|
<
|
<
|
<
|
<
|
<
|
-
|
>
|
-
|
-
|
-
|
-
|
>
|
>
|
<
|
-
|
-
|
-
|
<
|
>
|
-
|
-
|
-
|
-
|
-
|
-
|
<
|
<
|
<
|
<
|
-
|
-
|
-
|
-
|
not
|
-
|
-
|
-
|
>
|
>
|
<
|
<
|
<
|
<
|
<
|
>
|
-
|
-
|
-
|
-
|
-
|
-
|
<
|
<
|
<
|
<
|
<
|
-
|
-
|
-
|
<
|
-
|
>
|
>
|
>
|
>
|
-
|
-
|
-
|
-
|
<
|
>
|
-
|
>
|
>
|
-
|
>
|
-
|
<
|
<
|
<
|
<
|
<
|
-
|
>
|
-
|
>
|
-
|
>
|
>
|
>
|
>
|
-
|
-
|
-
|
-
|
<
|
>
|
-
|
>
|
>
|
-
|
>
|
-
|
<
|
<
|
<
|
<
|
<
|
-
|
>
|
-
|
=
|
-
|
>
|
>
|
>
|
>
|
-
|
-
|
-
|
-
|
<
|
>
|
-
|
>
|
>
|
-
|
>
|
-
|
<
|
<
|
<
|
<
|
<
|
-
|
>
|
-
|
(
|
-
|
-
|
-
|
<
|
<
|
<
|
<
|
<
|
<
|
<
|
=
|
-
|
-
|
-
|
-
|
-
|
-
|
<
|
<
|
<
|
<
|
<
|
-
|
-
|
-
|
)
|
-
|
>
|
>
|
>
|
>
|
-
|
>
|
>
|
>
|
-
|
>
|
-
|
>
|
>
|
-
|
-
|
-
|
>
|
>
|
>
|
-
|
-
|
-
|
>
|
-
|
if
|
-
|
>
|
>
|
-
|
-
|
-
|
<
|
<
|
<
|
<
|
-
|
-
|
<
|
<
|
-
|
>
|
-
|
<
|
<
|
<
|
<
|
<
|
-
|
>
|
-
|
then
|
-
|
>
|
>
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
<
|
-
|
>
|
<
|
>
|
<
|
-
|
-
|
-
|
<
|
-
|
<
|
>
|
-
|
else
|
-
|
>
|
>
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
<
|
-
|
>
|
<
|
>
|
<
|
-
|
-
|
-
|
<
|
-
|
<
|
>
|
-
|
do
|
-
|
>
|
<
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
<
|
<
|
-
|
<
|
<
|
<
|
<
|
-
|
-
|
-
|
<
|
-
|
<
|
>
|
-
|
while
|
-
|
>
|
>
|
-
|
-
|
-
|
<
|
<
|
<
|
<
|
-
|
-
|
-
|
>
|
-
|
>
|
-
|
<
|
<
|
<
|
<
|
<
|
-
|
>
|
-
|
:=
|
-
|
>
|
>
|
-
|
-
|
-
|
-
|
-
|
<
|
-
|
-
|
-
|
-
|
>
|
-
|
>
|
-
|
<
|
<
|
<
|
<
|
<
|
-
|
>
|
-
|
-
|
-
|
>
|
>
|
>
|
>
|
-
|
>
|
>
|
>
|
<
|
>
|
-
|
>
|
-
|
>
|
-
|
>
|
>
|
>
|
<
|
<
|
-
|
>
|
-
|
+
|
-
|
>
|
>
|
>
|
>
|
-
|
>
|
>
|
>
|
<
|
>
|
-
|
>
|
>
|
-
|
>
|
-
|
>
|
>
|
>
|
<
|
<
|
-
|
>
|
-
|
-
|
-
|
>
|
>
|
>
|
>
|
-
|
>
|
>
|
>
|
-
|
>
|
-
|
>
|
>
|
-
|
>
|
-
|
>
|
>
|
>
|
-
|
-
|
-
|
>
|
-
|
c
|
-
|
>
|
>
|
>
|
>
|
-
|
>
|
>
|
>
|
-
|
>
|
-
|
>
|
>
|
-
|
>
|
>
|
>
|
>
|
>
|
-
|
-
|
-
|
>
|
-
|
g
|
-
|
>
|
>
|
>
|
>
|
-
|
>
|
>
|
>
|
-
|
>
|
-
|
>
|
>
|
-
|
>
|
-
|
>
|
>
|
>
|
-
|
-
|
-
|
>
|
-
|
begin
|
-
|
-
|
<
|
<
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
<
|
-
|
-
|
<
|
-
|
<
|
-
|
-
|
-
|
<
|
-
|
<
|
<
|
-
|
end
|
-
|
>
|
>
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
>
|
-
|
>
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
>
|
-
|
bgn
|
<
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
-
|
.4
Результат выполнения программы
Результаты построения дерева разбора входных выражений представлены
на рисунке 3.1.
Рис. 3.1 - Результаты построения дерева разбора
По последовательности правил «свертки» легко строится цепочка
вывода и дерево синтаксического разбора. Дерево строится сверху вниз путем
последовательного применения правил. Алгоритм разбора порождает правосторонний
вывод.
Вывод
Была разработана программа, производящая построение дерева
вывода заданных логических выражений и проверяющая их синтаксис.
Заключение
В результате выполнения курсовой работы для заданного
входного языка были построены отдельные части компилятора.
В первой части работы был разработан программа, которая
получает на входе набор идентификаторов, организует таблицу идентификаторов
методом цепочек и методом бинарного дерева, позволяет осуществить многократный
поиск идентификатора в этих таблицах.
Было также выявлено, что метод цепочек более эффективен, чем
метод бинарного дерева, так как для поиска идентификатора в таблице
организованной методом цепочек используется меньшее количество сравнений.
Во второй части работы была написана программа, которая
выполняет лексический анализ входного текста и порождает таблицу лексем с
указанием их типов и значений.
Третья часть курсовой работы была посвящена разработке
программы, которая порождает таблицу лексем и выполняет синтаксический разбор
текста с построением дерева разбора.
Отдельные части компилятора, разработанные в данной курсовой
работе, дают представление о технике и методах, лежащих в основе построения
компиляторов.
Список
литературы
1. Гордеев А.В. Молчанов Л.Ю. Системное
программное обеспечение, - СПб.: Питер. 2002. - 734 с.
2. Кампапиец Р. II. Манькоп Е.В., Филатов
Н.Е. Системное программирование. Основы построения трансляторов: Учеб. пособие
для высших и средних учебных заведений. - СПб.: КОРОНА Принт, 2000. - 256 с.
. Гордеев А.В. Операционные системы:
Учебник для вузов. 2-е изд.-СПб.: Питер, 2004. - 416 с.
. Олифер В.Г., Олифер Н.А. Сетевые
операционные системы. - СПб.: Питер. 2002. - 544 с.
Приложение
А - Листинги программы
String
input_line[256];stack[256];terminal[32];rules[32];input_rules[256];index_rule;**mega_matrix;all_rules=0;comment=0;
TForm1: Identificator // класс идентификатора
{:*Name;Right;Left;()
{= new char[32];=0;=0;
}Hash()
{(Name[0]|Name [strlen(Name) - 1]);
}
};
TForm1: AddToHashTableChane (int IDindex,
Identificator *IDTable, int *HashTable)
{ // добавление ид-ра в таблицу методом цепочек
if (! HashTable [IDTable[IDindex].Hash()])
{[IDTable[IDindex].Hash()]=IDindex;>Lines->Add((IDTable[IDindex].Name));>Text=mTextChane->Text+
«-> в хэш»;
}
{>Lines->Add((IDTable[IDindex].Name));>Text=mTextChane->Text+
«коллизия»;HashIndex =
HashTable [IDTable[IDindex].Hash()];fl=0;_chane++;
{>Text=mTextChane->Text+
«R»;(IDTable[HashIndex].Right!=0)
{= IDTable[HashIndex].Right;_chane++;
}
{[HashIndex].Right=IDindex;=1;
}
} while(! fl);
}
}
TForm1: SearchIdChane (char *ID, Identificator
*IDTable, int *HashTable) // поиск в табл. метода цепочек
{HashID=ID[0]|ID [strlen(ID) - 1];(!
HashTable[HashID])
{-1;
}
{HashIndex = HashTable[HashID];fl=0;_count_chane
= 1;
{_count_chane++;(strcmp (IDTable[HashIndex].Name,
ID)==0) return(HashIndex);
{(strcmp (IDTable[HashIndex].Name,
ID)!=0)(IDTable[HashIndex].Right!=0) HashIndex =
IDTable[HashIndex].Right;return -1;
}
} while(1);
}
}
int TForm1: A (char ch) // функции состояния автомата
{(ch=='r') return 2;(ch=='\0') return 999;return
777;
}TForm1: B (char ch)
{(ch=='o') return 3;(ch=='\0') return 999;return
777;
}TForm1: C (char ch)
{(ch=='g') return 4;(ch=='\0') return 999;return
777;
}TForm1: D (char ch)
{(ch=='\0') return 999;(ch=='\0') return
999;return 777;
}
TForm1: E (char ch)
{(ch=='n') return 6;(ch=='l') return
11;(ch=='\0') return 999;return 777;
}TForm1: H (char ch)
{(ch=='d') return 7;(ch=='\0') return 999;return
777;
}TForm1: G (char ch)
{(ch=='.') return 8;(ch=='\0') return 999;return
777;
}TForm1: K (char ch)
{(ch=='\0') return 999;return 777;
}
TForm1: L (char ch)
{(ch=='=') return 10;return 666;
}TForm1: M (char ch)
{(ch=='\0') return 999;return 666;
}
int TForm1: R (char ch)
{(ch=='s') return 23;(ch=='\0') return 999;return
777;
}TForm1: N (char ch)
{(ch=='f') return 13;(ch=='\0') return 999;return
777;
}TForm1: O (char ch)
{(ch=='\0') return 999;return 777;
}
TForm1: P (char ch)
{(ch=='h') return 15;(ch=='\0') return 999;return
777;
}TForm1: I (char ch)
{(ch=='e') return 16;(ch=='\0') return 999;return
777;
}TForm1: J (char ch)
{(ch=='n') return 17;(ch=='\0') return 999;return
777;
}TForm1: Q (char ch)
{(ch=='\0') return 999;return 777;
}
TForm1: V (char ch)
{(ch=='e') return 19;(ch=='\0') return 999;return
777;
}TForm1: W (char ch)
{(ch=='g') return 20;(ch=='\0') return 999;return
777;
}TForm1: X (char ch)
{(ch=='i') return 21;(ch=='\0') return 999;return
777;
}TForm1: Y (char ch)
{(ch=='n') return 22;(ch=='\0') return 999;return
777;
}TForm1: Z (char ch)
{(ch=='\0') return 999;return 777;
}
TForm1: T (char ch)
{(ch=='e') return 24;(ch=='\0') return 999;return
777;
}TForm1: U (char ch)
{(ch=='\0') return 999;return 777;
}TForm1: F (char ch)
{(ch=='\0') return 999;return 666;
}TForm1: FF (char ch)
{(ch=='-') return 26;(ch=='\0') return 999;return
666;
}
TForm1: AA (char ch)
{(ch=='\0') return 999;return 666;
}TForm1: AM (char ch)
{(ch=='\0') return 999;return 666;
}TForm1: AB (char ch)
{(ch=='n') return 29;(ch=='\0') return 999;return
777;
}TForm1: AC (char ch)
{(ch=='d') return 30;(ch=='\0') return 999;return
777;
}TForm1: AD (char ch)
{(ch=='\0') return 999;return 777;
}
TForm1: AG (char ch)
{(ch=='r') return 32;(ch=='\0') return 999;return
777;
}TForm1: AF (char ch)
{(ch=='\0') return 999;return 777;
}TForm1: AH (char ch)
{(ch=='o') return 34;(ch=='\0') return 999;return
777;
}TForm1: AI (char ch)
{(ch=='\0') return 999;return 777;
}TForm1: AE (char ch)
{(ch=='o') return 36;(ch=='\0') return 999;return
777;
}TForm1: AK (char ch)
{(ch=='t') return 37;(ch=='\0') return 999;return
777;
}TForm1: AL (char ch)
{(ch=='\0') return 999;return 777;
}
TForm1: AJ (char ch)
{(ch=='h') return 39;(ch=='\0') return 999;return
777;
}TForm1: AN (char ch)
{(ch=='i') return 40;(ch=='\0') return 999;return
777;
}TForm1: AO (char ch)
{(ch=='l') return 41;(ch=='\0') return 999;return
777;
}TForm1: AP (char ch)
{(ch=='e') return 42;(ch=='\0') return 999;return
777;
}TForm1: AQ (char ch)
{(ch=='\0') return 999;return 777;
}
TForm1: AR (char ch)
{(ch=='*') return 45;return 666;
}TForm1: AT (char ch)
{=1;(ch=='*') return 46;return 45;
}TForm1: AU (char ch)
{(ch=='/') return 47;return 45;
}TForm1: AV (char ch)
{(ch=='\0') {comment=0; return 999;}return 666;
}
TForm1: AW (char ch)
{((ch>='0')&&(ch<='9')) return
48;((ch>='a')&&(ch<='f')) return 49;(ch=='\0') return 999;return
666;
}TForm1: AX (char ch)
}
TForm1:h (char ch)
{(ch=='p') return 1;(ch=='e') return 5;(ch==':')
return 9;(ch=='i') return 12;(ch=='t') return 14;(ch=='b') return 18;(ch=='a')
return 28;(ch=='o') return 31;(ch=='-') return 50;(ch==' ('||ch==')') return
27;(ch=='+'||ch=='<'||ch=='>'||ch=='=') return 25;(ch=='d') return
33;(ch=='n') return 35;(ch=='/') return 43;(ch==';') return 51;(ch=='w') return
38;((ch>='0')&&(ch<='9')) return 48;return 777;
}
TForm1: IDF (char ch)
{((ch>='0')&&(ch<='9')) return
777;((ch>='a')&&(ch<='z')) return 777;(ch=='\0') return
999;return 666;
}
TForm1: RR (char ch)
{(ch=='\0') return 999; return 666;
}
String TForm1: GetState (int st) // функция определение состояния автомата по
его номеру
{res;(st) {0: res = «h»; break;1: res = «A»;
break;2: res = «B»; break;3: res = «C»; break;4: res = «D»; break;5: res = «E»;
break;6: res = «H»; break;7: res = «G»; break;8: res = «K»; break;9: res = «L»;
break;10: res = «M»; break;11: res = «R»; break;12: res = «N»; break;13: res =
«O»; break;14: res = «P»; break;15: res = «I»; break;16: res = «J»; break;17:
res = «Q»; break;18: res = «V»; break;19: res = «W»; break;20: res = «X»;
break;21: res = «Y»; break;22: res = «Z»; break;23: res = «T»; break;24: res =
«U»; break;25: res = «F»; break;26: res = «AA»; break;27: res = «AM»; break;28:
res = «AB»; break;29: res = «AC»; break;30: res = «AD»; break;31: res = «AG»;
break;32: res = «AF»; break;33: res = «AH»; break;34: res = «AI»; break;35: res
= «AE»; break;36: res = «AK»; break;37: res = «AL»; break;38: res = «AJ»;
break;39: res = «AN»; break;40: res = «AO»; break;41: res = «AP»; break;42: res
= «AQ»; break;43: res = «AR»; break;45: res = «AT»; break;46: res = «AU»;
break;47: res = «AV»; break;48: res = «AW»; break;49: res = «AX»; break;50: res
= «FF»; break;51: res = «RR»; break;777: res = «IDF»; break;666:res= «Err»;
break;999:res= «S»; break;
}res;
}
// -
__fastcall TForm1:TForm1 (TComponent* Owner)
: TForm(Owner)
{>Rows[0]->Add («Лексема»);>Rows[0]->Add
(«Тип лексемы»);>Rows[0]->Add
(«Лексема»);_rule = 0;
}
// -TForm1: AddTerminal (String filename) // считывание терминальных символов
{*input;*temp;= new char[32];= fopen
(filename.c_str(), «r»);i=0;(strcmp (temp, «over»))
{(input, «%s», temp);[i]=temp;++;
}[i]= "#»;
(int j=0; j<i; j++) {>Cols [j+1]->Add
(terminal[j]);(terminal[j]== «over») sgMatrix->Rows [j+1]->Add
(«bgn»);sgMatrix->Rows [j+1]->Add (terminal[j]);
}>ColCount = i+1;>RowCount = i+1;(input,
i);(input);
}
TForm1: AddMatrix (FILE *input, int n) // считывание матрицы предшествования
{i=0;*temp;= new char [32];_matrix = new int
*[n];(int i = 0; i < n; i++)_matrix[i] =new int[n];
(! feof(input))
{(input, «%s», temp);(int j=0; j<n; j++)
{(input, «%s», temp);(temp[0]=='<') mega_matrix[i] [j] = 1;(temp[0]=='>')
mega_matrix[i] [j] = 2;(temp[0]=='=') mega_matrix[i] [j] = 0;(temp[0]=='-')
mega_matrix[i] [j] = -1;>Cells [j+1] [i+1] = temp;
}++;
}
}
TForm1: index_terminal (String trm) // функция определния индекса терминала в массиве терм. симв.
{count=0;(trm== «bgn») trm =
«over»;(terminal[count]!= "#») {(trm==terminal[count]) return count;++;
}-1;
}
TForm1:first_terminal (int count) // функция возвращает первый терминальный символ в стеке
{(int i=count; i!=0; i-)
{(index_terminal (stack[i])!=-1) return i;
}
}
TForm1:cmp_substr (String sub1, String sub2) // функция сравнения двух символов
{(index_terminal(sub1)>=0&&index_terminal(sub2)>=0)mega_matrix
[index_terminal(sub1)] [index_terminal(sub2)];return -1;
}
TForm1:sdvig (int count_s, int count_l) // функция сдвига
{[count_s+1]=input_line [count_l];
}
int TForm1: AddRules() // функция добавления правил грамматики
{*temp = new char [32];*input = fopen
(«Rules.txt», «r»);i=0;(! feof(input))
{(temp, 256, input);[i] =
String(temp);[i].SetLength (rules[i].Length() - 1);(rules[i].Pos(«»))
{rules[i].Delete (rules[i].Pos(«»), 1);}++;
}i;
}
TForm1:cmp_rules (String rls, int n) // функция сравнение правил
{(int i=0; i<n; i++)
{(rls==rules[i]) return i;
}-1;
}
TForm1:package (int count_st, int n) // функция свертки
{trm, tV, Vt, VVt, V;ftrm = first_terminal
(count_st);= stack[ftrm];= trm + stack [ftrm+1];= stack [ftrm-1] + trm;= stack
[ftrm-1] + trm + stack [ftrm+1];= stack [ftrm-2]+ stack [ftrm-1]+trm;
(cmp_rules (trm, n)>=0)
{rez = cmp_rules (trm, n);[ftrm]= «S»;_rules [index_rule]=IntToStr(rez);_rule++;0;
}
(cmp_rules (V, n)>=0)
{rez = cmp_rules (V, n);right_empty = stack
[ftrm+1];[ftrm-1]= «S»;[ftrm]=»»;[ftrm+1]=»»;_rules
[index_rule]=IntToStr(rez);_rule++;(right_empty==»») return 1; else return 2;
}
(cmp_rules (Vt, n)>=0)
{rez = cmp_rules (Vt, n);[ftrm-1]=
«S»;[ftrm]=»»;_rules [index_rule]=IntToStr(rez);_rule++;1;
}
(cmp_rules (tV, n)>=0)
{rez = cmp_rules (tV, n);[ftrm]=
«S»;[ftrm+1]=»»;_rules [index_rule]=IntToStr(rez);_rule++;1;
}
(cmp_rules (VVt, n)>=0)
{rez = cmp_rules (VVt, n);[ftrm-2]=
«S»;[ftrm-1]=»»;[ftrm]=»»;_rules [index_rule]=IntToStr(rez);_rule++;2;
}
-1;
}
TForm1: Conclude (String X, char *temp, int i) //
определение типа лексемы
{(X== «AM») {_line[i]=AnsiString(temp);(«Круглая скобка»);
}(X== «RR») {_line[i]=AnsiString(temp);
return («Разделительный символ»);
}(X== «AX») {
input_line[i]= «g»;(«Константа»);
}(X== «F» || X== «FF» || X== «AA»)
{_line[i]=AnsiString(temp);(«Знак операции»);
}(X== «AD» || X== «AL» || X== «AF»)
{_line[i]=AnsiString(temp);(«Логическая операция»);
}(X== «G» || X== «M» || X== «O» || X== «Q»|| X==
«U»|| X== «Z»||X== «AI»||X== «AQ») {_line[i]=AnsiString(temp);(«Оператор»);
}(X== «AT» || X== «AV») return («Комментарий»);(X== «D» ||
X== «K») {_line[i]=AnsiString(temp);
return («Слово начала / конца программы»);
}(X== «AW») {_line[i]= «g»;(«Число»);
}(X== «Err») return («Ошибка»);{_line[i]=
«c»;(«Идентификатор»);
}
}
TForm1: Analiz (char *wInput) // функция анализа лексемы
{i = 0;State=0;Way= «h»;last=»»;(comment==1)
State = 45;{(State) {0: State = h (wInput[i]); break;1: State = A (wInput[i]);
break;2: State = B (wInput[i]); break;3: State = C (wInput[i]); break;4: State
= D (wInput[i]); break;5: State = E (wInput[i]); break;6: State = H
(wInput[i]); break;7: State = G (wInput[i]); break;8: State = K (wInput[i]);
break;9: State = L (wInput[i]); break;10: State = M (wInput[i]); break;11:
State = R (wInput[i]); break;12: State = N (wInput[i]); break;13: State = O
(wInput[i]); break;14: State = P (wInput[i]); break;15: State = I (wInput[i]);
break;16: State = J (wInput[i]); break;17: State = Q (wInput[i]); break;18:
State = V (wInput[i]); break;19: State = W (wInput[i]); break;20: State = X
(wInput[i]); break;21: State = Y (wInput[i]); break;22: State = Z (wInput[i]);
break;23: State = T (wInput[i]); break;24: State = U (wInput[i]); break;25:
State = F (wInput[i]); break;26: State = AA (wInput[i]); break;27: State = AM
(wInput[i]); break;28: State = AB (wInput[i]); break;29: State = AC
(wInput[i]); break;30: State = AD (wInput[i]); break;31: State = AG
(wInput[i]); break;32: State = AF (wInput[i]); break;33: State = AH
(wInput[i]); break;34: State = AI (wInput[i]); break;35: State = AE
(wInput[i]); break;36: State = AK (wInput[i]); break;37: State = AL (wInput[i]);
break;38: State = AJ (wInput[i]); break;39: State = AN (wInput[i]); break;40:
State = AO (wInput[i]); break;41: State = AP (wInput[i]); break;42: State = AQ
(wInput[i]); break;43: State = AR (wInput[i]); break;45: State = AT
(wInput[i]); break;46: State = AU (wInput[i]); break;47: State = AV
(wInput[i]); break;48: State = AW (wInput[i]); break;49: State = AX
(wInput[i]); break;50: State = FF (wInput[i]); break;51: State = RR
(wInput[i]); break;777: State = IDF (wInput[i]); break;999: State = IDF (wInput[i]);
break;666: break;
}=Way +» - «+GetState(State);(GetState(State)!=
«S») last = GetState(State);
} while (wInput [i++]!='\0');last;
}
__fastcall TForm1: Button1Click (TObject *Sender)
// непосредственно загрузка входного текста
{_chane=0;
i=1;*temp;= new char[32];= new
Identificator[256];
*inFile;=fopen («input.txt», «r»);(int i=0;
i<=255; i++) {HashTableChane[i]=0;}>Lines->Clear();
(! feof(inFile))
{(inFile, «%s», temp);(TableChane[i].Name,
temp);(i, TableChane, HashTableChane);
last = Analiz(temp);>Rows[i]->Add(temp);>Rows[i]->Add
(Conclude(last, temp, i-1));>Rows[i]->Add (input_line [i-1]);++;_line
[i-1]= «over»;>RowCount = i;
}(inFile);
Way;>Lines->LoadFromFile
(«input.txt»);->Lines->LoadFromFile
(«input.txt»);>Lines->LoadFromFile («Rules.txt»);
(«hyper_matrix.txt»);_rules =
AddRules();count_stack;[0] = «bgn»;
->Enabled = true;
}__fastcall TForm1: Button3Click (TObject
*Sender) // строим цепочку вывода
{stack_index = 0;lines_index = 0;[0]=
«bgn»;temp;cmp_rez;left;fl = 0;(1)
{((input_line [lines_index]== «over») &&
(stack[1]== «S») && (stack[2]==»»)) break;_rez = cmp_substr
(stack[first_terminal (stack_index)], input_line [lines_index]);(cmp_rez==1 ||
cmp_rez==0)
{(stack_index, lines_index);_index++;_index++;
}(cmp_rez==2)
{= package (stack_index, all_rules);(left == -1)
{fl=1; break;}stack_index= stack_index - left;
}(cmp_rez==-1) {fl=1; break;}
}(fl==1) {->Text= «Неправильная конструкция»;
} // далее можно поставить нужный разделительный символ
(сейчас пробел «»)
else for (int k = 0; k< index_rule; k++) temp
+= IntToStr (StrToInt(input_rules[k])+1) + «»;->Text=temp;->Enabled =
true;
}
void TForm1: AddChild (String child, int
ind_item) // добавление листьев к дереву
{lenght = child. Length();*rezult_child;temp_string=»»;_child
= new char [lenght];*Node1;= tree->Items->Item [ind_item];(rezult_child,
child.c_str());
(int i=0; i<lenght; i++)
{_string = temp_string +
rezult_child[i];(temp_string== «S»)
{>Items->AddChild (Node1,
temp_string);_string=»»;
}(rezult_child [i+1]!='.')(index_terminal
(temp_string)>=0)
{>Items->AddChild (Node1,
temp_string);_string=»»;
}
}
}
__fastcall TForm1: Button4Click (TObject *Sender)
// строим дерево
{*Node1;>Items->Clear();>Items->Add
(NULL, «S»);= tree->Items->Item[0];
(int j = index_rule; j>0; j-)
{n = tree->Items->Count;(int i=n-1;
i>=0; i-)
{(tree->Items->Item[i]->HasChildren ==
false)(tree->Items->Item[i]->Text == «S»)
{(rules[StrToInt (input_rules [j-1])], i);
break;
}
}
}
}
// -