source: trunk/UTerminal.pas

unit UTerminal;

{$mode delphi}

interface

uses
  Classes, SysUtils, UDevice;

type

  { TTerminal }

  TTerminal = class
  private
    function GetCommandLine: string;
    procedure SetCommandLine(AValue: string);
  public
    Output: string;
    Device: TDevice;
    User: string;
    Context: TContext;
    CommandLines: TStringList;
    CommandLineIndex: Integer;
    CommandHistory: TStringList;
    function ExecuteCommand(CommandText: string): string;
    function ContextHelp: string;
    function Prompt: string;
    procedure Write(Text: string);
    procedure WriteLn(Text: string);
    procedure KeyPress(Key: Char);
    procedure KeyPressCode(Key: Word);
    procedure Run;
    constructor Create;
    destructor Destroy; override;
    property CommandLine: string read GetCommandLine write SetCommandLine;
  end;

implementation

function TTerminal.GetCommandLine: string;
begin
  Result := CommandLines[CommandLineIndex];
end;

procedure TTerminal.SetCommandLine(AValue: string);
begin
  CommandLines[CommandLineIndex] := AValue;
end;

function TTerminal.ExecuteCommand(CommandText: string): string;
var
  Index: Integer;
  CommandName: string;
  Commands: TCommands;
  Command: TCommand;
  CommandOutput: string;
begin
  CommandLine := Trim(CommandText);
  if (Length(CommandLine) > 0) and (CommandLine[1] = '/') then begin
    while Assigned(Context.Parent) do
      Context := Context.Parent;
    CommandLine := Trim(Copy(CommandLine, 2, MaxInt));
  end;

  while True do begin
    Index := Pos(' ', CommandLine);
    if Index > 0 then begin
      CommandName := Copy(CommandLine, 1, Index - 1);
      CommandLine := Trim(Copy(CommandLine, Length(CommandName) + 1, MaxInt));
    end else begin
      CommandName := CommandLine;
      CommandLine := '';
    end;
    if CommandName <> '' then begin
      Commands := Context.GetCommands;
      try
        Command := Commands.SearchByName(CommandName);
        if Assigned(Command) then begin
          CommandOutput := Command.Execute(Self, Command);
          if CommandOutput <> '' then Write(LineEnding + CommandOutput);
          if Command.IsContext then
            Continue
            else Break;
        end else begin
          Write(LineEnding + 'bad command name ' + CommandName);
          Break;
        end;
      finally
        FreeAndNil(Commands);
      end;
    end else Break;
  end;
end;

function TTerminal.ContextHelp: string;
var
  I: Integer;
  ParentName: string;
  Commands: TCommands;
begin
  Result := LineEnding + LineEnding;
  Commands := Context.GetCommands;
  Commands.SortAll;
  for I := 0 to Commands.Count - 1 do
    Result := Result + Commands[I].Name + ' -- ' + Commands[I].Description + LineEnding;
  Commands.Free;
  Result := Result + LineEnding;
end;

function TTerminal.Prompt: string;
begin
  Result := '[' + User + '@' + Device.Identity + '] ' + Context.GetPath + '> ';
end;

procedure TTerminal.Write(Text: string);
begin
  Output := Output + Text;
end;

procedure TTerminal.WriteLn(Text: string);
begin
  Write(Text + LineEnding);
end;

procedure TTerminal.KeyPress(Key: Char);
begin
  if Key = '?' then begin
    Write(ContextHelp + Prompt);
  end else
  if Key = #8 then begin
    if Length(CommandLine) > 0 then begin
      CommandLine := Copy(CommandLine, 1, Length(CommandLine) - 1);
      Delete(Output, Length(Output), 1);
    end;
  end else
  if Key = #13 then begin
    CommandHistory.Add(CommandLine);
    ExecuteCommand(CommandLine);

    // Prepare new command line
    Write(LineEnding + Prompt);
    CommandLines.Assign(CommandHistory);
    CommandLines.Add('');
    CommandLineIndex := CommandLines.Count - 1;
  end else begin
    CommandLine := CommandLine + Key;
    Write(Key);
  end;
end;

procedure TTerminal.KeyPressCode(Key: Word);
var
  Commands: TCommands;
begin
  if Key = 9 then begin
    Commands := Context.GetCommandsStartingWith(CommandLine);
    if Commands.Count = 1 then begin
      Write(Copy(Commands[0].Name, Length(CommandLine) + 1, Length(Commands[0].Name)));
      CommandLine := CommandLine + Copy(Commands[0].Name, Length(CommandLine) + 1, Length(Commands[0].Name));
    end;
    Commands.Free;
  end else
  if Key = 38 then begin
    if CommandLineIndex > 0 then begin
      Delete(Output, Length(Output) - Length(CommandLine) + 1, Length(CommandLine));
      Dec(CommandLineIndex);
      Write(GetCommandLine);
    end;
  end else
  if Key = 40 then begin
    if CommandLineIndex < CommandLines.Count - 1 then begin
      Delete(Output, Length(Output) - Length(CommandLine) + 1, Length(CommandLine));
      Inc(CommandLineIndex);
      Write(GetCommandLine);
    end;
  end;
end;

procedure TTerminal.Run;
begin
  CommandLines.Add('');
  CommandLineIndex := 0;
  User := 'admin';
  Context := Device.RootContext;
  WriteLn(Device.Routerboard.Logo.Text);
  WriteLn('');
  WriteLn('  ' + Device.Routerboard.Vendor + ' ' + Device.Routerboard.OS + ' ' +
    Device.Routerboard.Version + ' (c) ' + Device.Routerboard.Copyright + '       ' +
    Device.Routerboard.Website);
  WriteLn('');
  WriteLn('[?]             Gives the list of available commands');
  WriteLn('command [?]     Gives help on the command and list of arguments');
  WriteLn('');
  WriteLn('[Tab]           Completes the command/word. If the input is ambiguous,');
  WriteLn('                a second [Tab] gives possible options');
  WriteLn('');
  WriteLn('/               Move up to base level');
  WriteLn('..              Move up one level');
  WriteLn('/command        Use command at the base level');
  Write(Prompt);
end;

constructor TTerminal.Create;
begin
  CommandHistory := TStringList.Create;
  CommandLines := TStringList.Create;
end;

destructor TTerminal.Destroy;
begin
  FreeAndNil(CommandLines);
  FreeAndNil(CommandHistory);
  inherited Destroy;
end;

end.