Skip to content

Commit

Permalink
add new parser
Browse files Browse the repository at this point in the history
  • Loading branch information
@Alexey-Sagaydak
Alexey-Sagaydak committed Apr 2, 2024
1 parent 3fdef52 commit 3118e0a
Show file tree
Hide file tree
Showing 13 changed files with 398 additions and 189 deletions.
2 changes: 1 addition & 1 deletion Compiler/Compiler.csproj
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
<Project Sdk="Microsoft.NET.Sdk">

<PropertyGroup>
<OutputType>Exe</OutputType>
<OutputType>WinExe</OutputType>
<TargetFramework>net8.0-windows</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
Expand Down
38 changes: 0 additions & 38 deletions Compiler/Models/Parser/DeclareParser.cs
View file

This file was deleted.

162 changes: 130 additions & 32 deletions Compiler/Models/Parser/ReqParser.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,7 @@ public List<ParserError> Parse(List<Lexeme> tokensList)
Errors.Clear();
if (tokensList.Count <= 0)
return Errors;
GetAndRemoveInvalidLexemes(tokensList);
tokens = tokensList;
CurrIndex = 0;
MaxIndex = tokensList.Count - 1;
Expand All @@ -37,15 +38,24 @@ public List<ParserError> Parse(List<Lexeme> tokensList)
}
catch (SyntaxErrorException)
{
log("Syntax Error: Обнаружено незаконченное выражение.");
if (CurrToken.Type != LexemeType.Semicolon)
Errors.Add(new ParserError($"Выражение незакончено", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
}

return Errors;
}

private void log(string str)
public void GetAndRemoveInvalidLexemes(List<Lexeme> lexemes)
{

for (int i = lexemes.Count - 1; i >= 0; i--)
{
var lexeme = lexemes[i];
if (lexeme.Type == LexemeType.Whitespace || lexeme.Type == LexemeType.NewLine || lexeme.Type == LexemeType.InvalidCharacter)
{
Errors.Add(new ParserError($"Недопустимый символ \"{lexeme.Value}\"", lexeme.StartIndex, lexeme.EndIndex, ErrorType.UnfinishedExpression));
lexemes.RemoveAt(i);
}
}
}

private void ChangeCurrentToken()
Expand All @@ -54,12 +64,6 @@ private void ChangeCurrentToken()
{
CurrIndex++;
CurrToken = tokens[CurrIndex];

if (CurrToken.Type == LexemeType.InvalidCharacter)
{
Errors.Add(new ParserError($"Встречен некорректный символ \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
ChangeCurrentToken();
}
}
else
{
Expand All @@ -78,74 +82,130 @@ private void Z(bool get, bool neutralize = false)
{
if (get) ChangeCurrentToken();

if (CurrToken.Type == LexemeType.DECLARE || neutralize)
if (CurrToken.Type == LexemeType.DECLARE)
{
E(true);
}
else
{
Errors.Add(new ParserError($"Ожидалось ключевое слово DECLARE, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
E(true);
if (CurrToken.Type == LexemeType.Identifier && GetNextType() == LexemeType.CONSTANT)
{
Errors.Add(new ParserError($"Пропущено ключевое слово DECLARE", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
E(false);
}
else
{
Errors.Add(new ParserError($"Ожидалось ключевое слово DECLARE, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
E(true);
}
}
}

private void E(bool get, bool neutralize = false)
{
if (get) ChangeCurrentToken();

if (CurrToken.Type == LexemeType.Identifier || neutralize)
if (CurrToken.Type == LexemeType.Identifier)
{
CONST(true);
}
else
{
Errors.Add(new ParserError($"Ожидался идентификатор, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
CONST(true);
if (CurrToken.Type == LexemeType.CONSTANT)
{
Errors.Add(new ParserError($"Пропущен идентификатор", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
CONST(false);
}
else
{
Errors.Add(new ParserError($"Ожидался идентификатор, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));

if (GetNextType() == LexemeType.Identifier)
E(true);
else
CONST(true);
}
}
}

private void CONST(bool get, bool neutralize = false)
{
if (get) ChangeCurrentToken();

if (CurrToken.Type == LexemeType.CONSTANT || neutralize)
if (CurrToken.Type == LexemeType.CONSTANT)
{
INT(true);
}
else
{
Errors.Add(new ParserError($"Ожидалось ключевое слово CONSTANT, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
INT(true);
if (CurrToken.Type == LexemeType.INTEGER)
{
Errors.Add(new ParserError($"Пропущено ключевое слово CONSTANT", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
INT(false);
}
else
{
Errors.Add(new ParserError($"Ожидалось ключевое слово CONSTANT, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));

if (GetNextType() == LexemeType.CONSTANT)
CONST(true);
else
INT(true);
}
}
}

private void INT(bool get, bool neutralize = false)
{
if (get) ChangeCurrentToken();

if (CurrToken.Type == LexemeType.INTEGER || neutralize)
if (CurrToken.Type == LexemeType.INTEGER)
{
ASSIGN(true);
}
else
{
Errors.Add(new ParserError($"Ожидалось ключевое слово INTEGER, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
ASSIGN(true);
if (CurrToken.Type == LexemeType.AssignmentOperator)
{
Errors.Add(new ParserError($"Пропущено ключевое слово INTEGER", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
ASSIGN(false);
}
else
{
Errors.Add(new ParserError($"Ожидалось ключевое слово INTEGER, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));

if (GetNextType() == LexemeType.INTEGER)
INT(true);
else
ASSIGN(true);
}
}
}

private void ASSIGN(bool get, bool neutralize = false)
{
if (get) ChangeCurrentToken();

if (CurrToken.Type == LexemeType.AssignmentOperator || neutralize)
if (CurrToken.Type == LexemeType.AssignmentOperator)
{
NUMBER(true);
}
else
{
Errors.Add(new ParserError($"Ожидался оператор присваивания, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
NUMBER(true);
if (CurrToken.Type == LexemeType.Sign || CurrToken.Type == LexemeType.UnsignedInteger)
{
Errors.Add(new ParserError($"Пропущен оператор присваивания", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
NUMBER(false);
}
else
{
Errors.Add(new ParserError($"Ожидался оператор присваивания, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));

if (GetNextType() == LexemeType.AssignmentOperator)
ASSIGN(true);
else
NUMBER(true);
}
}
}

Expand All @@ -159,38 +219,76 @@ private void NUMBER(bool get, bool neutralize = false)
}
else
{
Errors.Add(new ParserError($"Ожидался знак или число, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
UNSIGNEDINT(true);
if (CurrToken.Type == LexemeType.Semicolon)
{
Errors.Add(new ParserError($"Пропущен знак или число", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
UNSIGNEDINT(false);
}
else
{
Errors.Add(new ParserError($"Ожидался знак или число, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));

if (GetNextType() == LexemeType.Sign || GetNextType() == LexemeType.UnsignedInteger)
NUMBER(true);
else
UNSIGNEDINT(true, true);
}
}
}

private void UNSIGNEDINT(bool get, bool neutralize = false)
{
if (get) ChangeCurrentToken();

if (CurrToken.Type == LexemeType.UnsignedInteger || neutralize)
if (CurrToken.Type == LexemeType.UnsignedInteger)
{
END(true);
}
else
{
Errors.Add(new ParserError($"Ожидалось число, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
END(true);
if (CurrToken.Type == LexemeType.Semicolon)
{
if (!neutralize)
Errors.Add(new ParserError($"Пропущено число", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
END(false);
}
else
{
Errors.Add(new ParserError($"Ожидалось число, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));

if (GetNextType() == LexemeType.UnsignedInteger)
UNSIGNEDINT(true);
else
END(true);
}
}
}

private void END(bool get, bool neutralize = false)
{
if (get) ChangeCurrentToken();

if (CurrToken.Type == LexemeType.Semicolon || neutralize)
if (CurrToken.Type == LexemeType.Semicolon)
{
Z(true);
}
else
{
Errors.Add(new ParserError($"Ожидался идентификатор, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
Z(true);
if (CurrToken.Type == LexemeType.DECLARE || GetNextType() == LexemeType.Error)
{
Errors.Add(new ParserError($"Пропущен оператор конца выражения", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));
if (GetNextType() != LexemeType.Error)
Z(false);
}
else
{
Errors.Add(new ParserError($"Ожидался оператор конца выражения, а встречено \"{CurrToken.Value}\"", CurrToken.StartIndex, tokens[MaxIndex].EndIndex, ErrorType.UnfinishedExpression));

if (GetNextType() == LexemeType.Semicolon)
END(true);
else
Z(true);
}
}
}
}
2 changes: 1 addition & 1 deletion Compiler/Resources/About.html
View file
Original file line number Diff line number Diff line change
Expand Up @@ -44,7 +44,7 @@
<h1>О программе</h1>
<img src="logo.png" alt="Логотип">
<p>Название программы: Компилятор</p>
<p>Версия программы: 4.2.2</p>
<p>Версия программы: 4.3.0b</p>
<p>Автор: Сагайдак А.Е., АВТ-113</p>
<p>Описание: текстовый редактор с функциями языкового процессора</p>
<p>2024 г.</p>
Expand Down
Loading

0 comments on commit 3118e0a

Please sign in to comment.