bool checkID(LexicalToken input)
{
if (source.Identifiers.isIdentifierExists(input))
{
return(true);
}
return(false);
}
void ProcessComparsion(LexicalToken input, bool isInt)
{
if (!isInt)
{
switch (input.Value)
{
case "==":
triadResult[pointer] = (currentBool.value == bufBool.value).ToString();
break;
case "<>":
triadResult[pointer] = (currentBool.value != bufBool.value).ToString();
break;
case ">":
case "<":
error = "Строка [" + (ThreeAddressCode[pointer].Operation.StringNumber + 1).ToString()
+ "]. Недопустимая операция для типа данных BOOL.";
break;
}
}
else
{
switch (input.Value)
{
case "==":
triadResult[pointer] = (bufInt.value == currentInt.value).ToString();
break;
case "<>":
triadResult[pointer] = (bufInt.value != currentInt.value).ToString();
break;
case ">":
if (bufInt.value > currentInt.value)
{
triadResult[pointer] = "TRUE";
}
else
{
triadResult[pointer] = "FALSE";
}
break;
case "<":
if (bufInt.value < currentInt.value)
{
triadResult[pointer] = "TRUE";
}
else
{
triadResult[pointer] = "FALSE";
}
break;
}
}
}
static void Main(string[] args)
{
TextReader reader = Console.In;
LexicalProcessor lexer = null;
try
{
if (args.Length > 0)
{
if (args[0].ToLowerInvariant().Equals("-h"))
{
PrintUsage();
}
reader = new StreamReader(args[0]);
}
lexer = new LexicalProcessor(reader);
while (lexer.Read())
{
LexicalToken token = lexer.Current;
buffer.Text(ConsoleColor.DarkYellow, String.Format("[{0}]", GetEnumName(token.Type)));
if (!String.IsNullOrEmpty(token.Value))
{
buffer.Text(" ")
.Text(ConsoleColor.DarkGray, "\'")
.Text(token.Value)
.Text(ConsoleColor.DarkGray, "\'");
}
if (token.Tag != null)
{
buffer.Text(" ")
.Text(ConsoleColor.DarkGray, "\'")
.Text(token.Tag.ToString())
.Text(ConsoleColor.DarkGray, "\'");
}
buffer.Line();
}
}
catch (Exception ex) {
Exception e = ex;
while (e != null)
{
buffer.Error(String.Format("sharplex: {0} ({1})", e.Message, e.GetType().Name));
e = ex.InnerException;
}
if (lexer != null)
{
buffer.Error(String.Format("\t at line {0}, column {1}", lexer.Line, lexer.Column));
}
Environment.Exit(Math.Min(-ex.GetHashCode(), -1));
}
}
public void postfixRecord() // Функция преобразования в польскую инверсную нотацию
{
HashInit();
output = new Queue <LexicalToken>(); // Инициализация переменной для результата
Buffer.Clear();
while (regroupedTable.TranslationList.Count > 0)
{
Buffer = regroupedTable.TranslationList.Dequeue();
casesOfTransactions();
}
}
public void Expect(LexicalToken token)
{
if (this.Current == token)
{
Next();
}
else
{
throw new ApplicationException(String.Format("Lexer error: Incorrent token '{0}' encountered. Expected '{1}'.", this.Value, token.ToString()));
}
}
public bool isIdentifierExists(LexicalToken input)
{
string nameForBuf = input.Value;
if (!intTable.ContainsKey(nameForBuf) && !boolTable.ContainsKey(nameForBuf))
{
errors.Enqueue("[" + (input.StringNumber + 1).ToString() + "][" + input.LineNumber + "] '" + input.Value + "' Переменная не была обьявлена в программе.\n");
return(false);
}
return(true);
}
/// <summary>
/// Creates a <see cref="ISyntaxNodeMaker"/> that interpretes the given token
/// as though it were a value to be created and returns the correct maker
/// to fulfill the request.
/// </summary>
/// <param name="token">The token representing the start of the value to be parsed.</param>
/// <returns>A <see cref="ISyntaxNodeMaker"/> that can parse the data.</returns>
public static ISyntaxNodeMaker CreateMaker(LexicalToken token)
{
// an input value could be:
// NameToken: a potential enumeration or true|false
// StringToken: some string value
// NumberToken: some number value
// CurlyLeft: complex JSON object
// BracketLeft: an array of items
// DollarSign: variable reference
if (token is NameToken)
{
if (token.Text.Span.Equals(ParserConstants.Keywords.True.Span, StringComparison.Ordinal) ||
token.Text.Span.Equals(ParserConstants.Keywords.False.Span, StringComparison.Ordinal))
{
return(BooleanValueNodeMaker.Instance);
}
else
{
return(EnumValueNodeMaker.Instance);
}
}
if (token is NullToken)
{
return(NullValueNodeMaker.Instance);
}
if (token is StringToken)
{
return(StringValueNodeMaker.Instance);
}
if (token is NumberToken)
{
return(NumberValueNodeMaker.Instance);
}
if (token.TokenType == TokenType.CurlyBraceLeft)
{
return(ComplexValueNodeMaker.Instance);
}
if (token.TokenType == TokenType.BracketLeft)
{
return(ListValueNodeMaker.Instance);
}
if (token.TokenType == TokenType.Dollar)
{
return(VariableValueNodeMaker.Instance);
}
return(null);
}
public bool takeOp(LexicalToken input)
{
switch (input.Token)
{
case TranslationToken.Identifier:
if (checkID(input))
{
if (source.Identifiers.intTable.ContainsKey(input.Value))
{
GetCurrentIntByID(input);
return(true);
}
else
if (source.Identifiers.boolTable.ContainsKey(input.Value))
{
GetCurrentBoolByID(input);
return(false);
}
else
{
outFlag = true;
return(false);
}
}
else
{
outFlag = true;
return(false);
}
case TranslationToken.Constant:
return(GetCurrentConst(input));
case TranslationToken.Triada:
{
if (CompareBool(triadResult[input.LineNumber], true))
{
currentBool.value = true;
currentBool.numberInProgram = input.LineNumber;
return(false);
}
if (CompareBool(triadResult[input.LineNumber], false))
{
currentBool.value = false;
currentBool.numberInProgram = input.LineNumber;
return(false);
}
currentInt.value = Convert.ToInt32(triadResult[input.LineNumber]);
return(true);
}
}
return(false);
}
/// <summary>
/// Asserts that the token meets common checks.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="expectedClassType">Expected type of the class.</param>
/// <param name="expectedText">The expected text.</param>
/// <param name="expectedType">The expected type of the 'TokenType' property.</param>
/// <param name="expectedAbsolutePosition">The expected absolute position.</param>
public static void AssertToken(LexicalToken token, Type expectedClassType, string expectedText, TokenType expectedType, int?expectedAbsolutePosition = null)
{
Assert.IsNotNull(token);
Assert.IsInstanceOf(expectedClassType, token);
Assert.AreEqual(expectedType, token.TokenType);
Assert.AreEqual(expectedText, token.Text.ToString());
Assert.IsNotNull(token.Location, "Token does not contain a valid location");
if (expectedAbsolutePosition != null)
{
Assert.AreEqual(expectedAbsolutePosition.Value, token.Location.AbsoluteIndex);
}
}
public void ProcessTriads()
{
BufferTriada = new Triada();
workStack = new Stack <LexicalToken>();
ThreeAddressCodeQueue = new Queue <Triada>();
Buffer.Clear();
while (output.Count > 0)
{
Buffer = output.Dequeue();
ActionCase();
}
ThreeAddressCode = ThreeAddressCodeQueue.ToArray();
}
void casesOfTransactions() // Функция, обрабатывающая варианты действий
//в соответствии с пришедшим "Token"
{
switch (Buffer.Token)
{
case TranslationToken.Identifier:
postfixString();
break;
case TranslationToken.BreakKeyword:
if (currentOut != -1)
{
createTransition(currentOut, false);
output.Enqueue(Buffer);
}
else
{
out_log += "Строка [" + Convert.ToString(Buffer.StringNumber + 1) + "] оператор Break используется вне цикла.";
}
break;
case TranslationToken.EchoKeyword:
bufForIO = Buffer;
Buffer = regroupedTable.TranslationList.Dequeue();
postfixString();
output.Enqueue(bufForIO);
break;
case TranslationToken.WhileKeyword:
postfixWhile();
break;
case TranslationToken.InputKeyword:
bufForIO = Buffer;
output.Enqueue(regroupedTable.TranslationList.Dequeue());
output.Enqueue(regroupedTable.TranslationList.Dequeue());
output.Enqueue(bufForIO);
break;
case TranslationToken.IfKeyword:
postfixIf();
break;
default:
break;
}
}
void postfixWhile() // Постфиксная запись оператора "WHILE"
{
int loopIn = markCounter, loopOut = markCounter + 1;
markCounter += 2;
subString = true;
// Добавляем метку перед условием
createMark(loopIn);
output.Enqueue(Buffer);
// Проверяем условие
Buffer.Clear();
Buffer = regroupedTable.TranslationList.Dequeue();
postfixString();
// Добавляем условный переход на выход из цикла
createTransition(loopOut, true);
output.Enqueue(Buffer);
Buffer.Clear();
Buffer = regroupedTable.TranslationList.Dequeue();
currentOut = loopOut;
if (Buffer.Token == TranslationToken.LeftBrace)
{
Buffer.Clear();
while (Buffer.Token != TranslationToken.RightBrace)
{
Buffer = regroupedTable.TranslationList.Dequeue();
casesOfTransactions();
}
createTransition(loopIn, false);
output.Enqueue(Buffer);
createMark(loopOut);
output.Enqueue(Buffer);
}
else
{
casesOfTransactions();
createTransition(loopIn, false);
output.Enqueue(Buffer);
createMark(loopOut);
output.Enqueue(Buffer);
}
currentOut = -1;
}
bool GetCurrentConst(LexicalToken input)
{
if (CompareBool(input.Value, true))
{
currentBool.value = true;
currentBool.numberInProgram = input.LineNumber;
return(false);
}
if (CompareBool(input.Value, false))
{
currentBool.value = false;
currentBool.numberInProgram = input.LineNumber;
return(false);
}
currentInt.value = Convert.ToInt32(input.Value);
currentBool.numberInProgram = input.LineNumber;
return(true);
}
public static OperatorExpression FromToken(LexicalToken token)
{
if (token == LexicalToken.Plus)
{
return(new OperatorExpression('+'));
}
else if (token == LexicalToken.Minus)
{
return(new OperatorExpression('-'));
}
else if (token == LexicalToken.Star)
{
return(new OperatorExpression('*'));
}
else if (token == LexicalToken.Slash)
{
return(new OperatorExpression('/'));
}
else
{
throw new ApplicationException("Invalid operator");
}
}
public Stack Do()
{
input = Tokens;
buffer.Token = TranslationToken.EndOfProgram;
input.Enqueue(buffer);
int c, r;
WorkStack = new Stack();
OutputStack = new Stack();
int param;
WorkStack.Push("$");
WorkStack.Push("<P>");
buffer = input.Dequeue();
while (WorkStack.Count > 0)
{
try
{
r = GetRowByID(Convert.ToString(WorkStack.Peek()));
c = (int)buffer.Token - 1;
if (r != -1 && -1 != c)
{
param = LLTable[r, c];
PutInStack(param);
}
else
{
buffer = input.Dequeue();
PrintLog(0);
}
}
catch (IndexOutOfRangeException)
{ }
}
return(OutputStack);
}
public bool addRecord(LexicalToken input) // Возвращает "true", если идентификатор/константа успешно занесен(-на) в таблицу.
{
string nameForBuf;
if (input.isIdentifier)
{
nameForBuf = input.Value;
if (!intTable.ContainsKey(nameForBuf) && !boolTable.ContainsKey(nameForBuf))
{
if (input.AttributeValue == "BOOL")
{
bool_buff.numberInProgram = input.LineNumber;
bool_buff.name = nameForBuf;
bool_buff.value = false;
boolTable.Add(nameForBuf, bool_buff);
clearBuff();
return(true);
}
if (input.AttributeValue == "INT")
{
int_buff.numberInProgram = input.LineNumber;
int_buff.name = nameForBuf;
int_buff.value = 0;
intTable.Add(nameForBuf, int_buff);
clearBuff();
return(true);
}
}
else
{
errors.Enqueue("Строка [" + (input.StringNumber + 1).ToString() + "][" + input.LineNumber + "] '" + input.Value + "' Идентификатор с таким именем уже существует.\n");
return(false);
}
}
return(false);
}
void PutInStack(int caseOf)
{
switch (caseOf)
{
case 1:
PrintLog(caseOf);
WorkStack.Push("}");
WorkStack.Push("<POp>");
WorkStack.Push("{");
WorkStack.Push("X");
break;
case 2:
PrintLog(caseOf);
WorkStack.Push("<a>");
WorkStack.Push("<O>");
break;
case 4:
PrintLog(caseOf);
WorkStack.Push("<POp>");
WorkStack.Push(";");
break;
case 5:
PrintLog(caseOf);
WorkStack.Push("<b>");
WorkStack.Push("<Op>");
break;
case 7:
PrintLog(caseOf);
WorkStack.Push("<POp>");
WorkStack.Push(";");
break;
case 8:
PrintLog(caseOf);
WorkStack.Push("<LID>");
WorkStack.Push("d");
break;
case 9:
PrintLog(caseOf);
WorkStack.Push("<LID>");
WorkStack.Push("B");
break;
case 10:
PrintLog(caseOf);
WorkStack.Push("<c>");
WorkStack.Push("X");
break;
case 12:
PrintLog(caseOf);
WorkStack.Push("<LID>");
WorkStack.Push(",");
break;
case 13:
PrintLog(caseOf);
WorkStack.Push("<V>");
WorkStack.Push("=");
WorkStack.Push("X");
break;
case 14:
PrintLog(caseOf);
WorkStack.Push("R");
break;
case 15:
PrintLog(caseOf);
WorkStack.Push("<d>");
WorkStack.Push("<Cmp>");
WorkStack.Push("I");
break;
case 16:
PrintLog(caseOf);
WorkStack.Push("<e>");
WorkStack.Push("<Op>");
break;
case 17:
PrintLog(caseOf);
WorkStack.Push("<e>");
WorkStack.Push("<O>");
break;
case 18:
PrintLog(caseOf);
WorkStack.Push("<e>");
WorkStack.Push("}");
WorkStack.Push("<POp>");
WorkStack.Push("{");
break;
case 20:
PrintLog(caseOf);
WorkStack.Push("<f>");
WorkStack.Push("E");
WorkStack.Push(";");
break;
case 21:
PrintLog(caseOf);
WorkStack.Push("<Op>");
break;
case 22:
PrintLog(caseOf);
WorkStack.Push("<O>");
break;
case 23:
PrintLog(caseOf);
WorkStack.Push("}");
WorkStack.Push("<POp>");
WorkStack.Push("{");
break;
case 24:
PrintLog(caseOf);
WorkStack.Push("<g>");
WorkStack.Push("<Cmp>");
WorkStack.Push("W");
break;
case 25:
PrintLog(caseOf);
WorkStack.Push("<Op>");
break;
case 26:
PrintLog(caseOf);
WorkStack.Push("}");
WorkStack.Push("<POp>");
WorkStack.Push("{");
break;
case 27:
PrintLog(caseOf);
WorkStack.Push("X");
WorkStack.Push("i");
break;
case 28:
PrintLog(caseOf);
WorkStack.Push("<V>");
WorkStack.Push("e");
break;
case 29:
PrintLog(caseOf);
WorkStack.Push("<h>");
WorkStack.Push("<F>");
break;
case 30:
PrintLog(caseOf);
WorkStack.Push("<F>");
WorkStack.Push("+");
break;
case 31:
PrintLog(caseOf);
WorkStack.Push("<F>");
WorkStack.Push("-");
break;
case 33:
PrintLog(caseOf);
WorkStack.Push("<o>");
WorkStack.Push("<PV>");
break;
case 34:
PrintLog(caseOf);
WorkStack.Push("<PV>");
WorkStack.Push("*");
break;
case 35:
PrintLog(caseOf);
WorkStack.Push("<PV>");
WorkStack.Push("/");
break;
case 36:
PrintLog(caseOf);
WorkStack.Push("<PV>");
WorkStack.Push("%");
break;
case 38:
PrintLog(caseOf);
WorkStack.Push("X");
break;
case 39:
PrintLog(caseOf);
WorkStack.Push("C");
break;
case 40:
PrintLog(caseOf);
WorkStack.Push("X");
WorkStack.Push("-");
break;
case 41:
PrintLog(caseOf);
WorkStack.Push("C");
WorkStack.Push("-");
break;
case 42:
PrintLog(caseOf);
WorkStack.Push(")");
WorkStack.Push("<V>");
WorkStack.Push("(");
break;
case 43:
PrintLog(caseOf);
WorkStack.Push(")");
WorkStack.Push("<V>");
WorkStack.Push("c");
WorkStack.Push("<V>");
WorkStack.Push("(");
break;
case 50:
PrintLog(caseOf);
break;
case 100:
PrintLog(caseOf);
buffer = input.Dequeue();
break;
case 999:
PrintLog(caseOf);
Log += "Синтаксический разбор успешно завершен.\n";
return;
case 0:
errLog.Enqueue("Строка [" + (buffer.StringNumber + 1).ToString() + "]. Неожиданный символ " + buffer.Value + ". \n");
PrintLog(0);
if (input.Count > 0)
{
buffer = input.Dequeue();
}
break;
}
}
/// <summary>
/// 型名が長いため作りました。
/// </summary>
private static KeyValuePair <LexicalToken, string> MakePair(LexicalToken token,
string text)
{
return(new KeyValuePair <LexicalToken, string>(token, text));
}
/// <summary>
/// Processes the queue as far as it needs to to generate a fully qualiffied
/// <see cref="SyntaxNode" /> based on its ruleset.
/// </summary>
/// <param name="tokenStream">The token stream.</param>
/// <returns>LexicalToken.</returns>
public SyntaxNode MakeNode(TokenStream tokenStream)
{
// extracts a variable in the format of: $name: declaredType [= defaultValue]
// the token stream MUST be positioned at a dollar sign for this maker to function correclty
tokenStream.MatchOrThrow(TokenType.Dollar);
var startLocation = tokenStream.Location;
tokenStream.Next();
// must be a name token
tokenStream.MatchOrThrow <NameToken>();
var variableName = tokenStream.ActiveToken.Text;
tokenStream.Next();
// must be a colon
tokenStream.MatchOrThrow(TokenType.Colon);
tokenStream.Next();
// extract the type expression while the tokens are of characters '[', ']', '!', {NameToken}
LexicalToken startToken = null;
LexicalToken endToken = null;
while (
tokenStream.Match(TokenType.BracketLeft) ||
tokenStream.Match(TokenType.BracketRight) ||
tokenStream.Match(TokenType.Bang) ||
tokenStream.Match(TokenType.Name))
{
startToken = startToken ?? tokenStream.ActiveToken;
endToken = tokenStream.ActiveToken;
tokenStream.Next();
}
var typeExpression = ReadOnlyMemory <char> .Empty;
if (startToken != null)
{
typeExpression = tokenStream.SourceText.Slice(
startToken.Location.AbsoluteIndex,
endToken.Location.AbsoluteIndex + endToken.Text.Length - startToken.Location.AbsoluteIndex);
}
// could be an equal sign for a default value
SyntaxNode defaultValue = null;
if (tokenStream.Match(TokenType.EqualsSign))
{
tokenStream.Next();
var maker = NodeMakerFactory.CreateMaker <InputValueNode>();
defaultValue = maker.MakeNode(tokenStream);
}
var variable = new VariableNode(startLocation, variableName, typeExpression);
if (defaultValue != null)
{
variable.AddChild(defaultValue);
}
return(variable);
}
/// <summary>
/// Asserts that the token meets common checks.
/// </summary>
/// <typeparam name="TExpectedTokenType">The type of the t expected token type.</typeparam>
/// <param name="token">The token.</param>
/// <param name="expectedText">The expected text.</param>
/// <param name="expectedType">The expected type of the 'TokenType' property.</param>
/// <param name="expectedAbsolutePosition">The expected absolute position.</param>
public static void AssertToken <TExpectedTokenType>(LexicalToken token, string expectedText, TokenType expectedType, int?expectedAbsolutePosition = null)
{
AssertToken(token, typeof(TExpectedTokenType), expectedText, expectedType, expectedAbsolutePosition);
}
void GetCurrentBoolByID(LexicalToken input)
{
currentBool.name = input.Value;
currentBool.value = source.Identifiers.boolTable[currentBool.name].value;
currentBool.numberInProgram = input.LineNumber;
}
void postfixString() // Трансляция выражений
{
Stack <LexicalToken> workStack = new Stack <LexicalToken>();
priority = 0;
while (true)
{
// Проверка на некорректность данных.
if (Buffer.Token == TranslationToken.LeftBrace || Buffer.Token == TranslationToken.RightBrace ||
Buffer.Token == TranslationToken.Semicolon || Buffer.Token == TranslationToken.WhileKeyword ||
Buffer.Token == TranslationToken.InputKeyword || Buffer.Token == TranslationToken.InputKeyword ||
Buffer.Token == TranslationToken.EchoKeyword)
{
break;
}
if (Buffer.Token == TranslationToken.LeftParentheses)
{
priority = _priorityTable[Buffer.Token];
workStack.Push(Buffer);
Buffer.Clear();
Buffer = regroupedTable.TranslationList.Dequeue();
continue;
}
// Обработка скобок
if (Buffer.Token == TranslationToken.RightParentheses)
{
while (workStack.Count > 0 && workStack.Peek().Token != TranslationToken.LeftParentheses)
{
output.Enqueue(workStack.Pop());
}
if (workStack.Count > 0)
{
workStack.Pop();
if (workStack.Count > 0)
{
priority = _priorityTable[workStack.Peek().Token];
}
else if (subString)
{
subString = false;
break;
}
priority = 0;
}
Buffer = regroupedTable.TranslationList.Dequeue();
continue;
}
if (Buffer.Token == TranslationToken.Identifier || Buffer.Token == TranslationToken.Constant)
{
output.Enqueue(Buffer);
Buffer.Clear();
Buffer = regroupedTable.TranslationList.Dequeue();
continue;
}
if (_priorityTable.ContainsKey(Buffer.Token))
{
if (priority < _priorityTable[Buffer.Token])
{
priority = _priorityTable[Buffer.Token];
workStack.Push(Buffer);
Buffer.Clear();
Buffer = regroupedTable.TranslationList.Dequeue();
continue;
}
else
{
while (true)
{
if (workStack.Count > 0 && _priorityTable[Buffer.Token] <= _priorityTable[workStack.Peek().Token])
{
output.Enqueue(workStack.Pop());
}
else
{
workStack.Push(Buffer);
Buffer = regroupedTable.TranslationList.Dequeue();
break;
}
}
}
}
}
while (workStack.Count > 0)
{
if (workStack.Peek().Token == TranslationToken.RightParentheses || workStack.Peek().Token == TranslationToken.LeftParentheses)
{
workStack.Pop();
}
else
{
output.Enqueue(workStack.Pop());
}
}
if (Buffer.Token != TranslationToken.RightParentheses && Buffer.Token != TranslationToken.LeftParentheses && Buffer.Token != TranslationToken.RightBrace && Buffer.Token != TranslationToken.LeftBrace)
{
output.Enqueue(Buffer);
}
}
void postfixIf() // Постфиксная запись оператора "IF"
{
int conditionOut = markCounter, elseOut = markCounter + 1;
markCounter += 2;
subString = true;
// Проверяем условие
Buffer.Clear();
Buffer = regroupedTable.TranslationList.Dequeue();
postfixString();
// Добавляем условный переход для выхода
createTransition(conditionOut, true);
output.Enqueue(Buffer);
Buffer.Clear();
// Транслируем множественные/одиночные выражения цикла
Buffer = regroupedTable.TranslationList.Dequeue();
if (Buffer.Token == TranslationToken.LeftBrace)
{
Buffer.Clear();
while (Buffer.Token != TranslationToken.RightBrace)
{
Buffer = regroupedTable.TranslationList.Dequeue();
casesOfTransactions();
}
createTransition(elseOut, false);
output.Enqueue(Buffer);
createMark(conditionOut);
output.Enqueue(Buffer);
}
else
{
casesOfTransactions();
createTransition(elseOut, false);
output.Enqueue(Buffer);
createMark(conditionOut);
output.Enqueue(Buffer);
}
if (regroupedTable.TranslationList.Peek().Token == TranslationToken.EchoKeyword)
{
regroupedTable.TranslationList.Dequeue();
Buffer = regroupedTable.TranslationList.Dequeue();
if (Buffer.Token == TranslationToken.LeftBrace)
{
Buffer.Clear();
while (Buffer.Token != TranslationToken.RightBrace)
{
Buffer = regroupedTable.TranslationList.Dequeue();
casesOfTransactions();
}
createMark(elseOut);
output.Enqueue(Buffer);
}
else
{
casesOfTransactions();
createMark(elseOut);
output.Enqueue(Buffer);
}
}
else
{
createMark(elseOut);
output.Enqueue(Buffer);
}
}
/// <summary>
/// 型名が長いため作りました。
/// </summary>
private static KeyValuePair<LexicalToken, string> MakePair(LexicalToken token,
string text)
{
return new KeyValuePair<LexicalToken, string>(token, text);
}
public Triada()
{
FirstOperand = new LexicalToken();
SecondOperand = new LexicalToken();
Operation = new LexicalToken();
}
