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

date image 2020-01-14
views image 77
Поделись с друзьями: 
45678910

 

private void btnSintax_Click(object sender, EventArgs e)

{

string[,] Grammatic = {

/*0*/{"<S>", "USING", "<USING_LIST>", "<NEXT>", "", "", "", "", "", "", "", "", "", "", ""},

/*1*/{"<S>", "PUBLIC", "<CLASS>", "<NEXT>", "", "", "", "", "", "", "", "", "", "", ""},

/*2*/{"<NEXT>", ";", "<S>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*3*/{"<NEXT>", "e", "", "", "", "", "", "", "", "", "", "", "", "", ""},

/*4*/{"<USING_LIST>","ID", "<NEXT_USING>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*5*/{"<NEXT_USING>",".", "<USING_LIST>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*6*/{"<NEXT_USING>","e", "", "", "", "", "", "", "", "", "", "", "", "", ""},

/*7*/{"<CLASS>", "CLASS", "ID", "{", "<CLASS_BODY>", "}", "", "", "", "", "", "", "", "", ""},

/*8*/{"<CLASS_BODY>","PUBLIC", "<DEF>", "<NEXT_BODY>", "", "", "", "", "", "", "", "", "", "", ""},

/*9*/{"<NEXT_BODY>", ";", "<CLASS_BODY>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*10*/{"<NEXT_BODY>", "e", "", "", "", "", "", "", "", "", "", "", "", "", ""},

/*11*/{"<DEF>", "UINT", "<DEF_LIST>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*12*/{"<DEF>", "BOOL", "<DEF_LIST>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*13*/{"<DEF>", "CONST", "LONG", "INT", "<DEF_LIST>", "", "", "", "", "", "", "", "", "", ""},

/*14*/{"<DEF_LIST>", "ID", "<NEXT_DEF>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*15*/{"<NEXT_DEF>", "(", "<VAR_LIST>", ")", "{", "<OPER_LIST>", "}", "", "", "", "", "", "", "", ""},

/*16*/{"<NEXT_DEF>", ",", "<VAR_LIST>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*17*/{"<NEXT_DEF>", "=", "<EXPR>", "<NEXT_VAR>", "", "", "", "", "", "", "", "", "", "", ""},

/*18*/{"<NEXT_DEF>", "e", "", "", "", "", "", "", "", "", "", "", "", "", ""},

/*19*/{"<VAR_LIST>", "ID", "<NEXT_VAR>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*20*/{"<NEXT_VAR>", ",", "<VAR_LIST>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*21*/{"<NEXT_VAR>", "=", "<EXPR>", "<NEXT_VAR>", "", "", "", "", "", "", "", "", "", "", ""},

/*22*/{"<NEXT_VAR>", "e", "", "", "", "", "", "", "", "", "", "", "", "", ""},

/*23*/{"<OPER_LIST>", "<OPERATOR>", "<NEXT_OPER>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*24*/{"<NEXT_OPER>", ";", "<OPER_LIST>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*25*/{"<NEXT_OPER>", "e", "", "", "", "", "", "", "", "", "", "", "", "", ""},

/*26*/{"<OPERATOR>", "FOR", "(", "ID", "=", "<EXPR>", ";", "<COND>", ";", "ID", "<LET>", ")", "{", "<OPER_LIST>", "}"},

/*27*/{"<OPERATOR>", "break", "", "", "", "", "", "", "", "", "", "", "", "", ""},

/*28*/{"<OPERATOR>", "continue", "", "", "", "", "", "", "", "", "", "", "", "", ""},

/*29*/{"<OPERATOR>", "WRITE", "(", "<VAR_LIST>", ")", "", "", "", "", "", "", "", "", "", ""},

/*30*/{"<OPERATOR>", "READ", "(", "<VAR_LIST>", ")", "", "", "", "", "", "", "", "", "", ""},

/*31*/{"<OPERATOR>", "ID", "<LET>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*32*/{"<LET>", "=", "<EXPR>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*33*/{"<LET>", "*", "=", "<EXPR>", "", "", "", "", "", "", "", "", "", "", ""},

/*34*/{"<LET>", "/", "=", "<EXPR>", "", "", "", "", "", "", "", "", "", "", ""},

/*35*/{"<EXPR>", "(", "<EXPR>", ")", "<OPERATION>", "", "", "", "", "", "", "", "", "", ""},

/*36*/{"<EXPR>", "ID", "<OPERATION>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*37*/{"<EXPR>", "NUM", "<OPERATION>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*38*/{"<OPERATION>", "+", "<EXPR>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*39*/{"<OPERATION>", "-", "<EXPR>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*40*/{"<OPERATION>", "e", "", "", "", "", "", "", "", "", "", "", "", "", ""},

/*41*/{"<COND>", "(", "<COND>", ")", "<RELATION>", "", "", "", "", "", "", "", "", "", ""},

/*42*/{"<COND>", "<EXPR>", "<RELATION>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*43*/{"<RELATION>", ">", "<COND>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*44*/{"<RELATION>", "<", "<COND>", "", "", "", "", "", "", "", "", "", "", "", ""},

/*45*/{"<RELATION>", "=", "=", "<COND>", "", "", "", "", "", "", "", "", "", "", ""},

/*46*/{"<RELATION>", "e", "", "", "", "", "", "", "", "", "", "", "", "", ""},

};

System.Collections.Stack SintaxStack = new System.Collections.Stack();

SintaxStack.Push("#");

SintaxStack.Push("<S>");

 

String sTopStack, sLexeme, sClass;

SinAnalizerState SintaxState = SinAnalizerState.InProcess;

 

lSinProgress.Visible = false;

lvSinTable.Items.Clear();

 

int nLexNum = 0;

while (SintaxState == SinAnalizerState.InProcess)

{

sTopStack = (String) SintaxStack.Peek();

sLexeme = lvLexTable.Items[nLexNum].SubItems[0].Text;

sClass = lvLexTable.Items[nLexNum].SubItems[1].Text;

String[] subItems = {sTopStack, sLexeme, sClass};

lvSinTable.Items.Add(new ListViewItem(subItems));

 

if (sTopStack == "#")

{

SintaxState = (sLexeme == "#")?(SinAnalizerState.Accept):(SinAnalizerState.Error);

}

else if (sTopStack == "<S>")

{

if (sLexeme == "#")

{

SintaxStack.Pop();

}

else if (sLexeme == "PUBLIC")

{

Replace(SintaxStack, Grammatic, 1, 2);

nLexNum++;

}

else if (sLexeme == "USING")

{

Replace(SintaxStack, Grammatic, 0, 2);

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "LONG")

{

if (sLexeme == "LONG")

{

SintaxStack.Pop();

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "INT")

{

if (sLexeme == "INT")

{

SintaxStack.Pop();

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "(")

{

if (sLexeme == "(")

{

SintaxStack.Pop();

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == ")")

{

if (sLexeme == ")")

{

SintaxStack.Pop();

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == ";")

{

if (sLexeme == ";")

{

SintaxStack.Pop();

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "{")

{

if (sLexeme == "{")

{

SintaxStack.Pop();

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "}")

{

if (sLexeme == "}")

{

SintaxStack.Pop();

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<CLASS_BODY>")

{

if (sLexeme == "PUBLIC")

{

Replace(SintaxStack, Grammatic, 8, 2);

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<CLASS>")

{

if (sLexeme == "CLASS")

{

Replace(SintaxStack, Grammatic, 7, 2);

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<DEF_LIST>")

{

if (sClass == "Идентификатор")

{

Replace(SintaxStack, Grammatic, 14, 2);

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<DEF>")

{

if (sLexeme == "UINT")

{

Replace(SintaxStack, Grammatic, 11, 2);

nLexNum++;

}

else if (sLexeme == "BOOL")

{

Replace(SintaxStack, Grammatic, 12, 2);

nLexNum++;

}

else if (sLexeme == "CONST")

{

Replace(SintaxStack, Grammatic, 13, 2);

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<EXPR>")

{

if (sLexeme == "(")

{

Replace(SintaxStack, Grammatic, 35, 2);

nLexNum++;

}

else if (sClass == "Идентификатор")

{

Replace(SintaxStack, Grammatic, 36, 2);

nLexNum++;

}

else if (sClass == "Число")

{

Replace(SintaxStack, Grammatic, 37, 2);

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<LET>")

{

if (sLexeme == "/")

{

Replace(SintaxStack, Grammatic, 34, 2);

nLexNum++;

}

else if (sLexeme == "*")

{

Replace(SintaxStack, Grammatic, 33, 2);

nLexNum++;

}

else if (sLexeme == "=")

{

Replace(SintaxStack, Grammatic, 32, 2);

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<NEXT_BODY>")

{

if (sLexeme == ";")

{

Replace(SintaxStack, Grammatic, 9, 2);

nLexNum++;

}

else if (sLexeme == "}")

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<NEXT_DEF>")

{

if (sLexeme == "(")

{

Replace(SintaxStack, Grammatic, 15, 2);

nLexNum++;

}

else if (sLexeme == ",")

{

Replace(SintaxStack, Grammatic, 16, 2);

nLexNum++;

}

else if (sLexeme == "=")

{

Replace(SintaxStack, Grammatic, 17, 2);

nLexNum++;

}

else if (sLexeme == ";")

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<NEXT_OPER>")

{

if (sLexeme == ";")

{

Replace(SintaxStack, Grammatic, 24, 2);

nLexNum++;

}

else if (sLexeme == "}")

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<NEXT_USING>")

{

if (sLexeme == ".")

{

Replace(SintaxStack, Grammatic, 5, 2);

nLexNum++;

}

else if (sLexeme == ";")

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<NEXT_VAR>")

{

if (sLexeme == ",")

{

Replace(SintaxStack, Grammatic, 20, 2);

nLexNum++;

}

else if (sLexeme == "=")

{

Replace(SintaxStack, Grammatic, 21, 2);

nLexNum++;

}

else if ((sLexeme == ")") || (sLexeme == ";"))

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<NEXT>")

{

if (sLexeme == ";")

{

Replace(SintaxStack, Grammatic, 2, 2);

nLexNum++;

}

else if (sLexeme == "#")

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<OPER_LIST>")

{

if ((sLexeme == "FOR") ||

(sLexeme == "CONTINUE") ||

(sLexeme == "BREAK") ||

(sLexeme == "READ") ||

(sLexeme == "WRITE") ||

(sClass == "Идентификатор"))

{

Replace(SintaxStack, Grammatic, 23, 1);

}

else if (sLexeme == "}")

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<OPERATION>")

{

if (sLexeme == "+")

{

Replace(SintaxStack, Grammatic, 38, 2);

nLexNum++;

}

else if (sLexeme == "-")

{

Replace(SintaxStack, Grammatic, 39, 2);

nLexNum++;

}

else if ((sLexeme == ")") ||

 (sLexeme == ";") ||

 (sLexeme == ",") ||

 (sLexeme == ">") ||

 (sLexeme == "<") ||

 (sLexeme == "="))

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<OPERATOR>")

{

if (sLexeme == "FOR")

{

Replace(SintaxStack, Grammatic, 26, 2);

nLexNum++;

}

else if (sLexeme == "BREAK")

{

SintaxStack.Pop();

nLexNum++;

}

else if (sLexeme == "CONTINUE")

{

SintaxStack.Pop();

nLexNum++;

}

else if (sLexeme == "READ")

{

Replace(SintaxStack, Grammatic, 30, 2);

nLexNum++;

}

else if (sLexeme == "WRITE")

{

Replace(SintaxStack, Grammatic, 29, 2);

nLexNum++;

}

else if (sClass == "Идентификатор")

{

Replace(SintaxStack, Grammatic, 31, 2);

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<USING_LIST>")

{

if (sClass == "Идентификатор")

{

Replace(SintaxStack, Grammatic, 4, 2);

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<COND>")

{

if (sLexeme == "(")

{

Replace(SintaxStack, Grammatic, 41, 2);

nLexNum++;

}

else if ((sClass == "Идентификатор") ||

 (sClass == "Число"))

{

Replace(SintaxStack, Grammatic, 42, 1);

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<RELATION>")

{

if (sLexeme == ">")

{

Replace(SintaxStack, Grammatic, 43, 2);

nLexNum++;

}

else if (sLexeme == "<")

{

Replace(SintaxStack, Grammatic, 44, 2);

nLexNum++;

}

else if (sLexeme == "=")

{

Replace(SintaxStack, Grammatic, 45, 2);

nLexNum++;

}

else if ((sLexeme == ")") ||

 (sLexeme == ";"))

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "<VAR_LIST>")

{

if (sClass == "Идентификатор")

{

Replace(SintaxStack, Grammatic, 19, 2);

nLexNum++;

}

else if (sLexeme == ";")

{

SintaxStack.Pop();

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "=")

{

if (sLexeme == "=")

{

SintaxStack.Pop();

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else if (sTopStack == "ID")

{

if (sClass == "Идентификатор")

{

SintaxStack.Pop();

nLexNum++;

}

else SintaxState = SinAnalizerState.Error;

}

else SintaxState = SinAnalizerState.Error;

if (SintaxState == SinAnalizerState.Error)

{

lSinProgress.Text = "ОШИБКА! Неправильный синтаксис";

lSinProgress.ForeColor = Color.Red;

}

else if (SintaxState == SinAnalizerState.Accept)

{

lSinProgress.Text = "Синтаксический анализ завершен успешно!";

lSinProgress.ForeColor = Color.Blue;

}

}

lSinProgress.Visible = true;

btnSintax.Enabled = false;

синтаксическийАнализToolStripMenuItem.Enabled = false;

}

Цель данного проекта: практическое применение теории формальных грамматик и теории автоматов для проектирования трансляторов.

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

Учебный язык включает директиву using, функцию main(), описание переменных, констант, массива переменной длины, операторов присваивания, арифметические операции. За основу лексики, синтаксиса и семантики учебного языка принять стандарты языка программирования С#.

Рассмотренная регулярная грамматика может быть реализована автоматом с множеством состояний G: [S, I, C, E, R], где

S - состояние ожидания первого символа лексемы;

I - состояние ожидания символов идентификаторов: буквы, цифры;

С - состояние ожидания символов целой части числа;

E -состояние ошибки;

R - состояние допуска лексемы.

Автомат переходит в допустимое состояние R из состояний S, I, C по символу конца лексемы - пробел или разделительного знака. Автомат определен множеством перечисленных состояний, множеством правил [1, 2, …, 47] и множеством входных символов [00..9, A..Z, «–», «#», «(», «)», «*», «,», «.», «/», «:», «;», «{«, «}», «+», «=»], из которых символы подмножества [«–», «#», «(», «)», «*», «,», «/», «:», «;», «{«, «}», «+», «=»] являются одновременно разделительными символами и уникальными лексемами. Таблица переходов автомата распознавателя идентификаторов представлена ниже на таблице.

 

  L D e

 

  
S I E S

Нач. состояние

  
I I I R

 

  
E

Ошибка

  
R

Допустить

  

Множества ВЫБОР:

ВЫБОР(48) using
ВЫБОР(49) public
ВЫБОР(50) ;
ВЫБОР(51) #
ВЫБОР(52) ID
ВЫБОР(53) .
ВЫБОР(54) ;
ВЫБОР(55) class
ВЫБОР(56) public
ВЫБОР(57) ;
ВЫБОР(58) }
ВЫБОР(59) uint
ВЫБОР(60) bool
ВЫБОР(61) const
ВЫБОР(62) ID
ВЫБОР(63) (
ВЫБОР(64) ,
ВЫБОР(65) =
ВЫБОР(66) ;
ВЫБОР(67) ID
ВЫБОР(68) ,
ВЫБОР(69) =
ВЫБОР(70) )
ВЫБОР(71) for break continue write read ID
ВЫБОР(72) ;
ВЫБОР(73) }
ВЫБОР(74) for
ВЫБОР(75) break
ВЫБОР(76) continue
ВЫБОР(77) write
ВЫБОР(78) read
ВЫБОР(79) ID
ВЫБОР(80) =
ВЫБОР(81) *
ВЫБОР(82) /
ВЫБОР(83) (
ВЫБОР(84) ID
ВЫБОР(85) NUM
ВЫБОР(86) +
ВЫБОР(87) -
ВЫБОР(88) ID;) < > =
ВЫБОР(89) (
ВЫБОР(90) (ID NUM
ВЫБОР(91) >
ВЫБОР(92) <
ВЫБОР(93) =
ВЫБОР(94) ;)

 

  Формальная грамматика языка программирования:

Грамматика целевого символа:

(1) <S> -> using <USING_LIST> <NEXT>

(2) <S> -> public <CLASS> <NEXT>

(3) <NEXT> ->; <S>

(4) <NEXT> -> e

Грамматика описания using:

(5) <USING_LIST> -> ID <NEXT_USING>

(6) <NEXT_USING> ->. <USING_LIST>

(7) <NEXT_USING> -> e

Грамматика описания класса:

(8) <CLASS> -> class ID { <CLASS_BODY> }

(9) <CLASS_BODY> -> public <DEF> <NEXT_BODY>

(10) <NEXT_BODY> ->; <CLASS_BODY>

(11) <NEXT_BODY> -> e

Грамматика описания определения полей и методов класса:

(12) <DEF> -> uint <DEF_LIST>

(13) <DEF> -> bool <DEF_LIST>

(14) <DEF> -> const long int <DEF_LIST>

(15) <DEF_LIST> -> ID <NEXT_DEF>

(16) <NEXT_DEF> -> (<VAR_LIST>) { <OPER_LIST> }

(17) <NEXT_DEF> ->, <VAR_LIST>

(18) <NEXT_DEF> -> = <EXPR> <VAR_LIST>

(19) <NEXT_DEF> -> e

(20) <VAR_LIST> -> ID <NEXT_VAR>

(21) <NEXT_VAR> ->, <VAR_LIST>

(22) <NEXT_VAR> -> = <EXPR> <VAR_LIST>

(23) <NEXT_VAR> -> e


Грамматика описания списка операторов:

(24) <OPER_LIST> -> <OPERATOR> <NEXT_OPER>

(25) <NEXT_OPER> ->; <OPER_LIST>

(26) <NEXT_OPER> -> e

 

 

Грамматика описания операторов:

(27) <OPERATOR> -> for (ID = <EXPR>; <COND>; ID <LET>) { <OPER_LIST> }

(28) <OPERATOR> -> break

(29) <OPERATOR> -> continue

(30) <OPERATOR> -> write (<VAR_LIST>)

(31) <OPERATOR> -> read (<VAR_LIST>)

(32) <OPERATOR> -> ID <LET>

(33) <LET> -> = <EXPR>

(34) <LET> -> * = <EXPR>

(35) <LET> -> / = <EXPR>

Грамматика описания арифметического выражения:

(36) <EXPR> -> (<EXPR>) <OPERATION>

(37) <EXPR> -> ID <OPERATION>

(38) <EXPR> -> NUM <OPERATION>

(39) <OPERATION> -> + <EXPR>

(40) <OPERATION> -> - <EXPR>

(41) <OPERATION> -> e

Грамматика описания условия:

(42) <COND> -> (<COND>) <RELATION>

(43) <COND> -> <EXPR> <RELATION>

(44) <RELATION> -> > <COND>

(45) <RELATION> -> < <COND>

(46) <RELATION> -> = = <COND>

(47) <RELATION> -> e

 
               

Управляющая таблица синтаксического анализатора 

  / - # ( ) * , . ; { } + < = > bool break class const continue for ID int long NUM public read using write
#     Д                                                    
(       В С                                                  
)         В С                                                
;                 В С                                        
{                   В С                                      
}                     В С                                    
<CLASS_BODY>                                                   З(9, 2) С      
<CLASS>                                   З(8, 2) С                      
<COND>       З(42, 2) С                                   З(43, 1)     З(43, 1)        
<DEF_LIST>                                           З(15, 2) С              
<DEF>                               З(13, 2) С     З(14, 2) С                    
<EXPR>       З(36, 2) С                                   З(37, 2) С     З(38, 2) С        
<LET> З(35, 2) С         З(34, 2) С               З(33, 2) С                              
<NEXT_BODY>                 З(10, 2) С   В                                    
<NEXT_DEF>       З(16, 2) С     З(17, 2) С   В         З(18, 2) С                              
<NEXT_OPER>                 З(25, 2) С   В                                    
<NEXT_USING>               З(6, 2) С В                                        
<NEXT_VAR>         В   З(21, 2) С   В         З(22, 2) С                              
<NEXT>     В           З(3, 2) С                                        
<OPER_LIST>                     В           З(24, 1)     З(24, 1) З(24, 1) З(24, 1)         З(24, 1)   З(24, 1)
<OPERATION>   З(40, 2) С     В       В     З(39, 2) С В В В                            
<OPERATOR>                                 В С     В С З(27, 2) С З(32, 2) С         З(31, 2) С   З(30, 2) С
<RELATION>         В       В       З(45, 2) С З(46, 2) С З(44, 2) С                            
<S>     В                                             З(2, 2) С   З(1, 2) С  
<USING_LIST>                                           З(5, 2) С              
<VAR_LIST>                 В                         З(20, 2) С              
=                           В С                              
ID                                           В С              
int                                             В С            
long                                               В С          

 



Понравилась статья? Добавь ее в закладку (CTRL+D) и не забудь поделиться с друзьями:  

45678910

double arrow
Сейчас читают про:
article image
Источники международного права
article image
Контроль за санитарным состоянием тумбочек, холодильников, за ассортиментом и сроками хранения продуктов
article image
МЕТОДЫ ПРОГНОЗИРОВАНИЯ
article image
Назначение, устройство и работа делителя передач. Управление коробкой передач с делителем
article image
ВЫПИСКА, ХРАНЕНИЕ И ПРИМЕНЕНИЕ ЛЕКАРСТВЕННЫХ СРЕДСТВ
article image
Методы воспитания
article image
Самый сильный аргумент, почему эволюция человека не могла быть

Тот способен, кто полагает себя способным, и тот неспособен, кто полагает себя неспособным. Это непреклонный, неоспоримый закон. © Пикассо ==> читать все изречения...
like icon 6512
like icon 6432
Понравился сайт? Поделись им с друзьями: