/// <summary>
/// Create a new NamedValue lookup given name and value.
/// </summary>
/// <param name="name">The name of the value. Or null if the name was not used for this value.</param>
/// <param name="value">The value - a literal.</param>
public NamedValue(string name, LiteralToken value)
{
ExceptionUtils.CheckArgumentNotNull(value, "value");
this.name = name;
this.value = value;
}
public void Run(ICommandInteraction writer, [Values("Noisy", "Debug", "Info", "Warning", "Error")] StringToken level, LiteralToken backendName, LiteralToken peripheralName)
{
if(!SetLogLevel(LogLevel.Parse(level.Value), backendName.Value, peripheralName.Value))
{
writer.WriteError(string.Format("Could not find emulation element or backend"));
}
}
public void Run(ICommandInteraction writer, LiteralToken variable, Token value)
{
var varName = variable.Value;
varName = GetVariableName(varName);
SetVariable(varName, value);
}
public void Run(ICommandInteraction writer, [Values(-1L, 0L, 1L, 2L, 3L)] NumericToken level, LiteralToken backendName, LiteralToken peripheralName)
{
if(!SetLogLevel((LogLevel)level.Value, backendName.Value, peripheralName.Value))
{
writer.WriteError(string.Format("Could not find emulation element or backend"));
}
}
public void Run(ICommandInteraction writer, LiteralToken peripheralName)
{
var emu = EmulationManager.Instance.CurrentEmulation;
IPeripheral p;
string fake;
var m = monitor.Machine;
if(m == null || !m.TryGetByName(peripheralName.Value, out p, out fake))
{
writer.WriteError(string.Format("Peripheral not found: {0}", peripheralName.Value));
return;
}
IAnalyzableBackend backend;
if(!emu.BackendManager.TryGetBackendFor(p, out backend))
{
writer.WriteError(string.Format("No backend found for {0}", peripheralName.Value));
return;
}
foreach(var a in emu.BackendManager.GetAvailableAnalyzersFor(backend))
{
writer.WriteLine(a);
}
}
public static RangeNode BuildRangeNode(LiteralToken from, LiteralToken to)
{
var rangeNode = new RangeNode(TokenBuilder.BuildRangeToken());
rangeNode.ChildNodes.Add(BuildLiteralNode(from));
rangeNode.ChildNodes.Add(BuildLiteralNode(to));
return rangeNode;
}
public void NamedValueDefaultTest()
{
LiteralToken literal = new LiteralToken(null);
NamedValue keyValue = new NamedValue("a", literal);
this.Assert.AreEqual("a", keyValue.Name, "The Name property has an unexpected value.");
this.Assert.AreEqual(literal, keyValue.Value, "The Value property has an unexpected value.");
}
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName, BooleanToken traceReturn, params LiteralToken[] types)
{
var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm));
var cpuTracer = EnsureTracer(cpu);
var handler = new DefaultFunctionHandler(cpu);
var paramList = new List<FunctionCallParameter>();
foreach(var parameter in types)
{
FunctionCallParameterType paramType;
if(!Enum.TryParse(parameter.Value, out paramType))
{
throw new RecoverableException("{0} is not a proper parameter type.".FormatWith(parameter.Value));
}
paramList.Add(new FunctionCallParameter{ Type = paramType });
}
handler.CallParameters = paramList.Take(paramList.Count - (traceReturn.Value ? 1 : 0));
handler.ReturnParameter = traceReturn.Value ? paramList.Last() : (FunctionCallParameter?)null;
if(traceReturn.Value)
{
cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler, handler.ReturnParameter, handler.ReturnHandler);
}
else
{
cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler);
}
}
public void UnsupportedTokenBinderErrorTest()
{
IEdmModel model = QueryTestMetadata.BuildTestMetadata(this.PrimitiveTypeResolver, this.UntypedDataServiceProviderFactory);
var binder = new ErrorMetadataBinder(model);
var token = new LiteralToken("d");
Action action = () => binder.Bind(token);
action.ShouldThrow<ODataException>().WithMessage(ODataErrorStrings.MetadataBinder_BoundNodeCannotBeNull(token.Kind));
}
public void Run(ICommandInteraction writer, [Values(-1L, 0L, 1L, 2L, 3L)] DecimalIntegerToken level, LiteralToken peripheralOrBackendName)
{
if(!SetLogLevel((LogLevel)level.Value, null, peripheralOrBackendName.Value)
&& !SetLogLevel((LogLevel)level.Value, peripheralOrBackendName.Value, null))
{
writer.WriteError(string.Format("Could not find emulation element or backend named: {0}", peripheralOrBackendName.Value));
}
}
public void UnaryOperatorQueryTokenDefaultTest()
{
LiteralToken operand = new LiteralToken(null);
UnaryOperatorToken unary = new UnaryOperatorToken(UnaryOperatorKind.Negate, operand);
this.Assert.AreEqual(QueryTokenKind.UnaryOperator, unary.Kind, "The InternalKind property has an unexpected value.");
this.Assert.AreEqual(UnaryOperatorKind.Negate, unary.OperatorKind, "The OperatorKind property should be Negate.");
this.Assert.AreEqual(operand, unary.Operand, "The Operand property has an unexpected value.");
}
public void Run(ICommandInteraction writer, [Values("Noisy", "Debug", "Info", "Warning", "Error")] StringToken level, LiteralToken peripheralOrBackendName)
{
var logLevel = LogLevel.Parse(level.Value);
if(!SetLogLevel(logLevel, null, peripheralOrBackendName.Value)
&& !SetLogLevel(logLevel, peripheralOrBackendName.Value, null))
{
writer.WriteError(string.Format("Could not find emulation element or backend named: {0}", peripheralOrBackendName.Value));
}
}
/// <summary>
/// Parses null literals.
/// </summary>
/// <param name="lexer">The lexer to use.</param>
/// <returns>The literal token produced by building the given literal.</returns>
private static LiteralToken ParseNullLiteral(ExpressionLexer lexer)
{
Debug.Assert(lexer != null, "lexer != null");
Debug.Assert(lexer.CurrentToken.Kind == ExpressionTokenKind.NullLiteral, "this.lexer.CurrentToken.InternalKind == ExpressionTokenKind.NullLiteral");
LiteralToken result = new LiteralToken(null, lexer.CurrentToken.Text);
lexer.NextToken();
return(result);
}
public void SetStateTokenizeLiteral()
{
var lexer = new Lexer();
var tokens = lexer.Tokenize("[e");
var expected = new LiteralToken {
Character = 'e'
};
Assert.AreEqual(tokens.Last(), expected);
}
public void EscapeStateTokenizeLiteral()
{
var lexer = new Lexer(nodeBuilder.TokenBuilder);
var tokens = lexer.Tokenize("\\z");
var expected = new LiteralToken {
Character = 'z'
};
Assert.AreEqual(tokens.Last(), expected);
}
public void CommandHelp(ICommandInteraction writer, LiteralToken commandName)
{
if(!GetCommands().Any(x => x.Name == commandName.Value))
{
writer.WriteError(String.Format("No such command: {0}.", commandName.Value));
return;
}
var command = GetCommands().First(x => x.Name == commandName.Value);
command.PrintHelp(writer);
}
public void BinaryOperatorQueryTokenDefaultTest()
{
LiteralToken left = new LiteralToken(null);
LiteralToken right = new LiteralToken(null);
BinaryOperatorToken binary = new BinaryOperatorToken(BinaryOperatorKind.Or, left, right);
this.Assert.AreEqual(QueryTokenKind.BinaryOperator, binary.Kind, "The InternalKind property has an unexpected value.");
this.Assert.AreEqual(BinaryOperatorKind.Or, binary.OperatorKind, "The OperatorKind property should be Or.");
this.Assert.AreEqual(left, binary.Left, "The Left property has an unexpected value.");
this.Assert.AreEqual(right, binary.Right, "The Right property has an unexpected value.");
}
/// <summary>
/// Binds a literal value to a ConstantNode
/// </summary>
/// <param name="literalToken">Literal token to bind.</param>
/// <returns>Bound query node.</returns>
internal static ConstantNode BindLiteral(LiteralToken literalToken)
{
ExceptionUtils.CheckArgumentNotNull(literalToken, "literalToken");
if (!string.IsNullOrEmpty(literalToken.OriginalText))
{
return(new ConstantNode(literalToken.Value, literalToken.OriginalText));
}
return(new ConstantNode(literalToken.Value));
}
public void BinaryOperatorQueryTokenDefaultTest()
{
LiteralToken left = new LiteralToken(null);
LiteralToken right = new LiteralToken(null);
BinaryOperatorToken binary = new BinaryOperatorToken(BinaryOperatorKind.Or, left, right);
this.Assert.AreEqual(QueryTokenKind.BinaryOperator, binary.Kind, "The InternalKind property has an unexpected value.");
this.Assert.AreEqual(BinaryOperatorKind.Or, binary.OperatorKind, "The OperatorKind property should be Or.");
this.Assert.AreEqual(left, binary.Left, "The Left property has an unexpected value.");
this.Assert.AreEqual(right, binary.Right, "The Right property has an unexpected value.");
}
public void CommandHelp(ICommandInteraction writer, LiteralToken commandName)
{
if (!GetCommands().Any(x => x.Name == commandName.Value))
{
writer.WriteError(String.Format("No such command: {0}.", commandName.Value));
return;
}
var command = GetCommands().First(x => x.Name == commandName.Value);
command.PrintHelp(writer);
}
public void NullValueShouldThrow()
{
const string text = "(1,2,3)";
var expectedType = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false)));
object collection = ODataUriConversionUtils.ConvertFromCollectionValue("[1,2,3]", HardCodedTestModel.TestModel, expectedType);
LiteralToken literalToken = new LiteralToken(collection, text, expectedType);
Action target = () => new CollectionConstantNode(null, text, expectedType);
Assert.Throws <ArgumentNullException>("objectCollection", target);
}
public void NullCollectionTypeShouldThrow()
{
const string text = "(1,2,3)";
var expectedType = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false)));
object collection = ODataUriConversionUtils.ConvertFromCollectionValue("[1,2,3]", HardCodedTestModel.TestModel, expectedType);
LiteralToken literalToken = new LiteralToken(collection, text, expectedType);
Action target = () => new CollectionConstantNode((literalToken.Value as ODataCollectionValue)?.Items, text, null);
target.ShouldThrow <ArgumentNullException>().Where(e => e.Message.Contains("collectionType"));
}
public void KindIsSetCorrectly()
{
const string text = "(1,2,3)";
var expectedType = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false)));
object collection = ODataUriConversionUtils.ConvertFromCollectionValue("[1,2,3]", HardCodedTestModel.TestModel, expectedType);
LiteralToken literalToken = new LiteralToken(collection, text, expectedType);
CollectionConstantNode collectionConstantNode = new CollectionConstantNode(
(literalToken.Value as ODataCollectionValue)?.Items, text, expectedType);
Assert.Equal(InternalQueryNodeKind.CollectionConstant, collectionConstantNode.InternalKind);
}
protected StringToken ParseString()
{
//System.Diagnostics.Debugger.Launch();
LiteralToken stringToken = (LiteralToken)Eat(TokenType.Literal);
if (stringToken.LiteralType != LiteralTokenType.String)
{
ReportError(Resources.ParserTokenUnexpected, stringToken.ToString());
throw new NotSupportedException();
}
return((StringToken)stringToken);
}
public void Equals_ValuesAreEqual_ReturnsTrue()
{
// arrange
var sut1 = new LiteralToken(new SourceLocation(3, 6), 'a');
var sut2 = new LiteralToken(new SourceLocation(3, 6), 'a');
// act
var result = sut1.Equals(sut2);
// assert
Assert.True(result);
}
public void Equals_ValueIsDifferent_ReturnsFalse()
{
// arrange
var sut1 = new LiteralToken(new SourceLocation(3, 6), 'a');
var sut2 = new LiteralToken(new SourceLocation(3, 6), 'b');
// act
var result = sut1.Equals(sut2);
// assert
Assert.False(result);
}
public void ItemTypeIsSetCorrectly()
{
const string text = "(1,2,3)";
var expectedType = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false)));
object collection = ODataUriConversionUtils.ConvertFromCollectionValue("[1,2,3]", HardCodedTestModel.TestModel, expectedType);
LiteralToken literalToken = new LiteralToken(collection, text, expectedType);
CollectionConstantNode collectionConstantNode = new CollectionConstantNode(
(literalToken.Value as ODataCollectionValue)?.Items, text, expectedType);
collectionConstantNode.ItemType.FullName().Should().Be("Edm.Int32");
}
public virtual Token GetToken()
{
Skip();
var t = TryLiteral()
?? TryVariable()
?? TryParameter()
?? TryUnary()
?? TryGroup()
?? TryObject()
?? (Token)TryShortArray();
if (t == null)
{
return(t);
}
if (t is VariableToken vt)
{
if (settings.TryGetKnownValue(vt.Name, out var value))
{
t = new LiteralToken(value);
}
else if (vt.Name == "new")
{
Skip();
t = (Token)TryObject() ?? GetArray();
}
}
if (Done())
{
return(t);
}
Token r;
do
{
Skip();
r = t;
t = TryMember(t)
?? TryIndexer(t)
?? TryLambda(t)
?? TryCall(t)
?? TryTernary(t)
?? (Token)TryBinary(t);
} while (t != null);
return(r);
}
public void GetHashCode_ValuesAreEqual_ReturnsSameHashCode()
{
// arrange
var sut1 = new LiteralToken(new SourceLocation(3, 6), 'a');
var sut2 = new LiteralToken(new SourceLocation(3, 6), 'a');
// act
var hashCode1 = sut1.GetHashCode();
var hashCode2 = sut2.GetHashCode();
// assert
Assert.Equal(hashCode1, hashCode2);
}
public void Ctor_WhenCalled_SetsProperties()
{
// arrange
var location = new SourceLocation(2, 3);
// act
var sut = new LiteralToken(location, 'b');
// assert
Assert.Equal(2, sut.Location.LineNumber);
Assert.Equal(3, sut.Location.CharacterNumber);
Assert.Equal('b', sut.Value);
}
public void GetHashCode_ValuesAreNotEqual_ReturnsDifferentHashCodes()
{
// arrange
var sut1 = new LiteralToken(new SourceLocation(3, 6), 'a');
var sut2 = new LiteralToken(new SourceLocation(3, 6), 'b');
// act
var hashCode1 = sut1.GetHashCode();
var hashCode2 = sut2.GetHashCode();
// act, assert
Assert.NotEqual(hashCode1, hashCode2);
}
public void Run(ICommandInteraction writer, [Values("set")] LiteralToken action, DecimalIntegerToken number)
{
var machines = EmulationManager.Instance.CurrentEmulation.Machines.ToArray();
if (machines.Length > number.Value && number.Value >= 0)
{
SetCurrentMachine(machines[number.Value]);
}
else
{
writer.WriteError("Wrong machine number. Type {0} to show a list of available machines.".FormatWith(Name));
}
}
public void AnyTokenWithNonConstantExpressionNullParameter()
{
this.expressionQueryNode = new UnaryOperatorNode(UnaryOperatorKind.Negate, new ConstantNode(false));
var binder = new LambdaBinder(this.FakeBindMethod);
var state = this.GetBindingStateForTest(HardCodedTestModel.GetPersonTypeReference(), HardCodedTestModel.GetPeopleSet());
var expression = new LiteralToken("foo");
var parent = new LiteralToken("bar");
var anyToken = new AnyToken(expression, null, parent);
var result = binder.BindLambdaToken(anyToken, state);
result.ShouldBeAnyQueryNode().And.Source.ShouldBeEntitySetQueryNode(HardCodedTestModel.GetPeopleSet());
result.Body.ShouldBeUnaryOperatorNode(UnaryOperatorKind.Negate);
}
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand, TraceDisableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName)
{
if (enable.Value == TraceEnableCommand)
{
Execute(writer, cpuToken, functionName.Value, false, null);
}
else
{
var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm));
var cpuTracer = EnsureTracer(cpu);
cpuTracer.RemoveTracing(functionName.Value);
}
}
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand, TraceDisableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName)
{
if(enable.Value == TraceEnableCommand)
{
Execute(writer, cpuToken, functionName.Value, false, null);
}
else
{
var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm));
var cpuTracer = EnsureTracer(cpu);
cpuTracer.RemoveTracing(functionName.Value);
}
}
public void AnyTokenWithNonConstantExpressionNullParameter()
{
this.expressionQueryNode = new UnaryOperatorNode(UnaryOperatorKind.Negate, new ConstantNode(false));
var binder = new LambdaBinder(this.FakeBindMethod);
var state = this.GetBindingStateForTest(HardCodedTestModel.GetPersonTypeReference(), HardCodedTestModel.GetPeopleSet());
var expression = new LiteralToken("foo");
var parent = new LiteralToken("bar");
var anyToken = new AnyToken(expression, null, parent);
var result = binder.BindLambdaToken(anyToken, state);
result.ShouldBeAnyQueryNode().And.Source.ShouldBeEntitySetQueryNode(HardCodedTestModel.GetPeopleSet());
result.Body.ShouldBeUnaryOperatorNode(UnaryOperatorKind.Negate);
}
public void InnerFilterSetCorrectly()
{
// Arrange & Act
QueryToken filter = new LiteralToken(21);
SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null),
filter, null, null, null, null, null, null, null);
// Assert
Assert.NotNull(selectTerm.FilterOption);
LiteralToken literalToken = Assert.IsType <LiteralToken>(selectTerm.FilterOption);
Assert.Equal(QueryTokenKind.Literal, literalToken.Kind);
Assert.Equal(21, literalToken.Value);
}
public void SetOrAdd(ICommandInteraction writer, [Values("set", "add")] LiteralToken action, PathToken path)
{
switch (action.Value)
{
case "set":
monitorPath.Path = path.Value;
break;
case "add":
monitorPath.Append(path.Value);
break;
}
PrintCurrentPath(writer);
}
private void Execute(ICommandInteraction writer, LiteralToken cpuToken, String functionName, bool traceReturn, int?numberOfParameters)
{
var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm));
var cpuTracer = EnsureTracer(cpu);
Type handlerType;
IFunctionHandler handler;
if (!handlers.TryGetValue(functionName, out handlerType))
{
if (numberOfParameters.HasValue)
{
var paramList = new List <FunctionCallParameter>();
for (var i = 0; i < numberOfParameters; ++i)
{
paramList.Add(new FunctionCallParameter {
Type = FunctionCallParameterType.UInt32
});
}
FunctionCallParameter?returnParameter = null;
if (traceReturn)
{
returnParameter = new FunctionCallParameter {
Type = FunctionCallParameterType.UInt32
};
}
var defHandler = new DefaultFunctionHandler(cpu);
defHandler.CallParameters = paramList;
defHandler.ReturnParameter = returnParameter;
handler = defHandler;
}
else
{
throw new RecoverableException("Handler for {0} not register. You must provide numberOfParameters to use default handler.".FormatWith(functionName));
}
}
else
{
handler = Dynamic.InvokeConstructor(handlerType, cpu);
}
if (traceReturn)
{
cpuTracer.TraceFunction(functionName, handler.CallParameters, handler.CallHandler, handler.ReturnParameter, handler.ReturnHandler);
}
else
{
cpuTracer.TraceFunction(functionName, handler.CallParameters, handler.CallHandler);
}
}
Token GetToken()
{
Skip();
Token t = TryLiteral()
?? TryVariable()
?? TryParameter()
?? TryUnary()
?? (Token)TryGroup();
if (t == null)
{
return(t);
}
if (t is VariableToken vt)
{
if (knowns.TryGetValue(vt.Name, out var value))
{
t = new LiteralToken(value);
}
else if (vt.Name == "new")
{
t = GetObject();
}
}
if (Done())
{
return(t);
}
Token r;
do
{
Skip();
r = t;
t = TryMember(t)
?? TryIndexer(t)
?? TryLambda(t)
?? TryCall(t)
?? TryTernary(t)
?? (Token)TryBinary(t);
} while (t != null);
return(r);
}
public override Exp Analy( )
{
if (this.IsAnalyed)
{
return(this);
}
RetType = AnalyLiteralZType();
if (RetType == null)
{
Errorf(this.Position, LiteralToken.ToCode() + "不是正确的值");
}
IsAnalyed = true;
return(this);
}
private static void VerifyBinaryOperatorToken <T>(string expectedEndPathIdentifier, BinaryOperatorKind expectedOperator, T expectedLiteralValue, BinaryOperatorToken actual)
{
Assert.NotNull(actual);
Assert.Equal(actual.OperatorKind, expectedOperator);
EndPathToken left = actual.Left as EndPathToken;
Assert.NotNull(left);
Assert.Equal(left.Identifier, expectedEndPathIdentifier);
LiteralToken right = actual.Right as LiteralToken;
Assert.NotNull(right);
Assert.Equal(right.Value, expectedLiteralValue);
}
public void Run(ICommandInteraction writer, LiteralToken use)
{
if(use.Value == "-")
{
GetUsings().Clear();
}
else
{
var dotted = use.Value + (use.Value.Last() == '.' ? "" : "."); //dot suffix
if(!GetUsings().Contains(dotted))
{
GetUsings().Add(dotted);
}
}
}
public void Run(ICommandInteraction writer, [Values("create", "clear")] LiteralToken action)
{
switch (action.Value)
{
case "clear":
SetCurrentMachine(null);
break;
case "create":
var machine = new Machine();
EmulationManager.Instance.CurrentEmulation.AddMachine(machine);
SetCurrentMachine(machine);
break;
}
}
private static void VerifyBinaryOperatorToken <T>(string expectedEndPathIdentifier, BinaryOperatorKind expectedOperator, T expectedLiteralValue, BinaryOperatorToken actual)
{
actual.Should().NotBeNull();
actual.OperatorKind.Should().Be(expectedOperator);
EndPathToken left = actual.Left as EndPathToken;
left.Should().NotBeNull();
left.Identifier.Should().Be(expectedEndPathIdentifier);
LiteralToken right = actual.Right as LiteralToken;
right.Should().NotBeNull();
right.Value.Should().Be(expectedLiteralValue);
}
public void Run(ICommandInteraction writer, LiteralToken use)
{
if (use.Value == "-")
{
GetUsings().Clear();
}
else
{
var dotted = use.Value + (use.Value.Last() == '.' ? "" : "."); //dot suffix
if (!GetUsings().Contains(dotted))
{
GetUsings().Add(dotted);
}
}
}
public void FilterSetCorrectly()
{
QueryToken filter = new LiteralToken(1);
ExpandTermToken expandTerm = new ExpandTermToken(new NonSystemToken("stuff", null, null),
filter,
null /*orderByOption*/,
null /*topOption*/,
null /*skipOption*/,
null /*countQueryOption*/,
null /*levelsOption*/,
null /*searchOption*/,
null /*selectOption*/,
null /*expandOption*/);
expandTerm.FilterOption.ShouldBeLiteralQueryToken(1);
}
internal override bool Apply(StringReader reader, ref Token parentToken, ref Token previousToken)
{
var temp = previousToken as LiteralToken;
if (temp != null)
{
temp.AddChar(reader.CurrentChar);
}
else
{
var token = new LiteralToken(reader.CurrentChar);
parentToken.AddChild(token);
previousToken = token;
}
return true;
}
/// <summary>
/// Binds a literal value to a ConstantNode
/// </summary>
/// <param name="literalToken">Literal token to bind.</param>
/// <returns>Bound query node.</returns>
internal static ConstantNode BindLiteral(LiteralToken literalToken)
{
ExceptionUtils.CheckArgumentNotNull(literalToken, "literalToken");
if (!string.IsNullOrEmpty(literalToken.OriginalText))
{
if (literalToken.ExpectedEdmTypeReference != null)
{
return new ConstantNode(literalToken.Value, literalToken.OriginalText, literalToken.ExpectedEdmTypeReference);
}
return new ConstantNode(literalToken.Value, literalToken.OriginalText);
}
return new ConstantNode(literalToken.Value);
}
public void Run(ICommandInteraction writer, StringToken analyzerName, LiteralToken peripheral, LiteralToken analyzerTypeName)
{
try
{
var analyzer = GetAnalyzer(peripheral.Value, analyzerTypeName == null ? null : analyzerTypeName.Value);
if (analyzerName != null)
{
EmulationManager.Instance.CurrentEmulation.ExternalsManager.AddExternal((IExternal)analyzer, analyzerName.Value);
}
analyzer.Show();
}
catch (Exception e)
{
throw new RecoverableException(string.Format("Received '{0}' error while initializng analyzer for: {1}. Are you missing a required plugin?", e.Message, peripheral.Value));
}
}
public void Run(ICommandInteraction writer, [Values("default")] LiteralToken @default, LiteralToken peripheralName)
{
var emu = EmulationManager.Instance.CurrentEmulation;
IPeripheral p;
string fake;
var m = monitor.Machine;
if(m == null || !m.TryGetByName(peripheralName.Value, out p, out fake))
{
writer.WriteError(string.Format("Peripheral not found: {0}", peripheralName.Value));
return;
}
IAnalyzableBackend backend;
if(!emu.BackendManager.TryGetBackendFor(p, out backend))
{
writer.WriteError(string.Format("No backend found for {0}", peripheralName.Value));
return;
}
var def = emu.BackendManager.GetPreferredAnalyzerFor(backend);
writer.WriteLine(def ?? "No default analyzer found.");
}
public void Run(ICommandInteraction writer, LiteralToken peripheral, LiteralToken analyzerTypeName)
{
Run(writer, null, peripheral, analyzerTypeName);
}
public void Run(ICommandInteraction writer, LiteralToken peripheral)
{
Run(writer, peripheral, null);
}
public void Run(ICommandInteraction writer, StringToken analyzerName, LiteralToken peripheral)
{
Run(writer, analyzerName, peripheral, null);
}
public FieldStatement(TypeStatement type, LiteralToken name, Expression expression)
{
Type = type;
Name = name;
Expression = expression;
}
public void Run(ICommandInteraction writer, LiteralToken peripheral, StringToken viewId)
{
Run(writer, null, peripheral, viewId);
}
protected override QueryNode BindLiteral(LiteralToken literalToken)
{
return null;
}
private AnyToken CreateTestAnyQueryToken()
{
var expression = new LiteralToken("foo");
var parent = new LiteralToken("bar");
return new AnyToken(expression, "p", parent);
}
private static void VerifyLiteralQueryTokensAreEqual(LiteralToken expected, LiteralToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Value, actual.Value, "Literal values are different.");
}
