public void ParserConstantValueE()
{
var stream = new CommandStream()
{
Line = "E"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(Math.E);
}
public void ParserAssignVariable()
{
var stream = new CommandStream()
{
Line = "VAR=1"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(1);
}
public void ParserSign()
{
var stream = new CommandStream()
{
Line = "SIGN(-100)+SIGN(30)+SIGN(0)+SIGN(234.32)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(1.0);
}
public void ParserLog()
{
var stream = new CommandStream()
{
Line = "LOG(2)+LOG10(10)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(2.0);
}
public void ParserSqrtFractional()
{
var stream = new CommandStream()
{
Line = "SQRT(9)+FACTORIAL(2)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(5);
}
public void ParserASinACosATan()
{
var stream = new CommandStream()
{
Line = "ASIN(1.0)+ACOS(1.0)+ATAN(1.0)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(2.3561944901923448);
}
public void ParserSinCosTan()
{
var stream = new CommandStream()
{
Line = "SIN(1.5707963267948966192313216916398)+COS(0)+TAN(0.78539816339744830961566084581988)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(3.0);
}
public void AddingCommandsTest()
{
var s = new CommandStream(128)
{
MaxProcessingTime = 10
};
s.Add(_cmd1);
s.Add(_cmd2);
s.Add(_cmd3);
Assert.AreEqual(3, s.CommandsCount);
}
public void ParserBitAndOr()
{
var stream = new CommandStream()
{
Line = "(255&8)+(1|2)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(11.0);
}
public void ParserAbsCeilFloor()
{
var stream = new CommandStream()
{
Line = "ABS(-1)+FIX(1.8)+FUP(0.5)+ROUND(1.7)"
}; // FIX=>floor, FUP=>Ceil
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(5.0);
}
public void ParserCompareNotEqual()
{
var stream = new CommandStream()
{
Line = "(1!=2)+(1!=1)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(1.0);
}
public void ParserConstantValueFloatDotMinus()
{
var stream = new CommandStream()
{
Line = "-.5"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(-0.5);
}
public void ParserCompareGt()
{
var stream = new CommandStream()
{
Line = "(1>2)+(1>=1)+(4>1)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(2.0);
}
public void ParserSin()
{
var stream = new CommandStream()
{
Line = "SIN(1.5707963267948966192313216916398)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(1.0);
}
public void ParserXOr()
{
var stream = new CommandStream()
{
Line = "(3||1)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(2.0);
}
public void ParserBitLeftRight()
{
var stream = new CommandStream()
{
Line = "(1<<1)+(16>>1)"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(8.0 + 2.0);
}
public void ParserPow()
{
var stream = new CommandStream()
{
Line = "2^8"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(256);
}
public void ParserMod()
{
var stream = new CommandStream()
{
Line = "14%10"
};
var parser = new ExpressionParser(stream);
parser.Parse();
parser.IsError().Should().BeFalse();
parser.Answer.Should().Be(4.0);
}
public override bool Execute(ICommandSource?source, CommandStream stream)
{
if (stream.ConsumeEnum(out LogLevel level, LogLevel.Info) && stream.Consume(NodeType.STRING, out string?message))
{
if (!string.IsNullOrEmpty(message))
{
Program.LOGGER.Log(message, level);
Console.WriteLine($"Wrote message '{message}' to the logs");
return(true);
}
}
Console.WriteLine("'log' requires at least a single argument.");
return(false);
}
public override bool Execute(ICommandSource?source, CommandStream stream)
{
if (stream.Consume(NodeType.STRING, out string?value))
{
if (Directory.Exists(value))
{
var graph = Tree.FromDirectory(new DirectoryInfo(value));
graph.PrettyPrint(Console.Out, DirectoryTree.NameFactory);
return(true);
}
}
Console.WriteLine("'tree' requires a single argument referring to a valid directory.");
return(false);
}
protected virtual string ReadIdent()
{
var sb = new StringBuilder();
char ch = _reader.NextChar;
sb.Append(ch);
ch = _reader.Next();
while (CommandStream.IsAlpha(ch) || CommandStream.IsDigit(ch))
{
sb.Append(ch);
ch = _reader.Next();
}
return(sb.ToString());
}
public override bool Execute(ICommandSource?source, CommandStream stream)
{
var messages = Program.LOGGER.Messages;
Console.WriteLine("Dumping logs...");
Console.WriteLine();
if (messages.Any())
{
Program.LOGGER.Dump();
}
else
{
Console.WriteLine("No logs found");
}
return(true);
}
public void ProcessingTimeTest(
[Range(2.0, 10.0, 1.0)] double processingTime,
[Values(10, 50, 100)] int numOfCommands)
{
var s = new CommandStream(128)
{
MaxProcessingTime = processingTime
};
var cmdList = new List <DeferredCommand>();
for (int i = 0; i < numOfCommands; i++)
{
var cm1 = new DeferredCommand(_p.PopulateRandomList100)
{
InitExecutionDelayMin = 0.0f,
InitExecutionDelayMax = 0.0f,
ExecutionDelayMin = 0.00001f,
ExecutionDelayMax = 0.00001f
};
s.Add(cm1);
cmdList.Add(cm1);
}
// This is to give Time for the structures within to take their appropriate size
// which may take some Time in the first round.
s.Process();
for (int i = 0; i < 5; i++)
{
s.Process();
#if DISPLAY_LOG
StreamLog(s);
#endif
}
#if DISPLAY_LOG
for (int i = 0; i < numOfCommands; i++)
{
Console.WriteLine("Cmd {0} Executed {1} times.", i, cmdList[i].TimesExecuted);
}
#endif
}
// Use this for initialization
void Start()
{
commandStream = new CommandStream();
commandRecord = new Dictionary <ObjectBase, List <CommandStream> > ();
CommandConversion Do_FrieCommand = (ObjectBase playObj) => {
FrieCommand frie = new FrieCommand();
frie.Execute(playObj);
commandRecord [playObj].Add(frie);
};
CommandConversion Do_EludeCommand = (ObjectBase playObj) => {
EludeCommand elude = new EludeCommand();
elude.Execute(playObj);
commandRecord [playObj].Add(elude);
};
CommandConversion Do_JumpCommand = (ObjectBase playObj) => {
JumpCommand jump = new JumpCommand();
jump.Execute(playObj);
commandRecord [playObj].Add(jump);
};
CommandConversion Do_SupplementCommand = (ObjectBase playObj) => {
SupplementCommand supplement = new SupplementCommand();
supplement.Execute(playObj);
commandRecord [playObj].Add(supplement);
};
CommandConversion Do_WalkCommand = (ObjectBase playObj) => {
WalkCommand walk = new WalkCommand();
walk.Execute(playObj);
commandRecord [playObj].Add(walk);
};
CommandRoute.Add(CommandType.EludeCommand, Do_EludeCommand);
CommandRoute.Add(CommandType.FrieCommand, Do_FrieCommand);
CommandRoute.Add(CommandType.JumpCommand, Do_JumpCommand);
CommandRoute.Add(CommandType.SupplementCommand, Do_SupplementCommand);
CommandRoute.Add(CommandType.WalkCommand, Do_WalkCommand);
}
public ICommandStream Start(string arguments)
{
var info = new ProcessStartInfo(ExecutablePath, arguments)
{
CreateNoWindow = true,
RedirectStandardInput = true,
RedirectStandardOutput = true,
UseShellExecute = false,
WorkingDirectory = WorkingDirectory,
};
var process = new Process
{
StartInfo = info,
};
process.Start();
var stream = new CommandStream(process);
return(stream);
}
private bool EvaluateParameterValue(CommandState state, out double paramvalue)
{
var linestream = new CommandStream()
{
Line = GCodeAdd
};
var expressionparser = new GCodeExpressionParser(linestream)
{
ParameterValues = state.ParameterValues
};
expressionparser.Parse();
if (expressionparser.IsError())
{
paramvalue = 0;
return(false);
}
paramvalue = expressionparser.Answer;
return(true);
}
public override bool Execute(ICommandSource?source, CommandStream stream)
{
if (stream.Consume(NodeType.LITERAL, out string?name))
{
if (stream.Consume(NodeType.STRING, out string?value))
{
if (ContainsCommandLabel(name !))
{
Console.WriteLine($"A command of the name '{name}' already exists.");
return(false);
}
TestCommandsBleeding.Commands.Add(new AnonCommand(name !, value !));
Console.WriteLine($"Set alias for {value} to {name}.");
return(true);
}
}
Console.WriteLine("'alias' requires a two arguments; one referring to a valid name, and one referring to a valid command(s).");
return(false);
}
public bool TryGetVariable(char name, CommandState state, out double val)
{
Variable var = GetVariable(name);
if (var?.Value != null)
{
val = var.Value.Value;
return(true);
}
if (var?.Parameter != null)
{
if (var.ParameterIsTerm)
{
var lineStream = new CommandStream()
{
Line = var.Parameter
};
var expressionParser = new GCodeExpressionParser(lineStream)
{
ParameterValues = state.ParameterValues
};
expressionParser.Parse();
if (!expressionParser.IsError())
{
val = expressionParser.Answer;
return(true);
}
}
else if (int.TryParse(var.Parameter, out int parameterNo) && state.ParameterValues.ContainsKey(parameterNo))
{
val = state.ParameterValues[parameterNo];
return(true);
}
}
val = 0;
return(false);
}
public override void ReadFrom(CommandStream stream)
{
int saveIndex = stream.PushIdx();
stream.Next();
if (stream.IsNumber())
{
int parameter = stream.GetInt();
if (parameter >= 0 && stream.SkipSpacesToUpper() == '=')
{
stream.Next();
ParameterNo = parameter;
}
else
{
// error => do not analyse line
stream.PopIdx(saveIndex);
}
}
ReadFromToEnd(stream);
}
public override bool Execute(ICommandSource?source, CommandStream stream) => Dispatch(this, command);
