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(); }