public Assigment(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { var variableNameNode = node.GetChildAndAddError(0, "variable_name", runtime, true); var varValueTable = node.GetChildAndAddError(0, "var_value_table", runtime, true); if (variableNameNode.HasValue) { LeftSide = new VariableName(variableNameNode, runtime); } else if (varValueTable.HasValue) { LeftSide = new ValueTable(varValueTable, runtime); } else { runtime.AddError(new CompilationError( "Failed to find variable name in left side of assigment.")); } var expression = runtime.Get(node.Value.Children[2]); RightSide = expression; }
public MethodCall(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { var namespaceName = node.GetChildAndAddError(0, "namespace", runtime) .GetChildAndAddError(0, "LITERAL", runtime, false); var methodName = node.GetChildAndAddError(2, "method_name", runtime) .GetChildAndAddError(0, "LITERAL", runtime, false); var methodArguments = node.GetChildAndAddError(4, "method_arguments", runtime, true); if (namespaceName.HasValue && methodName.HasValue) { Pointer = new MethodPointer { NameSpace = namespaceName.Value.Value, Name = methodName.Value.Value }; Arguments = new Arguments(); if (methodArguments.HasValue) { for (var k = 0; k < methodArguments.Value.Children.Count; k += 2) { var element = methodArguments.Value.Children.ElementAt(k); var value = runtime.Get(element); Arguments.Args.Add(value); } } } }
public MethodDeclaration(ASTNode?node, IMnemonicsCompiler compiler) : base(node) { var nameSpace = node.GetChildAndAddError(0, "namespace", compiler) .GetChildAndAddError(0, "LITERAL", compiler)?.Value; var method_name = node.GetChildAndAddError(2, "method_name", compiler) .GetChildAndAddError(0, "LITERAL", compiler)?.Value; var body = node.GetChildAndAddError(node.Value.Children.Count - 1, "block_of_lopla", compiler); var code = compiler.Get(body); var method_parameters = node.GetChildAndAddError(4, "method_parameters", compiler, true); var methodArguments = new List <string>(); if (method_parameters != null && method_parameters.Value.Children.Any()) { foreach (var valueChild in method_parameters.Value.Children) { var name = valueChild.GetChildAndAddError(0, "LITERAL", compiler).Value.Value; methodArguments.Add(name); } } Pointer = new MethodPointer { Name = method_name, NameSpace = nameSpace }; Code = new Method { ArgumentList = methodArguments, Code = new List <Mnemonic> { code } }; }
internal bool TryParse(ILookaroundEnumerator <Token> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode, AssignmentOperatorBehavior assignmentOperatorBehavior, int currentPrecedence = 0) { if (currentPrecedence == 0 && CustomParseDelegates != default) { var customResult = CustomParseDelegates.Select(del => { var Success = del(enumerator, out var Result, assignmentOperatorBehavior); return(new { Success, Result }); }).FirstOrDefault(res => res.Success)?.Result; if (customResult != default) { enumerator.MoveNext(); // TODO: Is this right? parsedNode = customResult; return(true); } } if (currentPrecedence >= _PrecedenceGroups.Length) { return(TryParseBraces(enumerator, out parsedNode, assignmentOperatorBehavior)); } return(_PrecedenceGroups[currentPrecedence].First().OperandCount switch { OperandCount.Binary => TryParseBinary(enumerator, currentPrecedence, out parsedNode, assignmentOperatorBehavior), OperandCount.Unary => TryParseUnary(enumerator, currentPrecedence, out parsedNode), _ => throw new NotImplementedException(), });
internal bool TryParseDictionary(ILookaroundEnumerator <Token> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode, AssignmentOperatorBehavior assignmentOperatorBehavior) { parsedNode = default; if (enumerator.Current.TokenType != TokenType.CurlyBraceOpen) { return(false); } var dictionaryItems = new Queue <DictionaryItemNode>(); while (enumerator.MoveNext() && TryParseDictionaryItem(enumerator, out var dictionaryItem, assignmentOperatorBehavior)) { dictionaryItems.Enqueue(dictionaryItem); if (enumerator.MoveNext() == false) { throw new NotImplementedException(); } if (enumerator.Current.TokenType != TokenType.Comma) { break; } } if (enumerator.State == EnumeratorState.Complete || enumerator.Current.TokenType != TokenType.CurlyBraceClose) { throw new NotImplementedException(); } parsedNode = new DictionaryNode(dictionaryItems); return(true); }
public VariableName(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { Pointer = new VariablePointer { Name = node.GetChildAndAddError(0, "LITERAL", runtime)?.Value }; }
public ValueString(ASTNode?node) : base(node) { Value = new String { Value = node.Value.Value?.Trim('\"') }; }
public ExpressionCommon(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { Arguments = new Arguments(); if (node?.Children.Count == 3) { var left = node?.Children[0]; var middle = node?.Children[1]; var right = node?.Children[2]; var leftExpression = runtime.Get(left); var operatorKind = middle.Value.Value; var rightExpression = runtime.Get(right); var o = new Operator(); if (Expression.Operators.ContainsKey(operatorKind)) { o.Kind = Expression.Operators[operatorKind]; } else { runtime.AddError( new CompilationError($"Operator {operatorKind} is not discovered by compiler.")); } Arguments.Args.Add(leftExpression); Arguments.Args.Add(o); Arguments.Args.Add(rightExpression); } else if (node?.Children.Count == 1) { Arguments.Args.Add(runtime.Get(node.Value.Children[0])); } }
public override AASTNode Annotate(ASTNode astNode, AASTNode?parent) { AASTNode returnNode = new AASTNode(astNode, parent, SemanticAnalyzer.no_type); // Check if "return" is in right place - inside the routine body ASTNode?parentCopy = returnNode.Parent; while (parentCopy != null) { if (parentCopy.ASTType.Equals("Routine body")) { // Perform the rest of checks if (astNode.Children[1].Children[0].Children.Count > 0) // If it has something to return { if (astNode.Children[1].Children[0].Children[0].Children[0].ASTType.Equals("Call")) { returnNode.Children.Add(base.Annotate(astNode.Children[1].Children[0].Children[0], returnNode)); } else { returnNode.Children.Add(base.Annotate(astNode.Children[1].Children[0].Children[0].Children[0], returnNode)); } } return(returnNode); } parentCopy = parentCopy.Parent; } throw new SemanticErrorException( "Return is not in place!!!\r\n" + " At (Line: " + astNode.Children[0].Token.Position.Line.ToString() + ", " + "Char: " + astNode.Children[0].Token.Position.Char.ToString() + ")." ); }
public AuthorizationError(ASTNode?node, ValidationContext context, string message, AuthorizationResult result, OperationType?operationType = null) : base(context.Document.Source, "6.1.1", message, node == null ? Array.Empty <ASTNode>() : new ASTNode[] { node }) { Code = "authorization"; AuthorizationResult = result; OperationType = operationType; }
public static ASTNode?GetChildAndAddError(this ASTNode?node, int i, string tokenName, IMnemonicsCompiler runtime, bool optional = false) { if (node != null) { if (node.Value.Children.Count >= i + 1) { var element = node.Value.Children.ElementAt(i); if (element.Symbol.Name != tokenName) { if (!optional) { runtime.AddError(new CompilationError($"Expected: {tokenName} but found: {element.Symbol.Name}.")); } } else { return(element); } } else if (!optional) { runtime.AddError(new CompilationError($"Expected: {i} tokens but found: {node.Value.Children.Count} when looking for: {tokenName}.")); } } else { if (!optional) { runtime.AddError(new CompilationError($"Parent node for: {tokenName} not found.")); } } return(null); }
public VariableName(ASTNode?node, string name) : base(node) { this.Pointer = new VariablePointer() { Name = name }; }
public Block(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { foreach (var valueChild in node.Value.Children) { var mnemonic = runtime.Get(valueChild); Lines.Add(mnemonic); } }
public ExpressionBracket(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { if (node?.Children.Count == 1) { var expresionToken = node?.Children[0]; SubExpresion = runtime.Get(expresionToken); } }
internal bool TryParseList(ILookaroundEnumerator <Token> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode, AssignmentOperatorBehavior assignmentOperatorBehavior) { if (TryParseCommaSeperatedSet(enumerator, TokenType.Operator, _OPERATOR_SQUARE_BRACE_OPEN, SquareBraceClose, out var parsedListItems, minimumItems: 0, assignmentOperatorBehavior)) { parsedNode = new ListNode(parsedListItems); return(true); } parsedNode = default; return(false); }
public If(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { var logicalTest = node.GetChildAndAddError(1, "expression", runtime, false); Condition = runtime.Get(logicalTest); var blockOfLopla = node.GetChildAndAddError(2, "block_of_lopla", runtime, false); BlockOfCode = runtime.Get(blockOfLopla); }
internal bool TryParseTuple(ILookaroundEnumerator <Token> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode, AssignmentOperatorBehavior assignmentOperatorBehavior) { if (TryParseCommaSeperatedSet(enumerator, TokenType.Operator, _OPERATOR_PAREN_OPEN, ParenClose, out var parsedListItems, minimumItems: 2, assignmentOperatorBehavior)) { parsedNode = new TupleNode(parsedListItems); return(true); } parsedNode = default; return(false); }
public ValueTable(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { TablePointer = new VariablePointer { Name = node .GetChildAndAddError(0, "variable_name", runtime)? .GetChildAndAddError(0, "LITERAL", runtime)?.Value }; ElementPositionInTable = runtime.Get(node.Value.Children[1]); }
/// <summary> /// Adds a location to an <see cref="ExecutionError"/> based on a <see cref="ASTNode"/> within a <see cref="GraphQLDocument"/>. /// </summary> public static TError AddLocation <TError>(this TError error, ASTNode?abstractNode, GraphQLDocument?document) where TError : ExecutionError { if (abstractNode == null || abstractNode.Location == default || document == null || document.Source.IsEmpty) { return(error); } error.AddLocation(Location.FromLinearPosition(document.Source, abstractNode.Location.Start)); return(error); }
public ExpressionPrefix(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { if (node?.Children.Count == 2) { var right = node?.Children[1]; this.MultByMinus1 = runtime.Get(right); } else { this.ExpressionToPrefix = runtime.Get(node.Value.Children[0]); } }
/// <summary> /// Creates an AST node. /// </summary> /// <param name="parent">Ref to the parent AST node.</param> /// <param name="children">Ref to the list of AST children nodes.</param> /// <param name="token">Corresponding token from the lexical analyzer.</param> /// <param name="type">The type of the AST node (basically syntax rule).</param> public ASTNode(ASTNode?parent, List <ASTNode> children, Token token, string type) { Parent = parent; Children = children; Token = token; ASTType = type; if (parent != null) { level = parent.level + 2; } }
public int Visualize(ASTNode?ast) { if (ast is null) { return(1); } Application.SetHighDpiMode(HighDpiMode.SystemAware); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new VisualizeForm(ast)); return(0); }
public override async ValueTask VisitAsync(ASTNode?node, GetVariablesVisitorContext context) { if (node == null) { return; } context.Info.Enter(node, context.ValidationContext); await base.VisitAsync(node, context).ConfigureAwait(false); context.Info.Leave(node, context.ValidationContext); }
public DeclareTable(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { Values = new List <Mnemonic>(); var kids = node.GetChildAndAddError(0, "declare_table_values", runtime, true); if (kids.HasValue && kids.Value.Children.Count > 0) { foreach (var valueChild in kids.Value.Children) { Values.Add(runtime.Get(valueChild)); } } }
public Return(ASTNode?node, IMnemonicsCompiler runtime) : base(node) { var returnValue = node.GetChildAndAddError(1, "expression", runtime, true); if (returnValue == null) { ReturnExpression = new Nop(node); } else { ReturnExpression = runtime.Get(returnValue); } }
protected Mnemonic(ASTNode?node) { if (node.HasValue) { Symbol = node?.Symbol.Name; var n = node; do { Line = n?.Position.Line; Column = n?.Position.Column; n = n.Value.Children.Count > 0 ? (ASTNode?)n.Value.Children[0] : null; } while (Line == 0 && n != null); } }
/// <summary> /// Walks the specified <see cref="ASTNode"/>, executing <see cref="INodeVisitor.Enter(ASTNode, ValidationContext)"/> and /// <see cref="INodeVisitor.Leave(ASTNode, ValidationContext)"/> methods for each node. /// </summary> public override async ValueTask VisitAsync(ASTNode?node, State context) { if (node != null) { for (int i = 0; i < _visitors.Count; ++i) { _visitors[i].Enter(node, context.Context); } await base.VisitAsync(node, context).ConfigureAwait(false); for (int i = _visitors.Count - 1; i >= 0; --i) { _visitors[i].Leave(node, context.Context); } } }
private static bool TryBuildFromFile(string path, out ASTNode?ast) { Log.Information("Creating AST for file: {Path}", path); ast = null; try { ast = new ImperativeASTFactory().BuildFromFile(path); return(true); } catch (SyntaxErrorException e) { Log.Fatal(e, "[{Path}] Syntax error: {Details}", path, e.Message ?? "unknown"); } catch (NotImplementedException e) { Log.Fatal(e, "[{Path}] Not supported: {Details}", path, e.Message ?? "unknown"); } catch (UnsupportedLanguageException e) { Log.Fatal(e, "[{Path}] Not supported language", path); } catch (Exception e) { Log.Fatal(e, "[{Path}] Exception occured", path); } return(false); }
public override AASTNode Annotate(ASTNode astNode, AASTNode?parent) { AASTNode breakNode = new AASTNode(astNode, parent, SemanticAnalyzer.no_type); // Check if "break" is in the right place - inside the loop body ASTNode?parentCopy = breakNode.Parent; while (parentCopy != null) { if (parentCopy.ASTType.Equals("Loop body")) { return(breakNode); } parentCopy = parentCopy.Parent; } throw new SemanticErrorException( "Break is not in place!!!\r\n" + " At (Line: " + astNode.Children[0].Token.Position.Line.ToString() + ", " + "Char: " + astNode.Children[0].Token.Position.Char.ToString() + ")." ); }
/// <summary> /// Executes the test as a parsing test with a non-matching condition /// </summary> /// <param name="parser">The parser to use</param> /// <returns>The test result</returns> private int TestNoMatches(Hime.Redist.Parsers.BaseLRParser parser) { ASTNode?expected = GetExpectedAST(); if (!expected.HasValue) { Console.WriteLine("Failed to parse the expected AST"); return(RESULT_FAILURE_PARSING); } ParseResult result = parser.Parse(); foreach (ParseError error in result.Errors) { Console.WriteLine(error); TextContext context = result.Input.GetContext(error.Position); Console.WriteLine(context.Content); Console.WriteLine(context.Pointer); } if (!result.IsSuccess) { Console.WriteLine("Failed to parse the input"); return(RESULT_FAILURE_PARSING); } if (result.Errors.Count != 0) { Console.WriteLine("Some errors while parsing the input"); return(RESULT_FAILURE_PARSING); } if (Compare(expected.Value, result.Root)) { Console.WriteLine("Produced AST incorrectly matches the specified expectation"); return(RESULT_FAILURE_VERB); } else { return(RESULT_SUCCESS); } }