{"id":26087,"date":"2016-04-02T22:54:46","date_gmt":"2016-04-02T19:54:46","guid":{"rendered":"http:\/\/studentpmr.ru\/?p=26087"},"modified":"2016-04-02T22:54:46","modified_gmt":"2016-04-02T19:54:46","slug":"%d1%82%d1%8f%d0%bf-%d0%bb%d0%b0%d0%b1%d0%be%d1%80%d0%b0%d1%82%d0%be%d1%80%d0%bd%d0%b0%d1%8f-%d1%80%d0%b0%d0%b1%d0%be%d1%82%d0%b0-2-%d0%b8%d1%81%d1%85%d0%be%d0%b4%d0%bd%d0%b8%d0%ba%d0%b8","status":"publish","type":"post","link":"https:\/\/studentpmr.ru\/?p=26087","title":{"rendered":"\u0422\u042f\u041f \u2014 \u043b\u0430\u0431\u043e\u0440\u0430\u0442\u043e\u0440\u043d\u0430\u044f \u0440\u0430\u0431\u043e\u0442\u0430 2. \u0418\u0441\u0445\u043e\u0434\u043d\u0438\u043a\u0438 «\u0440\u0430\u0441\u043f\u043e\u0437\u043d\u0430\u0432\u0430\u0442\u0435\u043b\u044f»."},"content":{"rendered":"

\u0424\u0430\u0439\u043b Token.cs<\/strong><\/p>\n

using System;<\/p>\n

using System.Collections.Generic;
\nusing System.Collections;
\nusing System.Text;<\/p>\n

namespace \u0422\u042f\u041f_\u043b\u04312_\u043c6
\n{
\nenum TokenType { ERROR =0, Num, Identificator, BracketLeft, BracketRight, Not, End, Assign, OperatorBoolean};<\/p>\n

<\/p>\n

enum LexType { Terminal = 0, Nonterminal};<\/p>\n

enum LexRelation { Empty=0, Equality, Before, After};<\/p>\n

delegate TokenType ChangeState(TokenType type);<\/p>\n

class Token
\n{
\n#region \u041f\u043e\u043b\u044f
\nprivate TokenType type;
\nprivate string name;
\n#endregion<\/p>\n

#region \u041a\u043e\u043d\u0441\u0442\u0440\u0443\u043a\u0442\u043e\u0440\u044b
\npublic Token()
\n{
\ntype = TokenType.Identificator;
\nname = «»;
\n}<\/p>\n

public Token(TokenType type, string name)
\n{
\nthis.type = type;
\nthis.name = name;
\n}
\n#endregion<\/p>\n

#region \u0421\u0432\u043e\u0439\u0441\u0442\u0432\u0430
\npublic TokenType Type
\n{
\nget { return this.type; }
\nset { this.type = value; }
\n}<\/p>\n

public string Name
\n{
\nget { return this.name; }
\nset { this.name = value; }
\n}
\n#endregion<\/p>\n

#region \u041c\u0435\u0442\u043e\u0434\u044b
\nstatic bool IsLiter(char ch)
\n{
\nreturn ch >= ‘a’ && ch<=’z’ || ch>=’A’ && ch <=’Z’|| ch== ‘_’;
\n}<\/p>\n

static bool IsDigit(char ch)
\n{
\nreturn ch==’0′ || ch==’1′;
\n}<\/p>\n

public static Token[] GetTokens(string bufer)
\n{
\nList<Token> tokens = new List<Token>();
\nstring tempName = «»;
\nToken tempToken;<\/p>\n

for (int i = 0; i < bufer.Length; i++)
\n{
\ntempName = «»;<\/p>\n

#region \u0411\u0443\u043a\u0432\u0435\u043d\u043d\u044b\u0435 \u0441\u043b\u043e\u0432\u0430
\nif(Token.IsLiter(bufer[i]))
\n{
\ndo
\n{
\ntempName += bufer[i];
\ni++;
\n}
\nwhile(i < bufer.Length && (Token.IsLiter(bufer[i]) || Char.IsDigit(bufer[i])));<\/p>\n

tempToken = new Token();
\ntempToken.Name = tempName;
\nswitch (tempName)
\n{
\ncase «not»:
\ntempToken.Type = TokenType.Not;
\nbreak;
\ncase «or»:
\ncase «xor»:
\ncase «and»:
\ntempToken.Type = TokenType.OperatorBoolean;
\nbreak;
\ndefault:
\ntempToken.Type = TokenType.Identificator;
\nbreak;
\n}
\ntokens.Add(tempToken);
\ntempName = «»;
\ni—;
\ncontinue;
\n}
\n#endregion<\/p>\n

#region \u0426\u0438\u0444\u0440\u043e\u0432\u044b\u0435 \u0441\u043b\u043e\u0432\u0430
\nif (Char.IsDigit(bufer[i]))
\n{
\ndo
\n{
\ntempName += bufer[i];
\ni++;
\n}
\nwhile (i < bufer.Length && Char.IsDigit(bufer[i]));<\/p>\n

if (tempName == «0» || tempName == «1»)
\n{
\ntempToken = new Token(TokenType.Num, tempName);
\ntokens.Add(tempToken);
\n}
\nelse
\n{
\ntempToken = new Token(TokenType.ERROR, tempName);
\ntokens.Add(tempToken);
\n}
\ntempName = «»;
\ni—;
\ncontinue;
\n}
\n#endregion<\/p>\n

tempName += bufer[i];<\/p>\n

switch(bufer[i])
\n{
\ncase ‘(‘:
\ntempToken = new Token(TokenType.BracketLeft, tempName);
\ntokens.Add(tempToken);
\nbreak;
\ncase ‘)’:
\ntempToken = new Token(TokenType.BracketRight, tempName);
\ntokens.Add(tempToken);
\nbreak;
\ncase ‘;’:
\ntempToken = new Token(TokenType.End, tempName);
\ntokens.Add(tempToken);
\nbreak;
\ncase’ ‘:
\ncase ‘\\n’:
\ncase ‘\\0’:
\nbreak;
\ncase ‘:’:
\nif (i+1 < bufer.Length && bufer[i+1] == ‘=’)
\n{
\ntempName += bufer[i+1];
\ni++;
\ntempToken = new Token(TokenType.Assign, tempName);
\ntokens.Add(tempToken);
\n}
\nelse
\n{
\ntempToken = new Token(TokenType.ERROR, tempName);
\ntokens.Add(tempToken);
\n}
\nbreak;
\ndefault:
\ntempToken = new Token(TokenType.ERROR, tempName);
\ntokens.Add(tempToken);
\nbreak;
\n}
\n}
\nreturn tokens.ToArray();
\n}<\/p>\n

public static bool ScanBool(Token[] tokens, int iStart, int iEnd)
\n{
\nif(iStart >= tokens.Length || iStart > iEnd)
\nreturn true;
\n\/\/
\nint brackets = 0;
\nTokenType currentState;
\nChangeState changeState = StateStartBool;
\n\/\/
\ncurrentState = changeState(tokens[iStart].type);
\nif (currentState == TokenType.BracketLeft) brackets++;<\/p>\n

for (int i = iStart+1; i <= iEnd && i < tokens.Length; i++)
\n{
\nif (currentState == TokenType.ERROR)
\nbreak;
\nswitch (currentState)
\n{
\ncase TokenType.Identificator:
\nchangeState = StateIdentificator;
\nbreak;
\ncase TokenType.Num:
\nchangeState = StateNum;
\nbreak;
\ncase TokenType.Assign:
\nchangeState = StateAssign;
\nbreak;
\ncase TokenType.Not:
\nchangeState = StateNot;
\nbreak;
\ncase TokenType.BracketLeft:
\nchangeState = StateBracketLeft;
\nbreak;
\ncase TokenType.BracketRight:
\nchangeState = StateBracketRight;
\nbreak;
\ncase TokenType.OperatorBoolean:
\nchangeState = StateOperatorBool;
\nbreak;
\n}
\ncurrentState = changeState(tokens[i].type);
\nif (currentState == TokenType.BracketLeft) brackets++;
\nif (currentState == TokenType.BracketRight) brackets—;
\nif (brackets < 0)
\n{
\ncurrentState = TokenType.ERROR;
\nbreak;
\n}
\n}
\n\/\/
\nif (brackets != 0)
\nreturn false;
\nif (currentState == TokenType.BracketRight)
\nreturn true;
\nif (currentState == TokenType.Num)
\nreturn true;
\nif (currentState == TokenType.Identificator)
\nreturn true;
\nreturn false;
\n}<\/p>\n

public static bool ScanGeneral(Token[] tokens, int iStart, int iEnd)
\n{
\nbool result = true;
\nint iPoint;
\nint i = iStart;
\n\/\/
\nwhile (i < iEnd && i < tokens.Length && result)
\n{
\niPoint = Token.IndexOf(TokenType.End, tokens, i, tokens.Length — 1);
\nif ((iPoint — i) == 0) { i++; continue; }
\nif (iPoint < 3) return false;<\/p>\n

result &= tokens[i].Type == TokenType.Identificator;
\ni++;
\nresult &= tokens[i].Type == TokenType.Assign;
\ni++;
\nresult &= ScanBool(tokens, i, iPoint — 1);
\ni = iPoint+1;
\n}<\/p>\n

return result;
\n}<\/p>\n

public static int IndexOf(TokenType tokenType, Token[] tokens, int iStart, int iEnd)
\n{
\nfor (int i = iStart; i <= iEnd && i < tokens.Length; i++)
\nif (tokens[i].Type == tokenType)
\nreturn i;
\nreturn -1;
\n}<\/p>\n

#region \u0421\u043e\u0441\u0442\u043e\u044f\u043d\u0438\u044f
\npublic static TokenType StateStartBool(TokenType type)
\n{
\nTokenType result;
\nswitch (type)
\n{
\ncase TokenType.Not:
\nresult = TokenType.Not;
\nbreak;
\ncase TokenType.Identificator:
\nresult = TokenType.Identificator;
\nbreak;
\ncase TokenType.Num:
\nresult = TokenType.Num;
\nbreak;
\ncase TokenType.BracketLeft:
\nresult = TokenType.BracketLeft;
\nbreak;
\n\/\/case TokenType.BracketRight:
\n\/\/ result = TokenType.BracketRight;
\n\/\/ break;
\ndefault:
\nresult = TokenType.ERROR;
\nbreak;
\n}
\nreturn result;
\n}<\/p>\n

public static TokenType StateIdentificator(TokenType type)
\n{
\nTokenType result;
\nswitch (type)
\n{
\ncase TokenType.OperatorBoolean:
\nresult = TokenType.OperatorBoolean;
\nbreak;
\ncase TokenType.Assign:
\nresult = TokenType.Assign;
\nbreak;
\ncase TokenType.BracketRight:
\nresult = TokenType.BracketRight;
\nbreak;
\ndefault:
\nresult = TokenType.ERROR;
\nbreak;
\n}
\nreturn result;
\n}<\/p>\n

public static TokenType StateAssign(TokenType type)
\n{
\nTokenType result;
\nswitch (type)
\n{
\ncase TokenType.Not:
\nresult = TokenType.Not;
\nbreak;
\ncase TokenType.Identificator:
\nresult = TokenType.Identificator;
\nbreak;
\ncase TokenType.Num:
\nresult = TokenType.Num;
\nbreak;
\ncase TokenType.BracketLeft:
\nresult = TokenType.BracketLeft;
\nbreak;
\ndefault:
\nresult = TokenType.ERROR;
\nbreak;
\n}
\nreturn result;
\n}<\/p>\n

public static TokenType StateBracketLeft(TokenType type)
\n{
\nTokenType result;
\nresult = StateStartBool(type);
\nreturn result;
\n}<\/p>\n

public static TokenType StateBracketRight(TokenType type)
\n{
\nTokenType result;
\nswitch (type)
\n{
\ncase TokenType.OperatorBoolean:
\nresult = TokenType.OperatorBoolean;
\nbreak;
\ncase TokenType.BracketRight:
\nresult = TokenType.BracketRight;
\nbreak;
\ndefault:
\nresult = TokenType.ERROR;
\nbreak;
\n}
\nreturn result;
\n}<\/p>\n

public static TokenType StateNot(TokenType type)
\n{
\nTokenType result;
\nswitch (type)
\n{
\ncase TokenType.Identificator:
\nresult = TokenType.Identificator;
\nbreak;
\ncase TokenType.Num:
\nresult = TokenType.Num;
\nbreak;
\ncase TokenType.BracketLeft:
\nresult = TokenType.BracketLeft;
\nbreak;
\ndefault:
\nresult = TokenType.ERROR;
\nbreak;
\n}
\nreturn result;
\n}<\/p>\n

public static TokenType StateOperatorBool(TokenType type)
\n{
\nTokenType result;
\nswitch (type)
\n{
\ncase TokenType.Not:
\nresult = TokenType.Not;
\nbreak;
\ncase TokenType.Identificator:
\nresult = TokenType.Identificator;
\nbreak;
\ncase TokenType.Num:
\nresult = TokenType.Num;
\nbreak;
\ncase TokenType.BracketLeft:
\nresult = TokenType.BracketLeft;
\nbreak;
\ndefault:
\nresult = TokenType.ERROR;
\nbreak;
\n}
\nreturn result;
\n}<\/p>\n

public static TokenType StateNum(TokenType type)
\n{
\nTokenType result;
\nswitch (type)
\n{
\ncase TokenType.OperatorBoolean:
\nresult = TokenType.OperatorBoolean;
\nbreak;
\ncase TokenType.BracketRight:
\nresult = TokenType.BracketRight;
\nbreak;
\ndefault:
\nresult = TokenType.ERROR;
\nbreak;
\n}
\nreturn result;
\n}
\n#endregion<\/p>\n

public override string ToString()
\n{
\nreturn this.type.ToString()+» «+this.name;
\n}
\n#endregion
\n}<\/p>\n

class Lex
\n{
\n#region \u041f\u043e\u043b\u044f
\nprivate Token _token;
\nprivate string _name;
\nprivate LexType _type;
\n#endregion<\/p>\n

#region \u041a\u043e\u043d\u0441\u0442\u0440\u0443\u043a\u0442\u043e\u0440\u044b
\npublic Lex()
\n{
\nthis._name = null;
\nthis._token = null;
\nthis._type = LexType.Nonterminal;
\n}<\/p>\n

public Lex(string name, LexType type)
\n{
\nthis._name = name;
\nthis._token = null;
\nthis._type = type;
\n}<\/p>\n

public Lex(Token token)
\n{
\nthis._token = token;
\nthis._name = token.Name;
\nthis._type = LexType.Terminal;
\n}
\n#endregion<\/p>\n

#region \u0421\u0432\u043e\u0439\u0441\u0442\u0432\u0430
\npublic Token Token
\n{
\nget { return this._token; }
\nset
\n{
\nthis._token = value;
\nif (value != null)
\n{
\nthis._type = LexType.Terminal;
\nthis._name = value.Name;
\n}
\n}
\n}<\/p>\n

public LexType Type
\n{
\nget { return this._type; }
\nset { this._type = value; }
\n}<\/p>\n

public string Name
\n{
\nget { return this._name; }
\nset { this._name = value; }
\n}
\n#endregion<\/p>\n

#region \u041c\u0435\u0442\u043e\u0434\u044b
\npublic override string ToString()
\n{
\nif (this._token == null) return this._name;
\nelse return this.Token.Name;
\n}<\/p>\n

public Lex Clone()
\n{
\nLex clone = new Lex();
\nclone._token = this._token;
\nclone._name = this._name;
\nclone._type = this._type;
\nreturn clone;
\n}<\/p>\n

static public int[] GetRules(Token[] tokens, LexRuleTable ruleTable, LexRelationTable relationTable, Lex lexStart, Lex lexEnd)
\n{
\nList<int> ruleList;
\nint ruleNumber;
\nList<Lex> tempList;
\nStack<Lex> bufer, magazine;
\nLex tempCur, tempNext;
\nLexRelation relation;
\n\/\/
\nruleList = new List<int>();
\ntempList = new List<Lex>();
\nbufer = new Stack<Lex>();
\nmagazine = new Stack<Lex>();
\n\/\/
\nmagazine.Push(lexStart);
\nbufer.Push(lexEnd);
\nfor (int i = tokens.Length — 1; i >= 0; i—)
\n{
\ntempCur = new Lex(tokens[i]);
\nif (tempCur.Token.Type == TokenType.Num || tempCur.Token.Type == TokenType.Identificator)
\ntempCur.Name = «a»;
\nbufer.Push(tempCur);
\n}<\/p>\n

while (bufer.Count > 0)
\n{
\ntempCur = magazine.Peek();
\ntempNext = bufer.Peek();
\nrelation = relationTable.GetRelation(tempCur.Name, tempNext.Name);
\nswitch (relation)
\n{
\ncase LexRelation.Before:
\ncase LexRelation.Equality:
\nmagazine.Push(bufer.Pop());
\nbreak;
\ncase LexRelation.After:
\ntempNext = magazine.Pop();
\ntempCur = magazine.Peek();
\ntempList.Add(tempNext);
\nwhile (relationTable.GetRelation(tempCur.Name, tempNext.Name) == LexRelation.Equality)
\n{
\ntempNext = magazine.Pop();
\ntempCur = magazine.Peek();
\ntempList.Insert(0, tempNext);
\n}
\ntempCur = ruleTable.GetParient(tempList.ToArray(), out ruleNumber);
\ntempList.Clear();
\nif (tempCur == null) return ruleList.ToArray();
\nruleList.Add(ruleNumber);
\nmagazine.Push(tempCur);
\nbreak;
\ndefault:
\nreturn ruleList.ToArray();
\nbreak;
\n}
\n}
\n\/\/
\nreturn ruleList.ToArray();
\n}
\n#endregion
\n}<\/p>\n

class Tree
\n{
\n#region \u041f\u043e\u043b\u044f
\nprivate Lex _current;
\nprivate List<Tree> _children;
\n#endregion<\/p>\n

#region \u041a\u043e\u043d\u0441\u0442\u0440\u0443\u043a\u0442\u043e\u0440\u044b
\npublic Tree()
\n{
\nthis._current = new Lex();
\nthis._children = new List<Tree>(3);
\n}<\/p>\n

public Tree(Tree parient)
\n{
\nthis._current = new Lex();
\nthis._children = new List<Tree>(3);
\n}<\/p>\n

public Tree(Lex lex)
\n{
\nthis._current = lex;
\nthis._children = new List<Tree>(3);
\n}<\/p>\n

public Tree(Lex lex, Tree parient)
\n{
\nthis._current = lex;
\nthis._children = new List<Tree>(3);
\n}
\n#endregion<\/p>\n

#region \u0421\u0432\u043e\u0439\u0441\u0442\u0432\u0430
\npublic Lex Current
\n{
\nget { return this._current; }
\nset { this._current = value; }
\n}<\/p>\n

public List<Tree> Children
\n{
\nget { return this._children; }
\nset { this._children = value; }
\n}
\n#endregion<\/p>\n

#region \u041c\u0435\u0442\u043e\u0434\u044b
\nprivate int GenerateNumber(Random rand, Lex lex, LexRuleTable table, int[] count, int[] decrements)
\n{
\nfloat[] p = new float[count.Length];
\nint maxindex;
\nint[] ruleNums;
\nfloat a;
\nLex tempLex;
\nfor (int i = 0; i < p.Length; i++)
\n{
\na = (float)rand.NextDouble() * 100;
\np[i] = a \/ (float)count[i];
\n}<\/p>\n

tempLex = lex;
\nruleNums = table.GetRuleNums(tempLex);
\nif (ruleNums == null)
\nreturn -1;
\nmaxindex = ruleNums[0];<\/p>\n

for (int i = 1; i < ruleNums.Length; i++)
\n{
\nif (p[ruleNums[i]] > p[maxindex])
\n{
\nmaxindex = ruleNums[i];
\n}
\n}
\ncount[maxindex] += decrements[maxindex];
\nreturn maxindex;
\n}<\/p>\n

private void GenerateChildren(LexRuleTable table, int[] count, int[] decrements, Random rand)
\n{
\nif (this._current.Type == LexType.Terminal || table == null) return;<\/p>\n

if (this._children == null) this._children = new List<Tree>(3);<\/p>\n

int ruleNum = this.GenerateNumber(rand, this._current, table, count, decrements);<\/p>\n

if (ruleNum < 0) return;<\/p>\n

List<Lex> tempListLex;<\/p>\n

this._children = new List<Tree>();
\ntempListLex = table.GetChildren(this._current, ruleNum);
\nfor (int i = 0; i < tempListLex.Count;i++ )
\nthis._children.Add(new Tree(tempListLex[i]));
\n}<\/p>\n

public void GenerateTree(LexRuleTable table, int[] count, int[] decrements)
\n{
\nif (this._current == null || this._current.Type == LexType.Terminal)
\nreturn;<\/p>\n

Random rand = new Random((int)DateTime.Now.Millisecond);<\/p>\n

this.GenerateChildren(table, count, decrements, rand);<\/p>\n

for (int i = this._children.Count-1; i >= 0; i—)
\nthis._children[i].GenerateTree(table, count, decrements);
\n}<\/p>\n

public void GetLexes(List<Lex> lexes)
\n{
\nfor (int i = 0; i < this._children.Count; i++)
\nif (this._children[i]._current.Type == LexType.Nonterminal)
\nthis._children[i].GetLexes(lexes);
\nelse
\nlexes.Add(this._children[i]._current);
\n}<\/p>\n

public void BuildTree(Stack<int> rules, LexRuleTable ruleTable, Stack<Token> tokens)
\n{
\nif (this._current.Type == LexType.Terminal || rules.Count <=0) return;<\/p>\n

Lex tempLex;
\nint i;
\nint ruleNumber = rules.Pop();
\nList<Lex> children = ruleTable.GetChildren(this._current, ruleNumber);<\/p>\n

if (children == null)
\n{
\nrules.Push(ruleNumber);
\nreturn;
\n}<\/p>\n

if (this._children == null)
\nthis._children = new List<Tree>(children.Count);<\/p>\n

for (i = 0; i < children.Count; i++)
\n{
\ntempLex = children[i].Clone();
\nthis._children.Add(new Tree(tempLex));
\n}<\/p>\n

for (i = this._children.Count — 1; i >= 0; i—)
\nif (this._children[i].Current.Type == LexType.Nonterminal)
\nthis._children[i].BuildTree(rules, ruleTable, tokens);
\nelse
\nif (tokens.Count > 0)
\nthis._children[i].Current.Token = tokens.Pop();
\n}<\/p>\n

public void OptimizeTranzetive()
\n{
\nwhile (this.Children.Count == 1 && this.Children[0] != null)
\n{
\nif (this.Children[0].Current.Type == LexType.Nonterminal)
\nthis.Children = this.Children[0].Children;
\nelse
\n{
\nthis.Current = this.Children[0].Current;
\nthis.Children = null;
\nreturn;
\n}
\n}<\/p>\n

for (int i = 0; i < this.Children.Count; i++)
\nif (this.Children[i] != null && this.Children[i].Current.Type == LexType.Nonterminal)
\nthis.Children[i].OptimizeTranzetive();
\n}<\/p>\n

public void OptimizeBrackets()
\n{
\nwhile (this.Children.Count == 3 && this.Children[0] != null && this.Children[0].Current.Type == LexType.Terminal && this.Children[0].Current.Token.Type == TokenType.BracketLeft)
\n{
\nif (this.Children[1].Current.Type == LexType.Nonterminal)
\nthis.Children = this.Children[1].Children;
\nelse
\n{
\nthis.Current = this.Children[1].Current;
\nthis.Children = null;
\nreturn;
\n}
\n}<\/p>\n

while (this.Children.Count == 4 && this.Children[0] != null && this.Children[0].Current.Type == LexType.Terminal && this.Children[0].Current.Token.Type == TokenType.Not)
\n{
\nthis.Children.RemoveRange(3, 1);
\nthis.Children.RemoveRange(1, 1);
\n}<\/p>\n

for (int i = 0; i < this.Children.Count; i++)
\nif (this.Children[i] != null && this.Children[i].Current.Type == LexType.Nonterminal)
\nthis.Children[i].OptimizeBrackets();
\n}
\n#endregion
\n}<\/p>\n

class LexRuleTable
\n{
\n#region \u041f\u043e\u043b\u044f
\nprivate List<int> _number;
\nprivate List<Lex> _lexesParient;
\nprivate List<List<Lex>> _lexesChildren;
\n#endregion<\/p>\n

#region \u041a\u043e\u043d\u0441\u0442\u0440\u0443\u043a\u0442\u043e\u0440\u044b
\npublic LexRuleTable()
\n{
\nthis._number = new List<int>();
\nthis._lexesParient = new List<Lex>();
\nthis._lexesChildren = new List<List<Lex>>();
\n}
\n#endregion<\/p>\n

#region \u041c\u0435\u0442\u043e\u0434\u044b
\npublic void Add(Lex parient, List<Lex> children, int ruleNumber)
\n{
\nthis._number.Add(ruleNumber);
\nthis._lexesParient.Add(parient);
\nthis._lexesChildren.Add(children);
\n}<\/p>\n

public void Add(Lex parient, Lex[] children, int ruleNumber)
\n{
\nthis._number.Add(ruleNumber);
\nthis._lexesParient.Add(parient);
\nList<Lex> tempList = new List<Lex>(children.Length);
\nfor (int i = 0; i < children.Length;i++ )
\ntempList.Add(children[i]);
\nthis._lexesChildren.Add(tempList);
\n}<\/p>\n

public void Remove(Lex parient, Lex[] children, int ruleNumber)
\n{
\nint i = 0, j = 0;
\nfor (i = 0; i < this._lexesParient.Count; i++)
\n{
\nif (this._lexesChildren[i].Count == children.Length)
\nfor (j = 0; j < children.Length; j++)
\nif (this._lexesChildren[i][j].Name != children[j].Name)
\nbreak;
\nif (j >= children.Length)
\n{
\nthis._number.RemoveRange(i, 1);
\nthis._lexesParient.RemoveRange(i, 1);
\nthis._lexesChildren.RemoveRange(i, 1);
\nbreak;
\n}
\n}
\n}<\/p>\n

public void Remove(Lex parient, List<Lex> children, int ruleNumber)
\n{
\nint i = 0, j = 0;
\nfor (i = 0; i < this._lexesParient.Count; i++)
\n{
\nif (this._lexesChildren[i].Count == children.Count)
\nfor (j = 0; j < children.Count; j++)
\nif (this._lexesChildren[i][j].Name != children[j].Name)
\nbreak;
\nif (j >= children.Count)
\n{
\nthis._number.RemoveRange(i, 1);
\nthis._lexesParient.RemoveRange(i, 1);
\nthis._lexesChildren.RemoveRange(i, 1);
\nbreak;
\n}
\n}
\n}<\/p>\n

public Lex GetParient(Lex[] children, out int ruleNumber)
\n{
\nint i = 0, j = 0;
\nfor (i = 0; i < this._lexesParient.Count; i++)
\n{
\nif (this._lexesChildren[i].Count == children.Length)
\nfor (j = 0; j < children.Length; j++)
\nif (this._lexesChildren[i][j].Name != children[j].Name)
\nbreak;
\nif (j == children.Length)
\n{
\nruleNumber = this._number[i];
\nreturn this._lexesParient[i];
\n}
\n}
\nruleNumber = -1;
\nreturn null;
\n}<\/p>\n

public Lex GetParient(List<Lex> children, out int ruleNumber)
\n{
\nint i = 0, j = 0;
\nfor (i = 0; i < this._lexesParient.Count; i++)
\n{
\nif (this._lexesChildren[i].Count == children.Count)
\nfor (j = 0; j < children.Count; j++)
\nif (this._lexesChildren[i][j].Name != children[j].Name)
\nbreak;
\nif (j == children.Count)
\n{
\nruleNumber = this._number[i];
\nreturn this._lexesParient[i];
\n}
\n}
\nruleNumber = -1;
\nreturn null;
\n}<\/p>\n

public int GetRuleNum(Lex[] children)
\n{
\nint i = 0, j = 0;
\nfor (i = 0; i < this._lexesParient.Count; i++)
\n{
\nif (this._lexesChildren[i].Count == children.Length)
\nfor (j = 0; j < children.Length; j++)
\nif (this._lexesChildren[i][j].Name != children[j].Name)
\nbreak;
\nif (j == children.Length)
\n{
\nreturn this._number[i];
\n}
\n}
\nreturn -1;
\n}<\/p>\n

public int GetRuleNum(List<Lex> children)
\n{
\nint i = 0, j = 0;
\nfor (i = 0; i < this._lexesParient.Count; i++)
\n{
\nif (this._lexesChildren[i].Count == children.Count)
\nfor (j = 0; j < children.Count; j++)
\nif (this._lexesChildren[i][j].Name != children[j].Name)
\nbreak;
\nif (j == children.Count)
\n{
\nreturn this._number[i];
\n}
\n}
\nreturn -1;
\n}<\/p>\n

public List<Lex> GetChildren(Lex parient, int ruleNumber)
\n{
\nint i = 0;
\nfor (i = 0; i < this._lexesParient.Count; i++)
\n{
\nif (this._number[i] == ruleNumber && this._lexesParient[i].Name == parient.Name)
\nreturn this._lexesChildren[i];
\n}
\nreturn null;
\n}<\/p>\n

public int[] GetRuleNums(Lex parient)
\n{
\nList<int> result = new List<int>();
\nint i = 0;
\nfor (i = 0; i < this._lexesParient.Count; i++)
\n{
\nif (this._lexesParient[i].Name == parient.Name)
\nresult.Add(this._number[i]);
\n}
\nif (result.Count == 0)
\nreturn null;
\nelse
\nreturn result.ToArray();
\n}<\/p>\n

public override string ToString()
\n{
\nstring outline= «\u041f\u0440\u0430\u0432\u0438\u043b\u0430»;
\nfor (int i = 0; i < this._number.Count; i++)
\n{
\noutline += «\\n» + this._number[i] + » : » + this._lexesParient[i].Name + » ->»;
\nfor (int j = 0; j < this._lexesChildren[i].Count; j++)
\noutline += » » + this._lexesChildren[i][j].Name;
\n}
\nreturn outline;
\n}
\n#endregion
\n}
\n\/\/
\nclass LexRelationTable
\n{
\nprivate List<string> _lexCur, _lexNext;
\nprivate List<LexRelation> _relations;<\/p>\n

public LexRelationTable()
\n{
\nthis._lexCur = new List<string>();
\nthis._lexNext = new List<string>();
\nthis._relations = new List<LexRelation>();
\n}<\/p>\n

public int Count
\n{
\nget { return this._relations.Count; }
\n}<\/p>\n

public void Add(string lexCurrent, string lexNext, LexRelation relation)
\n{
\nthis._lexCur.Add(lexCurrent);
\nthis._lexNext.Add(lexNext);
\nthis._relations.Add(relation);
\n}<\/p>\n

public void Add(Lex lexCurrent, Lex lexNext, LexRelation relation)
\n{
\nthis._lexCur.Add(lexCurrent.Name);
\nthis._lexNext.Add(lexNext.Name);
\nthis._relations.Add(relation);
\n}<\/p>\n

public LexRelation GetRelation(string lexCurrent, string lexNext)
\n{
\nfor (int i = 0; i < this.Count; i++)
\nif (this._lexCur[i] == lexCurrent && this._lexNext[i] == lexNext)
\nreturn this._relations[i];
\nreturn LexRelation.Empty;
\n}<\/p>\n

public void RemoveRelation(string lexCurrent, string lexNext)
\n{
\nfor (int i = 0; i < this.Count; i++)
\nif (this._lexCur[i] == lexCurrent && this._lexNext[i] == lexNext)
\n{
\nthis._lexCur.RemoveRange(i, 1);
\nthis._lexNext.RemoveRange(i, 1);
\nthis._relations.RemoveRange(i, 1);
\nreturn;
\n}
\n}
\n}
\n\/\/
\nclass Triad
\n{
\n#region \u041f\u043e\u043b\u044f
\nToken _oper, _obj1, _obj2;
\nint _tread1, _tread2;
\n#endregion<\/p>\n

#region \u041a\u043e\u043d\u0441\u0442\u0440\u0443\u043a\u0442\u043e\u0440\u044b
\npublic Triad()
\n{
\nthis._obj1 = this._obj2 = this._oper = null;
\nthis._tread1 = this._tread2 = 0;
\n}<\/p>\n

public Triad(Token oper, Token obj1, Token obj2)
\n{
\nthis._oper = oper;
\nthis._obj1 = obj1;
\nthis._obj2 = obj2;
\nthis._tread1 = this._tread2 = 0;
\n}<\/p>\n

public Triad(Token oper, int tread1, int tread2)
\n{
\nthis._oper = oper;
\nthis._tread1 = tread1;
\nthis._tread2 = tread2;
\nthis._obj1 = null;
\nthis._obj2 = null;
\n}
\n#endregion<\/p>\n

#region \u0421\u0432\u043e\u0439\u0441\u0442\u0432\u0430
\npublic Token Operator
\n{
\nget { return this._oper; }
\nset { this._oper = value; }
\n}<\/p>\n

public Token Operand1
\n{
\nget { return this._obj1; }
\nset
\n{
\nthis._obj1 = value;
\nthis._tread1 = 0;
\n}
\n}<\/p>\n

public Token Operand2
\n{
\nget { return this._obj2; }
\nset
\n{
\nthis._obj2 = value;
\nthis._tread2 = 0;
\n}
\n}<\/p>\n

public int Tread1
\n{
\nget { return this._tread1; }
\nset
\n{
\nthis._tread1 = value;
\nthis._obj1 = null;
\n}
\n}<\/p>\n

public int Tread2
\n{
\nget { return this._tread2; }
\nset
\n{
\nthis._tread2 = value;
\nthis._obj2 = null;
\n}
\n}
\n#endregion<\/p>\n

#region \u041c\u0435\u0442\u043e\u0434\u044b
\nstatic public void GetTriads(Tree tree, List<Triad> result, ref int num)
\n{
\nTriad tempTriad = new Triad();<\/p>\n

switch (tree.Children.Count)
\n{
\ncase 2:\/\/ not F \u0438\u043b\u0438 not a
\nif (tree.Children[0] != null)
\ntempTriad._oper = tree.Children[0].Current.Token;
\nif (tree.Children[1] != null)
\nif (tree.Children[1].Current.Type == LexType.Terminal)
\ntempTriad._obj1 = tree.Children[1].Current.Token;
\nelse
\n{
\nTriad.GetTriads(tree.Children[1], result, ref num);
\ntempTriad._tread1 = num;
\n}
\nelse
\ntempTriad._obj1 = null;
\ntempTriad._obj2 = null;
\nresult.Add(tempTriad);
\nnum++;
\nbreak;
\ncase 3:\/\/ \u0435\u0441\u043b\u0438 \u044d\u0442\u043e \u043e\u043f\u0435\u0440\u0430\u0442\u043e\u0440
\nif(tree.Children[1] != null)
\n{
\nif (tree.Children[1].Current.Type == LexType.Terminal && tree.Children[1].Current.Token.Type == TokenType.OperatorBoolean)
\n{
\ntempTriad._oper = tree.Children[1].Current.Token;
\nif (tree.Children[0].Current != null)
\nif (tree.Children[0].Current.Type == LexType.Nonterminal)
\n{
\nTriad.GetTriads(tree.Children[0], result, ref num);
\ntempTriad._tread1 = num;
\n}
\nelse
\ntempTriad._obj1 = tree.Children[0].Current.Token;
\nif (tree.Children[2].Current != null)
\nif (tree.Children[2].Current.Type == LexType.Nonterminal)
\n{
\nTriad.GetTriads(tree.Children[2], result, ref num);
\ntempTriad._tread2 = num;
\n}
\nelse
\ntempTriad._obj2 = tree.Children[2].Current.Token;
\n}
\n}
\nresult.Add(tempTriad);
\nnum++;
\nbreak;
\ncase 4:
\ntempTriad._oper = tree.Children[1].Current.Token;
\ntempTriad._obj1 = tree.Children[0].Current.Token;
\nif (tree.Children[2].Current.Type == LexType.Nonterminal)
\n{
\nTriad.GetTriads(tree.Children[2], result, ref num);
\ntempTriad._tread2 = num;
\n}
\nelse
\ntempTriad._obj2 = tree.Children[2].Current.Token;
\nresult.Add(tempTriad);
\nnum++;
\nbreak;
\ndefault:
\nbreak;
\n}
\n}<\/p>\n

static public string[] GetAssemblerCode(List<Triad> triads)
\n{
\nstring tempCommand;
\nList<string> commandsList = new List<string>();
\nfor (int i = 0; i < triads.Count; i++)
\n{
\ntempCommand = «»;
\nswitch (triads[i]._oper.Type)
\n{
\ncase TokenType.OperatorBoolean:
\nif (triads[i]._obj1 == null)
\ntempCommand += «pop AX»;
\nelse
\ntempCommand += «move AX » + triads[i]._obj1.Name;
\ntempCommand += «\\n»;
\nif (triads[i]._obj2 == null)
\ntempCommand += «pop DX»;
\nelse
\ntempCommand += «move DX » + triads[i]._obj2.Name;
\ntempCommand += «\\n»;
\ntempCommand += triads[i]._oper.Name.ToLower()+» AX DX»;
\ntempCommand += «\\n»;
\ntempCommand+= «push AX»;
\nbreak;
\ncase TokenType.Assign:
\nif (triads[i]._obj2 == null)
\ntempCommand += «pop AX»;
\nelse
\ntempCommand += «move AX» + triads[i]._obj2.Name;
\ntempCommand += «\\n»;
\ntempCommand += «move «+triads[i]._obj1.Name+» AX»;
\ntempCommand += «\\n»;
\ntempCommand += «push AX»;
\nbreak;
\ncase TokenType.Not:
\nif (triads[i]._obj1 == null)
\ntempCommand += «pop AX»;
\nelse
\ntempCommand += «move AX » + triads[i]._obj1.Name;
\ntempCommand += «\\n»;
\ntempCommand += «not AX»;
\ntempCommand += «\\n»;
\ntempCommand += «push AX»;
\nbreak;
\ndefault:
\nbreak;
\n}
\ncommandsList.Add(tempCommand);
\n}
\nreturn commandsList.ToArray();
\n}<\/p>\n

public override string ToString()
\n{
\nstring outStr = «(» + this._oper.Name + «, «;
\nif (this._obj1 == null)
\noutStr += «^»+this._tread1.ToString();
\nelse
\noutStr += this._obj1.Name;
\noutStr += «, «;
\nif (this._obj2 == null)
\noutStr += «^»+this._tread2.ToString();
\nelse
\noutStr += this._obj2.Name;
\noutStr += «)»;
\nreturn outStr;
\n}
\n#endregion
\n}
\n}<\/p>\n

\u0424\u0430\u0439\u043b\u00a0Form1.cs<\/strong><\/p>\n

using System;
\nusing System.Collections.Generic;
\nusing System.ComponentModel;
\nusing System.Data;
\nusing System.Drawing;
\nusing System.Text;
\nusing System.IO;
\nusing System.Windows.Forms;<\/p>\n

namespace \u0422\u042f\u041f_\u043b\u04312_\u043c6
\n{
\npublic partial class Form1 : Form
\n{
\nTree genTree;
\nLexRelationTable relationTable;
\nLexRuleTable ruleTable;
\nLex S, F, T, E, a, assigne, or, xor, and, lb, rb, not, semicolon, start, end;<\/p>\n

public Form1()
\n{
\nInitializeComponent();
\nList<Lex> tempList;<\/p>\n

S = new Lex(«S», LexType.Nonterminal);
\nF = new Lex(«F», LexType.Nonterminal);
\nT = new Lex(«T», LexType.Nonterminal);
\nE = new Lex(«E», LexType.Nonterminal);
\na = new Lex(«a», LexType.Terminal);
\nor = new Lex(«or», LexType.Terminal);
\nxor = new Lex(«xor», LexType.Terminal);
\nand = new Lex(«and», LexType.Terminal);
\nlb = new Lex(«(«, LexType.Terminal);
\nrb = new Lex(«)», LexType.Terminal);
\nnot = new Lex(«not», LexType.Terminal);
\nassigne = new Lex(«:=», LexType.Terminal);
\nsemicolon = new Lex(«;», LexType.Terminal);
\nstart = new Lex(@»\\s», LexType.Terminal);
\nend = new Lex(@»\\e;», LexType.Terminal);<\/p>\n

#region \u0417\u0430\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u0435 \u0442\u0430\u0431\u043b\u0438\u0446\u044b \u043f\u0440\u0430\u0432\u0438\u043b
\nruleTable = new LexRuleTable();<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(a);
\ntempList.Add(assigne);
\ntempList.Add(S);
\ntempList.Add(semicolon);
\nruleTable.Add(S, tempList, 0);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(F);
\nruleTable.Add(S, tempList, 1);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(T);
\ntempList.Add(or);
\ntempList.Add(F);
\nruleTable.Add(F, tempList, 2);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(T);
\ntempList.Add(xor);
\ntempList.Add(F);
\nruleTable.Add(F, tempList, 3);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(T);
\nruleTable.Add(F, tempList, 4);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(E);
\ntempList.Add(and);
\ntempList.Add(T);
\nruleTable.Add(T, tempList, 5);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(E);
\nruleTable.Add(T, tempList, 6);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(not);
\ntempList.Add(lb);
\ntempList.Add(F);
\ntempList.Add(rb);
\nruleTable.Add(E, tempList, 7);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(lb);
\ntempList.Add(F);
\ntempList.Add(rb);
\nruleTable.Add(E, tempList, 8);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(not);
\ntempList.Add(a);
\nruleTable.Add(E, tempList, 9);<\/p>\n

tempList = new List<Lex>();
\ntempList.Add(a);
\nruleTable.Add(E, tempList, 10);
\n#endregion<\/p>\n

this.outputBox.Text = ruleTable.ToString();<\/p>\n

#region \u0417\u0430\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u0435 \u0442\u0430\u0431\u043b\u0438\u0446\u044b \u043e\u0442\u043d\u043e\u0448\u0435\u043d\u0438\u0439 \u043f\u0440\u0435\u0434\u0448\u0435\u0441\u0442\u0432\u043e\u0432\u0430\u043d\u0438\u044f
\nrelationTable = new LexRelationTable();
\nrelationTable.Add(or, not, LexRelation.Before);
\nrelationTable.Add(or, lb, LexRelation.Before);
\nrelationTable.Add(or, a, LexRelation.Before);
\nrelationTable.Add(or, E, LexRelation.Before);
\nrelationTable.Add(or, T, LexRelation.Before);
\nrelationTable.Add(or, F, LexRelation.Equality);<\/p>\n

relationTable.Add(xor, not, LexRelation.Before);
\nrelationTable.Add(xor, lb, LexRelation.Before);
\nrelationTable.Add(xor, a, LexRelation.Before);
\nrelationTable.Add(xor, E, LexRelation.Before);
\nrelationTable.Add(xor, T, LexRelation.Before);
\nrelationTable.Add(xor, F, LexRelation.Equality);<\/p>\n

relationTable.Add(and, not, LexRelation.Before);
\nrelationTable.Add(and, lb, LexRelation.Before);
\nrelationTable.Add(and, a, LexRelation.Before);
\nrelationTable.Add(and, E, LexRelation.Before);
\nrelationTable.Add(and, T, LexRelation.Equality);<\/p>\n

relationTable.Add(not, lb, LexRelation.Equality);
\nrelationTable.Add(not, a, LexRelation.Equality);<\/p>\n

relationTable.Add(lb, not, LexRelation.Before);
\nrelationTable.Add(lb, lb, LexRelation.Before);
\nrelationTable.Add(lb, a, LexRelation.Before);
\nrelationTable.Add(lb, E, LexRelation.Before);
\nrelationTable.Add(lb, T, LexRelation.Before);
\nrelationTable.Add(lb, F, LexRelation.Equality);<\/p>\n

relationTable.Add(rb, or, LexRelation.After);
\nrelationTable.Add(rb, xor, LexRelation.After);
\nrelationTable.Add(rb, and, LexRelation.After);
\nrelationTable.Add(rb, rb, LexRelation.After);
\nrelationTable.Add(rb, semicolon, LexRelation.After);
\nrelationTable.Add(rb, end, LexRelation.After);<\/p>\n

relationTable.Add(a, or, LexRelation.After);
\nrelationTable.Add(a, xor, LexRelation.After);
\nrelationTable.Add(a, and, LexRelation.After);
\nrelationTable.Add(a, rb, LexRelation.After);
\nrelationTable.Add(a, semicolon, LexRelation.After);
\nrelationTable.Add(a, assigne, LexRelation.Equality);
\nrelationTable.Add(a, end, LexRelation.Equality);<\/p>\n

relationTable.Add(assigne, not, LexRelation.Before);
\nrelationTable.Add(assigne, lb, LexRelation.Before);
\nrelationTable.Add(assigne, a, LexRelation.Before);
\nrelationTable.Add(assigne, T, LexRelation.Before);
\nrelationTable.Add(assigne, E, LexRelation.Before);
\nrelationTable.Add(assigne, F, LexRelation.Before);
\nrelationTable.Add(assigne, S, LexRelation.Equality);<\/p>\n

relationTable.Add(S, semicolon, LexRelation.Equality);<\/p>\n

relationTable.Add(F, rb, LexRelation.Equality);
\nrelationTable.Add(F, semicolon, LexRelation.After);
\nrelationTable.Add(F, end, LexRelation.After);<\/p>\n

relationTable.Add(T, or, LexRelation.Equality);
\nrelationTable.Add(T, xor, LexRelation.Equality);
\nrelationTable.Add(T, rb, LexRelation.After);
\nrelationTable.Add(T, semicolon, LexRelation.After);
\nrelationTable.Add(T, end, LexRelation.After);<\/p>\n

relationTable.Add(E, or, LexRelation.After);
\nrelationTable.Add(E, xor, LexRelation.After);
\nrelationTable.Add(E, and, LexRelation.Equality);
\nrelationTable.Add(E, rb, LexRelation.After);
\nrelationTable.Add(E, semicolon, LexRelation.After);
\nrelationTable.Add(E, end, LexRelation.After);<\/p>\n

relationTable.Add(semicolon, end, LexRelation.After);
\nrelationTable.Add(semicolon, semicolon, LexRelation.After);<\/p>\n

relationTable.Add(start, a, LexRelation.Before);
\nrelationTable.Add(start, F, LexRelation.Before);
\n#endregion
\n}<\/p>\n

private void buttonRecognize_Click(object sender, EventArgs e)
\n{
\nthis.outputBox.Clear();
\nstring line = this.inputBox.Text;
\nToken[] tokens = Token.GetTokens(line);
\nif (tokens != null)
\n{
\nfor (int i = 0; i < tokens.Length; i++)
\nthis.outputBox.Text += tokens[i].ToString() + «\\n»;
\n}<\/p>\n

bool result = Token.ScanGeneral(tokens, 0, tokens.Length — 1); \/\/Token.ScanBool(tokens, 0, tokens.Length — 1);
\nthis.outputBox.Text += «\\n\\n» + result;
\n}<\/p>\n

private void buttonLoad_Click(object sender, EventArgs e)
\n{
\nstring filename = Directory.GetCurrentDirectory() + @»\\compiletext.txt»;
\nStreamReader reader = new StreamReader(filename, Encoding.GetEncoding(1251));
\nthis.inputBox.Text = reader.ReadToEnd();
\n}<\/p>\n

private void buttonGenerate_Click(object sender, EventArgs e)
\n{
\nTree tree = new Tree(new Lex(«S», LexType.Nonterminal));
\nint rulesCount = 11;
\nint[] maxCount = new int[rulesCount];
\nint[] decrements = new int[rulesCount];
\nfor (int i = 0; i < maxCount.Length; i++)
\nmaxCount[i] = 1;<\/p>\n

#region \u0428\u0442\u0440\u0430\u0444\u044b
\ndecrements[0] = 7;
\ndecrements[1] = 0;
\ndecrements[2] = 3;
\ndecrements[3] = 3;
\ndecrements[4] = 0;
\ndecrements[5] = 3;
\ndecrements[6] = 0;
\ndecrements[7] = 4;
\ndecrements[8] = 4;
\ndecrements[9] = 0;
\ndecrements[10] = 0;
\n#endregion<\/p>\n

tree.GenerateTree(ruleTable, maxCount, decrements);<\/p>\n

List<Lex> leses = new List<Lex>();
\ntree.GetLexes(leses);<\/p>\n

string line = «»;
\nfor (int i = 0; i < leses.Count; i++)
\nline += leses[i].Name + » «;<\/p>\n

this.inputBox.Text = line;<\/p>\n

this.treeViewOut.Nodes.Clear();
\nthis.treeViewOut.Nodes.Add(tree.Current.Name);
\nthis.GetTree(tree, this.treeViewOut.Nodes[0]);<\/p>\n

}<\/p>\n

private void GetTree(Tree tree, TreeNode treeNode)
\n{
\nTreeNode temp;
\nfor (int i = 0; i < tree.Children.Count; i++)
\nif (tree.Children[i].Current.Type == LexType.Nonterminal)
\n{
\ntemp = new TreeNode(tree.Children[i].Current.Name);
\nGetTree(tree.Children[i], temp);
\ntreeNode.Nodes.Add(temp);
\n}
\nelse
\ntreeNode.Nodes.Add(tree.Children[i].Current.Name);
\n}<\/p>\n

private void button1_Click(object sender, EventArgs e)
\n{
\nTree tree = new Tree(S);
\nint[] rules;
\nstring line;
\nStack<int> stackRule = new Stack<int>();
\nStack<Token> stackToken = new Stack<Token>();<\/p>\n

this.outputBox.Clear();
\nthis.outputBox.Text= this.ruleTable.ToString()+»\\n\\n»;<\/p>\n

line = this.inputBox.Text;
\nToken[] tokens = Token.GetTokens(line);
\nif (tokens == null)
\n{
\nthis.outputBox.Text += «\\nError»;
\nreturn;
\n}
\nfor (int i = 0; i < tokens.Length; i++)
\nthis.outputBox.Text += tokens[i].ToString() + «\\n»;
\nbool result = Token.ScanGeneral(tokens, 0, tokens.Length — 1);
\nthis.outputBox.Text += «\\n\\n» + result;<\/p>\n

rules = Lex.GetRules(tokens, ruleTable, relationTable, start, end);<\/p>\n

if (rules == null)
\n{
\nthis.outputBox.Text += «\\nError»;
\nreturn;
\n}
\noutputBox.Text += «\\n»;
\nfor (int i = rules.Length — 1; i >= 0; i—) this.outputBox.Text += rules[i] + » «;<\/p>\n

for (int i = 0; i < rules.Length; i++) stackRule.Push(rules[i]);
\nfor (int i = 0; i < tokens.Length; i++) stackToken.Push(tokens[i]);<\/p>\n

tree.BuildTree(stackRule, ruleTable, stackToken);
\ngenTree = tree;
\n\/\/
\nthis.treeViewOut.Nodes.Clear();
\nthis.treeViewOut.Nodes.Add(tree.Current.Name);
\nthis.GetTree(tree, this.treeViewOut.Nodes[0]);
\n}<\/p>\n

private void optimizeButton_Click(object sender, EventArgs e)
\n{
\ngenTree.OptimizeTranzetive();
\ngenTree.OptimizeBrackets();
\nthis.treeViewOut.Nodes.Add(genTree.Current.Name);
\nthis.GetTree(genTree, this.treeViewOut.Nodes[1]);<\/p>\n

int num=0;
\nList<Triad> triats = new List<Triad>();<\/p>\n

Triad.GetTriads(genTree, triats, ref num);<\/p>\n

outputBox.Text += «\\n\\n\u0422\u0440\u0438\u0430\u0434\u044b:\\n»;
\nfor (int i = 0; i < triats.Count; i++)
\noutputBox.Text += (i+1)+») «+triats[i].ToString()+»\\n»;<\/p>\n

outputBox.Text += «\\n\\n\u041a\u043e\u0434 \u0430\u0441\u0441\u0435\u043c\u0431\u043b\u0435\u0440\u0430:\\n»;
\nstring[] commands = Triad.GetAssemblerCode(triats);
\nfor (int i = 0; i < triats.Count; i++)
\noutputBox.Text+= commands[i]+»\\n»;
\n}
\n}
\n}<\/p>\n

\u0421\u043a\u0440\u0438\u043d\u0448\u043e\u0442 \u041f\u041e\u00a0\u0420\u0430\u0441\u043f\u043e\u0437\u043d\u0430\u0432\u0430\u0442\u0435\u043b\u044c:<\/p>\n

\"\u0420\u0430\u0441\u043f\u043e\u0437\u043d\u0430\u0432\u0430\u0442\u0435\u043b\u044c\"<\/a><\/p>\n

compiletext.txt<\/p>\n

var1 := b or ( c and \u00a0d);<\/p>\n","protected":false},"excerpt":{"rendered":"

\u0424\u0430\u0439\u043b Token.cs using System; using System.Collections.Generic; using System.Collections; using System.Text; namespace \u0422\u042f\u041f_\u043b\u04312_\u043c6 { enum TokenType { ERROR =0, Num, Identificator, BracketLeft, BracketRight, Not, End, Assign, OperatorBoolean};<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[48],"tags":[],"_links":{"self":[{"href":"https:\/\/studentpmr.ru\/index.php?rest_route=\/wp\/v2\/posts\/26087"}],"collection":[{"href":"https:\/\/studentpmr.ru\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/studentpmr.ru\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/studentpmr.ru\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/studentpmr.ru\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=26087"}],"version-history":[{"count":1,"href":"https:\/\/studentpmr.ru\/index.php?rest_route=\/wp\/v2\/posts\/26087\/revisions"}],"predecessor-version":[{"id":26090,"href":"https:\/\/studentpmr.ru\/index.php?rest_route=\/wp\/v2\/posts\/26087\/revisions\/26090"}],"wp:attachment":[{"href":"https:\/\/studentpmr.ru\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=26087"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/studentpmr.ru\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=26087"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/studentpmr.ru\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=26087"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}