public static Argument Evaluate(CompilerState state, SyntaxNode node)
{
if (state is null)
{
throw new ArgumentNullException(nameof(state));
}
if (node is null)
{
throw new ArgumentNullException(nameof(node));
}
var result = node switch
{
TextSyntax text => textInstruction.Evaluate(state, text),
QuoteSyntax quote => quoteInstruction.Evaluate(state, quote),
StringLiteralSyntax stringLiteral => stringInstruction.Evaluate(state, stringLiteral),
ArgumentSyntax argumentSyntax => argumentInstruction.Evaluate(state, argumentSyntax),
CommandSyntax command => commandInstruction.Evaluate(state, command),
ObjectSyntax objectSyntax => objectCreationInstruction.Evaluate(state, objectSyntax),
FieldSyntax fieldSyntax => fieldInstruction.Evaluate(state, fieldSyntax),
ArraySyntax arraySyntax => arrayInstruction.Evaluate(state, arraySyntax),
PercentSyntax percentSyntax => percentInstruction.Evaluate(state, percentSyntax),
ListSyntax list => blockInstruction.Evaluate(state, list),
CommentSyntax _ => null,
_ => throw new ArgumentException($"Evaluation of node type {node.GetType().Name} not implemented.", nameof(node)),
};
return(new Argument(node, result));
}
private static CommandSyntax ParseCommand(ParserContext context)
{
var token = context.Tokens.Dequeue();
var span = token.Span;
var command = new CommandSyntax
{
Name = ParseName(context)
};
var nextTokenParentheses = context.Tokens.Peek().Type == TokenType.ParenthesesOpen;
if (nextTokenParentheses)
{
command.Arguments = ParseArguments(context);
}
else
{
command.Arguments = new ListSyntax <ArgumentSyntax>();
}
if (context.Tokens.SkipSearchFor(e => e.Type == TokenType.Whitespace || e.Type == TokenType.Newline, e => e.Type == TokenType.CurlyOpen))
{
command.Environment = ParseExplicitBlock(context);
}
token = context.Tokens.Peek();
command.Span = span.WithEnd(token.Span.End);
return(command);
}
public string GetCommandSyntax(CommandInfo command)
{
CommandSyntax syntax = new CommandSyntax(command);
string space = string.IsNullOrWhiteSpace(command.GetName()) ? "" : " ";
string group = command.Module.Group.Exists() ? $"{command.Module.Group}{space}" : "";
return($"{group}{Format.Bold(command.GetName())}({syntax.GetArgs()})");
}
public async Task <CommandSyntax> StoreCommand(CommandSyntax commandSyntax)
{
if (!_initialized)
{
await Initialize();
}
commandSyntax.Key = Guid.NewGuid();
_commands.Add(Guid.NewGuid(), commandSyntax);
await using var sr = new StreamWriter(_storageFilePath);
await sr.WriteAsync(JsonConvert.SerializeObject(_commands.Select(x => x.Value)));
return(commandSyntax);
}
public void Setup()
{
Syntax = new CommandSyntax();
Parser = new CommandParser(Syntax);
Validator = new CommandValidator(Parser, new MockLocalizer());
MockMethods = new MockCommand();
Generator = new CandidatesGenerator(Syntax);
Switch = new ArgumentRule("switch", MockMethods.Switch);
Click = new ArgumentRule("click", MockMethods.Click);
RightClick = new ArgumentRule("rightclick", MockMethods.RightClick);
DoubleClick = new ArgumentRule("doubleclick", MockMethods.DoubleClick);
ArgApplication = new ArgumentRule("application", MockMethods.Application, ArgsFactory(Switch));
ArgWindow = new ArgumentRule("window", MockMethods.Window, ArgsFactory(Click, RightClick, DoubleClick));
ArgTaskbar = new ArgumentRule("taskbar", MockMethods.Taskbar, ArgsFactory(Click, RightClick));
ArgDividedscreen = new ArgumentRule("windowdividedscreen", MockMethods.WindowDividedScreen, ArgsFactory(Click, DoubleClick));
ArgText = new ArgumentRule("Text", MockMethods.Text);
ArgCommand = new ArgumentRule("Command", MockMethods.Command);
ArgInItemsControl = new ArgumentRule("TextInItemsControl", MockMethods.TextInItemsControl);
OptButton = new ArgumentRule("Button", MockMethods.Button);
OptCheckBox = new ArgumentRule("CheckBox", MockMethods.CheckBox);
OptGenerator = new ArgumentRule("-hintGenerator", MockMethods.HintGenerator);
OptTarget = new ArgumentRule("-searchTarget", MockMethods.SearchTarget, null, ArgsFactory(OptButton, OptCheckBox));
Hah = new CommandRule("hah", MockMethods.HitaHint, ArgsFactory(ArgWindow, ArgApplication, ArgTaskbar, ArgDividedscreen), ArgsFactory(OptGenerator, OptTarget));
SearchByText = new CommandRule("/", MockMethods.SearchByText, ArgsFactory(ArgText, ArgCommand, ArgInItemsControl), ArgsFactory(OptTarget));
Hah2 = new CommandRule("hah2", MockMethods.HitaHint2, ArgsFactory(ArgWindow, ArgDividedscreen));
MouseEmulation = new CommandRule("me", MockMethods.MouseEmulation);
Syntax.Add(Hah);
Syntax.Add(SearchByText);
Syntax.Add(Hah2);
Syntax.Add(MouseEmulation);
}
