public void Visit(FunctionInvocationNode functionInvocationNode) { switch (functionInvocationNode.Function) { case ScreenExitFunction screenExitFunction: { if (!abstractSyntaxTree.TryRetrieveGameObject(screenExitFunction.ConnectedScreenIdentifier)) { DazelLogger.EmitError( $"Screen {string.Join(".", screenExitFunction.ConnectedScreenIdentifier)} does not exist.", functionInvocationNode.Token); } break; } case ExitFunction exitFunction: exitFunction.MemberAccessNode.Accept(this); break; case PrintFunction printFunction: printFunction.Log(); break; } foreach (ValueNode valueNode in functionInvocationNode.Parameters) { if (valueNode is MemberAccessNode memberAccessNode) { memberAccessNode.Accept(this); } } }
public static VariableSymbolTableEntry AccessMember(MemberAccessNode memberAccessNode) { try { return(AccessMember(memberAccessNode.Identifiers)); } catch { DazelLogger.EmitError($"Member not found in {memberAccessNode}", memberAccessNode.Token); } return(null); }
public FunctionInvocationNode Setup() { if (DazelStdLib.TryGetFunction(Identifier, out Function function) && function.NumArguments == Parameters.Count) { Function = function; function.GetReturnType(Parameters); return(this); } DazelLogger.EmitError($"{Identifier} function not found in Dazel Standard Library.", Token); return(null); }
protected void InvalidArgumentsException(IEnumerable <ValueNode> parameters) { StringBuilder sb = new StringBuilder(); sb.AppendLine($"Invalid arguments in function {GetType()}:"); foreach (ValueNode valueNode in parameters) { sb.AppendLine($"{valueNode}"); } DazelLogger.EmitError(sb.ToString(), ValueNode.Token); }
public Vector2 ToVector2() { if (Values.Count == 2) { IntValueNode x = Values[0] as IntValueNode; IntValueNode y = Values[1] as IntValueNode; return(new Vector2(x.Value, y.Value)); } DazelLogger.EmitError($"Invalid number of arguments: {Values.Count}.", Token); return(Vector2.Zero); }
public void Visit(SumExpressionNode sumExpressionNode) { if (sumExpressionNode.Left == null) { DazelLogger.EmitError("Expression left operand is null", sumExpressionNode.Token); } if (sumExpressionNode.Right == null) { DazelLogger.EmitError("Expression right operand is null", sumExpressionNode.Token); } sumExpressionNode.Left.Accept(this); sumExpressionNode.Right.Accept(this); }
public void Visit(ExitValueNode exitValueNode) { if (exitValueNode is TileExitValueNode tileExit) { EnvironmentStore.AccessMember(tileExit.ToExit); } if (exitValueNode is ScreenExitValueNode screenExit) { if (!abstractSyntaxTree.TryRetrieveGameObject(screenExit.ConnectedScreenIdentifier)) { DazelLogger.EmitError( $"Exit {screenExit} is invalid: {screenExit.ConnectedScreenIdentifier} does not exist.", screenExit.Token); } } }
public void Visit(ArrayNode arrayNode) { typeHandler.SetType(arrayNode.Type, arrayNode.Token); SymbolType valueType = arrayNode.Values[0].Type; foreach (ValueNode value in arrayNode.Values) { if (value.Type == valueType) { valueType = value.Type; } else { DazelLogger.EmitError($"Type mismatch. {value} is not {typeHandler.CurrentType}", value.Token); } } }
public override ValueNode GetReturnType(List <ValueNode> parameters) { foreach (ValueNode valueNode in parameters) { if (valueNode.Type != SymbolType.Integer) { DazelLogger.EmitError("Invalid type.", valueNode.Token); } } if (parameters[0] is IntValueNode width && parameters[1] is IntValueNode height) { Width = width.Value; Height = height.Value; } return(null); }
public void SetType(SymbolType value, IToken token) { if (CurrentType == SymbolType.Exit) { DazelLogger.EmitError("Exits cannot be used in expressions.", token); } if (CurrentType == SymbolType.Null || CurrentType == SymbolType.Integer && (value == SymbolType.Float || value == SymbolType.Integer)) { CurrentType = value; return; } if (CurrentType == SymbolType.Float && value == SymbolType.Integer) { return; } DazelLogger.EmitError($"Type mismatch. {value} is not {CurrentType}", token); }
public void Visit(SumExpressionNode sumExpressionNode) { sumExpressionNode.Left.Accept(this); T a = Result; sumExpressionNode.Right.Accept(this); T b = Result; switch (sumExpressionNode.OperationNode.Operator) { case Operators.AddOp: Result = Calculator.Add(a, b); break; case Operators.MinOp: Result = Calculator.Subtract(a, b); break; default: DazelLogger.EmitError($"Operation {sumExpressionNode.OperationNode.Operator} is not valid.", sumExpressionNode.Token); break; } }
public void Visit(FactorExpressionNode factorExpressionNode) { factorExpressionNode.Left.Accept(this); T a = Result; factorExpressionNode.Right.Accept(this); T b = Result; switch (factorExpressionNode.OperationNode.Operator) { case Operators.MultOp: Result = Calculator.Multiply(a, b); break; case Operators.DivOp: Result = Calculator.Divide(a, b); break; default: DazelLogger.EmitError($"Operation {factorExpressionNode.OperationNode.Operator} is not valid.", factorExpressionNode.Token); break; } }
public void Visit(IdentifierValueNode identifierValueNode) { SymbolTableEntry entry; try { entry = symbolTable.RetrieveSymbolInParentScope(identifierValueNode.Identifier); } catch (Exception e) { DazelLogger.EmitError(e.Message, identifierValueNode.Token); return; } if (entry is VariableSymbolTableEntry variableSymbolTableEntry) { ExpressionNode expression = variableSymbolTableEntry.ValueNode; SetNumericalExpression(identifierValueNode, expression, entry.Type); } SymbolTableEntry symbolTableEntry = symbolTable.RetrieveSymbolInParentScope(identifierValueNode.Identifier); typeHandler.SetType(symbolTableEntry.Type, identifierValueNode.Token); }
public override ArrayNode GetValue(int a) { DazelLogger.EmitError($"Integer {a} is not an array.", Token); return(null); }
public override ArrayNode Divide(ArrayNode a, ArrayNode b) { DazelLogger.EmitError("Cannot divide arrays.", Token); return(null); }
public override ArrayNode Multiply(ArrayNode a, ArrayNode b) { DazelLogger.EmitError("Cannot multiply arrays.", Token); return(null); }
public override ArrayNode Subtract(ArrayNode a, ArrayNode b) { DazelLogger.EmitError("Cannot subtract arrays.", Token); return(null); }
public override ArrayNode GetValue(ExitValueNode a) { DazelLogger.EmitError("ExitValue is not an array.", Token); return(null); }
public override ExitValueNode GetValue(float a) { DazelLogger.EmitError($"Float {a} is not an exit.", Token); return(null); }
public override ExitValueNode GetValue(int a) { DazelLogger.EmitError($"Integer {a} is not an exit.", Token); return(null); }
public override ExitValueNode Divide(ExitValueNode a, ExitValueNode b) { DazelLogger.EmitError("Cannot divide exits.", Token); return(null); }
public override string Multiply(string a, string b) { DazelLogger.EmitError($"Cannot multiply string {a} and {b}.", Token); return(null); }
public override ExitValueNode Subtract(ExitValueNode a, ExitValueNode b) { DazelLogger.EmitError("Cannot subtract exits.", Token); return(null); }
public override string Divide(string a, string b) { DazelLogger.EmitError($"Cannot divide string {a} and {b}.", Token); return(null); }
public override string GetValue(ExitValueNode a) { DazelLogger.EmitError("Exits cannot be used as strings.", Token); return(null); }
public override ArrayNode GetValue(float a) { DazelLogger.EmitError($"Float {a} is not an array.", Token); return(null); }
public override ArrayNode GetValue(string a) { DazelLogger.EmitError($"String {a} is not an array.", Token); return(null); }
public override ExitValueNode GetValue(string a) { DazelLogger.EmitError($"String {a} is not an exit.", Token); return(null); }
public override ExitValueNode Multiply(ExitValueNode a, ExitValueNode b) { DazelLogger.EmitError("Cannot multiply exits.", Token); return(null); }
public override ExitValueNode GetValue(ArrayNode a) { DazelLogger.EmitError($"Array is not an exit.", Token); return(null); }