MycLib/Src/AST/Myc.Ast.Debugger.pas

unit Myc.Ast.Debugger;

interface

uses
    System.SysUtils,
    System.Classes,
    System.Generics.Collections,
    Myc.Data.Value,
    Myc.Ast.Nodes,
    Myc.Ast.Scope,
    Myc.Ast,
    Myc.Ast.Evaluator;

type
    TDebugEvaluatorVisitor = class(TEvaluatorVisitor)
    private
        FLog: TStrings;
        FIndentLevel: Integer;
        FShowScope: Boolean;
        procedure Indent;
        procedure Unindent;
        procedure AppendLine(const S: string);
        procedure ShowScope;

    protected
        // Overridden to provide the debug-specific visitor factory.
        function CreateVisitorFactory: TVisitorFactory; override;

    public
        constructor Create(const AScope: IExecutionScope; ALog: TStrings; AShowScope: Boolean; AInitialIndent: Integer = 0);

        class function CreateVisitor(
            const AScope: IExecutionScope;
            ALog: TStrings;
            AShowScope: Boolean;
            AInitialIndent: Integer = 0
        ): IAstVisitor;

        function VisitFunctionCall(const Node: IFunctionCallNode): TDataValue; override;
        // The logging overrides for other Visit... methods
        function VisitConstant(const Node: IConstantNode): TDataValue; override;
        function VisitIdentifier(const Node: IIdentifierNode): TDataValue; override;
        function VisitBinaryExpression(const Node: IBinaryExpressionNode): TDataValue; override;
        function VisitUnaryExpression(const Node: IUnaryExpressionNode): TDataValue; override;
        function VisitIfExpression(const Node: IIfExpressionNode): TDataValue; override;
        function VisitTernaryExpression(const Node: ITernaryExpressionNode): TDataValue; override;
        function VisitBlockExpression(const Node: IBlockExpressionNode): TDataValue; override;
        function VisitVariableDeclaration(const Node: IVariableDeclarationNode): TDataValue; override;
        function VisitAssignment(const Node: IAssignmentNode): TDataValue; override;
        function VisitIndexer(const Node: IIndexerNode): TDataValue; override;
        function VisitMemberAccess(const Node: IMemberAccessNode): TDataValue; override;
        function VisitCreateSeries(const Node: ICreateSeriesNode): TDataValue; override;
        function VisitAddSeriesItem(const Node: IAddSeriesItemNode): TDataValue; override;
        function VisitSeriesLength(const Node: ISeriesLengthNode): TDataValue; override;
    end;

implementation

uses
    System.TypInfo,
    Myc.Ast.Printer;

{ TDebugEvaluatorVisitor }

constructor TDebugEvaluatorVisitor.Create(const AScope: IExecutionScope; ALog: TStrings; AShowScope: Boolean; AInitialIndent: Integer = 0);
begin
    inherited Create(AScope);
    Assert(Assigned(ALog));
    FLog := ALog;
    FIndentLevel := AInitialIndent;
    FShowScope := AShowScope;
    ShowScope;
end;

function TDebugEvaluatorVisitor.CreateVisitorFactory: TVisitorFactory;
begin
    // Return a closure that creates a new Debug visitor, using the current context

    var callingVisitor := Self as IAstVisitor;
    Result :=
        function(const AScope: IExecutionScope): IAstVisitor
        begin
            var visitor := callingVisitor as TDebugEvaluatorVisitor;
            Result := TDebugEvaluatorVisitor.Create(AScope, visitor.FLog, visitor.FShowScope, visitor.FIndentLevel);
        end;
end;

function TDebugEvaluatorVisitor.VisitFunctionCall(const Node: IFunctionCallNode): TDataValue;
begin
    AppendLine('FunctionCall{');
    Indent;
    try
        ShowScope;
        Result := inherited VisitFunctionCall(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

procedure TDebugEvaluatorVisitor.Indent;
begin
    inc(FIndentLevel);
end;

procedure TDebugEvaluatorVisitor.Unindent;
begin
    dec(FIndentLevel);
end;

procedure TDebugEvaluatorVisitor.AppendLine(const S: string);
var
    pad: string;
    i: Integer;
begin
    pad := '';
    for i := 0 to FIndentLevel - 1 do
        pad := pad + ':' + ''.PadLeft(3);
    FLog.Add(pad + S);
end;

class function TDebugEvaluatorVisitor.CreateVisitor(
    const AScope: IExecutionScope;
    ALog: TStrings;
    AShowScope: Boolean;
    AInitialIndent: Integer = 0
): IAstVisitor;
begin
    Result := TDebugEvaluatorVisitor.Create(AScope, ALog, AShowScope, AInitialIndent);
end;

procedure TDebugEvaluatorVisitor.ShowScope;
var
    scopeDump: TArray<string>;
    line: string;
begin
    if FShowScope then
    begin
        AppendLine('-- Scope --');
        scopeDump := Scope.Dump.Split([sLineBreak]);
        for line in scopeDump do
        begin
            AppendLine(line);
        end;
        AppendLine('-----------');
    end;
end;

function TDebugEvaluatorVisitor.VisitAddSeriesItem(const Node: IAddSeriesItemNode): TDataValue;
begin
    AppendLine('AddSeriesItem {');
    Indent;
    try
        Result := inherited VisitAddSeriesItem(Node);
    finally
        Unindent;
    end;
    AppendLine('} -> (void)');
end;

function TDebugEvaluatorVisitor.VisitAssignment(const Node: IAssignmentNode): TDataValue;
begin
    AppendLine(Format('Assignment to "%s" {', [Node.Identifier.Name]));
    Indent;
    try
        Result := inherited VisitAssignment(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitConstant(const Node: IConstantNode): TDataValue;
begin
    AppendLine(Format('Constant (%s)', [Node.Value.ToString]));
    Result := inherited VisitConstant(Node);
end;

function TDebugEvaluatorVisitor.VisitCreateSeries(const Node: ICreateSeriesNode): TDataValue;
begin
    AppendLine('CreateSeries {');
    Indent;
    try
        Result := inherited VisitCreateSeries(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitIdentifier(const Node: IIdentifierNode): TDataValue;
begin
    Result := inherited VisitIdentifier(Node);
    AppendLine(Format('Identifier "%s" -> %s', [Node.Name, Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitBinaryExpression(const Node: IBinaryExpressionNode): TDataValue;
begin
    AppendLine(Format('BinaryExpr "%s" {', [Node.Operator.ToString]));
    Indent;
    try
        Result := inherited VisitBinaryExpression(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitUnaryExpression(const Node: IUnaryExpressionNode): TDataValue;
begin
    AppendLine(Format('UnaryExpr "%s" {', [Node.Operator.ToString]));
    Indent;
    try
        Result := inherited VisitUnaryExpression(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitIfExpression(const Node: IIfExpressionNode): TDataValue;
begin
    AppendLine('IfExpr{');
    Indent;
    try
        Result := inherited VisitIfExpression(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitIndexer(const Node: IIndexerNode): TDataValue;
begin
    AppendLine('Indexer {');
    Indent;
    try
        Result := inherited VisitIndexer(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitMemberAccess(const Node: IMemberAccessNode): TDataValue;
begin
    AppendLine(Format('MemberAccess (Member: %s) {', [Node.Member.Name]));
    Indent;
    try
        Result := inherited VisitMemberAccess(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitTernaryExpression(const Node: ITernaryExpressionNode): TDataValue;
begin
    AppendLine('TernaryExpr{');
    Indent;
    try
        Result := inherited VisitTernaryExpression(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitBlockExpression(const Node: IBlockExpressionNode): TDataValue;
begin
    AppendLine('Block{');
    Indent;
    try
        Result := inherited VisitBlockExpression(Node);
        ShowScope;
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

function TDebugEvaluatorVisitor.VisitVariableDeclaration(const Node: IVariableDeclarationNode): TDataValue;
begin
    AppendLine(Format('VarDecl %s :=', [Node.Identifier.Name]));
    Indent;
    try
        Result := inherited VisitVariableDeclaration(Node);
    finally
        Unindent;
    end;
end;

function TDebugEvaluatorVisitor.VisitSeriesLength(const Node: ISeriesLengthNode): TDataValue;
begin
    AppendLine('SeriesLength {');
    Indent;
    try
        Result := inherited VisitSeriesLength(Node);
    finally
        Unindent;
    end;
    AppendLine(Format('} -> %s', [Result.ToString]));
end;

end.