public ProgramRaw ParseProgram()
{
var node = new ProgramRaw();
while (_stream.HasTokens())
{
var nextNode = TryExtractVariants(new Func <AstNode>[] {
ParseAnnotation,
ParseData,
ParseModule,
ParseRoutine,
ParseCode,
});
if (nextNode != null)
{
node.AddChild(nextNode);
}
else
{
throw SyntaxError.Make(SyntaxErrorMessages.INVALID_TOKEN, NextToken());
}
}
return(node);
}
private Statement ParseStatement()
{
var label = ParseLabel();
var inner = TryExtractVariants(new Func <AstNode>[] {
ParseAssemblyBlock,
ParseExtensionStatement,
});
if (label == null && inner == null)
{
return(null);
}
if (label != null && inner == null)
{
var t = NextToken();
throw SyntaxError.Make(SyntaxErrorMessages.STATEMENT_EXPECTED, t);
}
var node = new Statement();
if (label != null)
{
node.AddChild(node);
}
node.AddChild(inner);
return(node);
}
protected void AssertIdentifier(Token received)
{
if (received.Type != TokenType.Identifier)
{
throw SyntaxError.Make(SyntaxErrorMessages.IDENTIFIER_EXPECTED, received);
}
}
protected void AssertLiteral(Token received)
{
if (received.Type != TokenType.Number)
{
throw SyntaxError.Make(SyntaxErrorMessages.LITERAL_EXPECTED, received);
}
}
private AssemblyOperationFormat ParseAssemblyOperationFormat()
{
var kw = NextToken();
if (!kw.IsKeyword(Keyword.Format))
{
_stream.Previous();
return(null);
}
var allowedVals = new HashSet <string>()
{
"8", "16", "32"
};
var t = NextToken();
AssertLiteral(t);
if (!allowedVals.Contains(t.Value))
{
throw SyntaxError.Make(SyntaxErrorMessages.INVALID_TOKEN, t);
}
var node = new AssemblyOperationFormat(t);
node.PropagatePosition(kw.Position);
return(node);
}
protected void AssertOperator(string expected, Token received)
{
if (!received.IsOperator(expected))
{
throw SyntaxError.Make(SyntaxErrorMessages.UNEXPECTED_TOKEN, expected, received);
}
}
public override ReadResult <Terminal> Read(ITextScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
var context = scanner.GetContext();
MatchResult result = null;
// ReSharper disable once ForCanBeConvertedToForeach
for (var i = 0; i < valueRange.Length; i++)
{
var c = valueRange[i];
result = scanner.TryMatch(c);
if (result.EndOfInput)
{
return(ReadResult <Terminal> .FromSyntaxError(SyntaxError.FromMatchResult(result, context)));
}
if (result.Success)
{
return(ReadResult <Terminal> .FromResult(new Terminal(result.Text, context)));
}
}
Debug.Assert(result != null, "result != null");
return(ReadResult <Terminal> .FromSyntaxError(SyntaxError.FromMatchResult(result, context)));
}
/// <summary>
///
/// </summary>
/// <param name="scanner"></param>
/// <exception cref="ArgumentNullException"></exception>
/// <returns></returns>
public override ReadResult <Alternative> Read(ITextScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
var context = scanner.GetContext();
IList <SyntaxError> errors = new List <SyntaxError>(lexers.Length);
SyntaxError partialMatch = null;
// ReSharper disable once ForCanBeConvertedToForeach
for (var i = 0; i < lexers.Length; i++)
{
var result = lexers[i].ReadElement(scanner);
if (result.Success)
{
return(ReadResult <Alternative> .FromResult(new Alternative(result.Text, result.Element, context, i + 1)));
}
errors.Add(result.Error);
if (partialMatch == null || result.Text.Length > partialMatch.Text.Length)
{
partialMatch = result.Error;
}
}
Debug.Assert(partialMatch != null, "partialMatch != null");
return(ReadResult <Alternative> .FromSyntaxError(partialMatch));
}
public static decimal?Compile(string sourceCode)
{
// create a compiler from the grammar
FlGrammar grammar = new FlGrammar();
LanguageCompiler compiler = new LanguageCompiler(grammar);
// Attempt to compile into an Abstract Syntax Tree. Because FLGrammar
// defines the root node as ProgramNode, that is what will be returned.
// This happens to implement IJavaScriptGenerator, which is what we need.
IExpressionGenerator program = (IExpressionGenerator)compiler.Parse(sourceCode);
if (program == null || compiler.Context.Errors.Count > 0)
{
// Didn't compile. Generate an error message.
SyntaxError error = compiler.Context.Errors[0];
string location = string.Empty;
if (error.Location.Line > 0 && error.Location.Column > 0)
{
location = "Line " + (error.Location.Line + 1) + ", column " + (error.Location.Column + 1);
}
string message = location + ": " + error.Message + ":" + Environment.NewLine;
message += sourceCode.Split('\n')[error.Location.Line];
throw new CompilationException(message);
}
// now just instruct the compilation of to javascript
//StringBuilder js = new StringBuilder();
var expression = program.GenerateExpression(null);
return(((Expression <Func <decimal?> >)expression).Compile()());
}
private VarType ParseType(bool assert = true)
{
var t = NextToken();
var allowedTypes = new HashSet <string>()
{
Keyword.Int, Keyword.Short, Keyword.Byte
};
if (t.Type != TokenType.Keyword || !allowedTypes.Contains(t.Value))
{
_stream.Previous();
if (assert)
{
throw SyntaxError.Make(SyntaxErrorMessages.TYPE_EXPECTED, t);
}
return(null);
}
var node = new VarType(t);
return(node);
}
protected void AssertRegister(Token received)
{
if (received.Type != TokenType.Register)
{
throw SyntaxError.Make(SyntaxErrorMessages.REGISTER_EXPECTED, received);
}
}
public Exception newSyntaxError(string m)
{
SyntaxError e = new SyntaxError(m, this.filename, this.lineno);
e.source = this.source;
e.cursor = this.cursor;
return(e);
}
public Exception newSyntaxError(string m)
{
SyntaxError e = new SyntaxError(m, filename, lineno);
e.source = m_source;
e.cursor = m_cursor;
return(e);
}
// Tests an invalid script
private static void AssertIsInvalid(string script, int position, SyntaxError error)
{
SyntaxValidationResult result = Brainf_ckParser.ValidateSyntax(script);
Assert.IsFalse(result.IsSuccess);
Assert.AreEqual(result.ErrorOffset, position);
Assert.AreEqual(result.ErrorType, error);
}
private CompositeElement handleError(CompositeElement result, SyntaxError syntaxError)
{
CompositeElement errorElement = TreeElementFactory.CreateErrorElement(syntaxError.Message);
if (result == null)
return errorElement;
result.AppendNewChild(errorElement);
return result;
}
/// <summary>
/// Creates a new lexical error token.
/// </summary>
/// <param name="errorType">The type of the error.</param>
/// <param name="span">The location of the error.</param>
public ErrorToken(SyntaxErrorType errorType, Span span) : base(TokenType.LexicalError, span)
{
if (errorType < SyntaxErrorType.InvalidEscapedIdentifier || errorType > SyntaxErrorType.InvalidDecimalLiteral)
{
throw new ArgumentOutOfRangeException("errorType");
}
_SyntaxError = new SyntaxError(errorType, span);
}
/// <summary>
/// Creates a new <see cref="SyntaxValidationResult"/> instance with the specified parameters
/// </summary>
/// <param name="error">The syntax error for the current source file, if any</param>
/// <param name="offset">The index of the parsing error, if present</param>
/// <param name="operatorsCount">The total number of Brainf*ck/PBrain operators in the original source file</param>
internal SyntaxValidationResult(SyntaxError error, int offset, int operatorsCount = -1)
{
Assert(offset >= -1);
Assert(operatorsCount >= -1);
Assert(operatorsCount >= 0 || error != SyntaxError.None);
ErrorType = error;
ErrorOffset = offset;
OperatorsCount = operatorsCount;
}
public override ReadResult <Alternative> Read(ITextScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
var context = scanner.GetContext();
ILexer bestCandidate = null;
var bestCandidateLength = -1;
var ordinal = 0;
IList <SyntaxError> errors = new List <SyntaxError>(lexers.Length);
SyntaxError partialMatch = null;
// ReSharper disable once ForCanBeConvertedToForeach
for (var i = 0; i < lexers.Length; i++)
{
var lexer = lexers[i];
var candidate = lexer.ReadElement(scanner);
if (candidate.Success)
{
var alternative = candidate.Element;
var length = alternative.Text.Length;
if (length > bestCandidateLength)
{
bestCandidate = lexer;
bestCandidateLength = length;
ordinal = i + 1;
}
if (length != 0)
{
scanner.Unread(alternative.Text);
}
}
else
{
errors.Add(candidate.Error);
if (partialMatch == null || candidate.Text.Length > partialMatch.Text.Length)
{
partialMatch = candidate.Error;
}
}
}
if (bestCandidate == null)
{
Debug.Assert(partialMatch != null, "partialMatch != null");
return(ReadResult <Alternative> .FromSyntaxError(partialMatch));
}
var readResult = bestCandidate.ReadElement(scanner);
Debug.Assert(readResult.Success, "readResult.Success");
return(ReadResult <Alternative> .FromResult(new Alternative(readResult.Text, readResult.Element, context, ordinal)));
}
private void ErrorHandler(SyntaxErrorTypes type)
{
if (currentLexem < LexemString.Count)
{
Error = new SyntaxError(type, new Error(LexemString[currentLexem].line, LexemString[currentLexem].column));
}
else
{
Error = new SyntaxError(type, new Error(LexemString[currentLexem - 1].line, LexemString[currentLexem - 1].column + LexemString[currentLexem - 1].value.Length));
}
OnError?.Invoke(); /*подія - коли відбулася помилка в средині то воно вибиває на верх */
}
private void lstErrors_Click(object sender, EventArgs e)
{
txtErrDetails.Text = "";
SyntaxError se = lstErrors.SelectedItem as SyntaxError;
if (se == null)
{
return;
}
ShowLocation(se.Location, 1);
txtErrDetails.Text = se.Message + "\r\n (L:C = " + se.Location + ", parser state: " + se.State + ")";
}
public ParseResult Parse()
{
ParseResult result = this.Expr();
if (!result.error && this.currentToken.type != Token.TokenType.TokenEOF)
{
var error = new SyntaxError("invalid syntax", this.currentToken.start, this.currentToken.end);
var errorToken = new Token(Token.TokenType.TokenError, error, error.start, error.end);
return(result.Failure(new ErrorNode(errorToken)));
}
return(result);
}
public void CalculateFromText_ShouldThrowExceptionForErrorError(
string invalidEquation, SyntaxError expectedErrorType
)
{
var calculator = new CalculatorModel();
CalculationParseSyntaxException thrownException =
Assert.Throws <CalculationParseSyntaxException>(
() => calculator.CalculateFromText(invalidEquation)
);
SyntaxError actualErrorType = thrownException.SyntaxErrorType;
Assert.Equal(expectedErrorType, actualErrorType);
}
public override ReadResult <Sign> Read(ITextScanner scanner)
{
var result = innerLexer.Read(scanner);
if (result.Success)
{
var sign = new Sign(result.Element);
return(ReadResult <Sign> .FromResult(sign));
}
var syntaxError = SyntaxError.FromReadResult(result, scanner.GetContext());
return(ReadResult <Sign> .FromSyntaxError(syntaxError));
}
public override ReadResult <Integer> Read(ITextScanner scanner)
{
var result = innerLexer.Read(scanner);
if (result.Success)
{
var integer = new Integer(result.Element);
return(ReadResult <Integer> .FromResult(integer));
}
var syntaxError = SyntaxError.FromReadResult(result, scanner.GetContext());
return(ReadResult <Integer> .FromSyntaxError(syntaxError));
}
public override ReadResult <EndOfLine> Read(ITextScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
var result = innerLexer.Read(scanner);
if (result.Success)
{
return(ReadResult <EndOfLine> .FromResult(new EndOfLine(result.Element)));
}
return(ReadResult <EndOfLine> .FromSyntaxError(SyntaxError.FromReadResult(result, scanner.GetContext())));
}
private static string GetMessage(SyntaxError error, int position)
{
string prefix = "Syntax Error:";
string suffix = $"Position: {position}";
switch (error)
{
case SyntaxError.UnbalancedSquareBraces: return($"{prefix} Program contains unbalanced square braces. {suffix}");
case SyntaxError.UnexpectedClosingSquareBrace: return($"{prefix} Program contains unexpected ']'. {suffix}");
default: return(null);
}
}
public ParseResult Factor()
{
var result = new ParseResult();
Token token = this.currentToken;
Token.TokenType[] checkOp = { Token.TokenType.TokenPlus, Token.TokenType.TokenMinus };
Token.TokenType[] numberTypes = { Token.TokenType.TokenInt, Token.TokenType.TokenDecimal };
if (checkOp.Contains(this.currentToken.type))
{
result.Register(this.Advance());
Node factor = result.Register(this.Factor());
if (result.error)
{
return(result);
}
return(result.Success(new UnaryOpNode(token, factor)));
}
else if (numberTypes.Contains(this.currentToken.type))
{
result.Register(this.Advance());
return(result.Success(new NumberNode(token)));
}
else if (token.type == Token.TokenType.TokenLPar)
{
result.Register(this.Advance());
Node expr = result.Register(this.Expr());
if (result.error)
{
return(result);
}
if (this.currentToken.type == Token.TokenType.TokenRPar)
{
result.Register(this.Advance());
return(result.Success(expr));
}
else
{
var missingPar = new SyntaxError("expected a ')'", token.start, token.end);
var missingParToken = new Token(Token.TokenType.TokenError, missingPar, missingPar.start, missingPar.end);
return(result.Failure(new ErrorNode(missingParToken)));
}
}
var error = new SyntaxError("expected a number", token.start, token.end);
var errorToken = new Token(Token.TokenType.TokenError, error, error.start, error.end);
return(result.Failure(new ErrorNode(errorToken)));
}
public static DiagnosticSeverity DiagnosticSeverityFromSyntaxError(SyntaxError syntaxError)
{
switch (syntaxError.ErrorCode.Severity)
{
case ErrorSeverity.Info:
return(DiagnosticSeverity.Information);
case ErrorSeverity.Warning:
return(DiagnosticSeverity.Warning);
case ErrorSeverity.Error:
default:
return(DiagnosticSeverity.Error);
}
}
public override ReadResult <Terminal> Read(ITextScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
var context = scanner.GetContext();
var result = scanner.TryMatch(terminal, comparer);
if (result.Success)
{
return(ReadResult <Terminal> .FromResult(new Terminal(result.Text, context)));
}
return(ReadResult <Terminal> .FromSyntaxError(SyntaxError.FromMatchResult(result, context)));
}
protected void AssertTokenExist(Token token)
{
if (token == null)
{
var last = _stream.Last();
// Next char position
var start = last.Position.Start.ToTuple();
var end = last.Position.End.ToTuple();
start.Item2 += 1;
end.Item2 += 1;
var prettyPos = new Position(start, end);
throw SyntaxError.Make(SyntaxErrorMessages.UNEXPECTED_EOS(), prettyPos);
}
}
public void CompileImplementation(PascalSharp.Internal.TreeConverter.TreeRealization.common_unit_node SemanticUnit,
compilation_unit SyntaxUnit, PascalSharp.Internal.TreeConverter.TreeRealization.unit_node_list UsedUnits, List <Error> ErrorsList, List <CompilerWarning> WarningsList,
SyntaxError parser_error, System.Collections.Hashtable bad_nodes, using_namespace_list interface_namespaces, using_namespace_list imlementation_namespaces,
Dictionary <syntax_tree_node, string> docs, bool debug, bool debugging)
{
//if (ErrorsList.Count>0) throw ErrorsList[0];
stv.parser_error = parser_error;
stv.bad_nodes_in_syntax_tree = bad_nodes;
stv.referenced_units = UsedUnits;
stv.using_list.clear();
stv.using_list.AddRange(interface_namespaces);
stv.interface_using_list.AddRange(interface_namespaces);
stv.using_list.AddRange(imlementation_namespaces);
stv.ErrorsList = ErrorsList;
stv.WarningsList = WarningsList;
stv.SymbolTable.CaseSensitive = SemanticRules.SymbolTableCaseSensitive;
if (docs != null)
{
stv.docs = docs;
}
stv.debug = debug;
stv.debugging = debugging;
SystemLibrary.syn_visitor = stv;
SetSemanticRules(SyntaxUnit);
unit_module umod = SyntaxUnit as unit_module;
if (umod == null)
{
throw new PascalSharp.Internal.TreeConverter.CompilerInternalError("Program has not implementation part");
}
//TODO: Переделать, чтобы Сашин код работал с common_unit_node.
stv.compiled_unit = (PascalSharp.Internal.TreeConverter.TreeRealization.common_unit_node)SemanticUnit;
stv.current_document = new document(SyntaxUnit.file_name);
foreach (compiler_directive cd in umod.compiler_directives)
{
cd.visit(stv);
}
stv.visit_implementation(umod);
//stv.visit(SyntaxUnit);
//return stv.compiled_unit;
}
public Error_GqlSyntax(SyntaxError mySyntaxError, String myQuery)
{
SyntaxError = mySyntaxError;
Info = myQuery;
}
internal void AddSyntaxError(SyntaxError error)
{
DebugAssert(error.Object == this, "Must own the error");
if (this.syntaxErrors == null) this.syntaxErrors = new List<SyntaxError>();
syntaxErrors.Add(error);
}
