public TokenValue(List<Expression> comparisons, Expression comparisonArray) {
_integer1 = 0;
_double = 0.0;
node = comparisonArray;
obj = comparisons;
_type = TokenValueType.None;
}
public Maplet(Expression/*!*/ key, Expression/*!*/ value, SourceSpan location)
: base(location) {
Assert.NotNull(key, value);
_key = key;
_value = value;
}
public ElseIfClause(Expression condition, List<Expression>/*!*/ statements, SourceSpan location)
: base(location) {
Assert.NotNullItems(statements);
_statements = statements;
_condition = condition;
}
string GetRequireString(Expression[] expressions)
{
foreach (Expression expression in expressions) {
StringConstructor stringCtor = expression as StringConstructor;
if (stringCtor != null) {
return (string)RubyCodeDeserializer.Deserialize(stringCtor);
}
}
return null;
}
public void SetUpFixture()
{
componentCreator = new MockComponentCreator();
SimpleAssignmentExpression assignment = RubyParserHelper.GetSimpleAssignmentExpression(GetRubyCode());
rhsAssignmentExpression = assignment.Right;
mockDesignerLoaderHost = new MockDesignerLoaderHost();
typeResolutionService = mockDesignerLoaderHost.TypeResolutionService;
RubyCodeDeserializer deserializer = new RubyCodeDeserializer(componentCreator);
deserializedObject = deserializer.Deserialize(rhsAssignmentExpression);
}
public object Deserialize(string name, Expression expression)
{
if (expression == null) {
throw new ArgumentNullException("expression");
}
if (expression is MethodCall) {
return Deserialize(name, (MethodCall)expression);
} else if (expression is Literal) {
return Deserialize((Literal)expression);
} else if (expression is StringConstructor) {
return Deserialize((StringConstructor)expression);
} else if (expression is InstanceVariable) {
return Deserialize((InstanceVariable)expression);
} else if (expression is SelfReference) {
return Deserialize((SelfReference)expression);
} else if (expression is LocalVariable) {
return Deserialize((LocalVariable)expression);
}
return null;
}
public CompoundRightValue(Expression/*!*/[]/*!*/ rightValues, Expression splattedValue) {
Assert.NotNull(rightValues);
_rightValues = rightValues;
_splattedValue = splattedValue;
}
private bool IsSelfModuleReference(Expression target, out string moduleName)
{
if (target == null) {
moduleName = null;
return false;
}
if (target.NodeType == NodeTypes.SelfReference) {
moduleName = _outerModules.Peek().QualifiedName;
return true;
}
if (target.NodeType == NodeTypes.ConstantVariable) {
string prefix = (_outerName.Count >= 2) ? _outerName[_outerName.Count - 2] : null;
moduleName = BuildName(prefix, (ConstantVariable)target);
return String.Equals(moduleName, _outerModules.Peek().QualifiedName, StringComparison.Ordinal);
}
moduleName = "<object>";
return false;
}
void ThrowCouldNotFindTypeException(Expression expression)
{
string typeName = String.Empty;
MethodCall methodCall = expression as MethodCall;
if (methodCall != null) {
typeName = RubyControlFieldExpression.GetMemberName(methodCall);
}
string message = String.Format(StringParser.Parse("${res:ICSharpCode.PythonBinding.UnknownTypeName}"), typeName);
throw new RubyComponentWalkerException(message);
}
bool IsResource(Expression expression)
{
MethodCall methodCall = expression as MethodCall;
if (methodCall != null) {
string memberName = RubyControlFieldExpression.GetMemberName(methodCall);
return memberName.StartsWith("resources.", StringComparison.InvariantCultureIgnoreCase);
}
return false;
}
void WalkExpression(Expression node)
{
if (node is SimpleAssignmentExpression) {
WalkSimpleAssignment((SimpleAssignmentExpression)node);
} else if (node is MethodCall) {
WalkMethodCall((MethodCall)node);
}
}
public static string[] GetMemberNames(Expression expression)
{
if (expression is MethodCall) {
return GetMemberNames((MethodCall)expression);
} else if (expression is InstanceVariable) {
return GetMemberNames((InstanceVariable)expression);
} else if (expression is SelfReference) {
return GetMemberNames((SelfReference)expression);
} else if (expression is LocalVariable) {
return GetMemberNames((LocalVariable)expression);
}
return new string[0];
}
public WhenClause(Expression[] comparisons, Expression comparisonArray, Statements statements, SourceSpan location)
: base(location) {
_comparisons = comparisons;
_comparisonArray = comparisonArray;
_statements = statements;
}
private readonly Statements _statements; // optional
#endregion Fields
#region Constructors
public WhenClause(Expression/*!*/[] comparisons, Statements statements, SourceSpan location)
: base(location)
{
_comparisons = comparisons ?? Expression.EmptyArray;
_statements = statements;
}
public WhenClause(List<Expression> comparisons, Expression comparisonArray, List<Expression> statements, SourceSpan location)
: base(location) {
_comparisons = comparisons;
_comparisonArray = comparisonArray;
_statements = statements;
}
public object Deserialize(Expression expression)
{
return Deserialize(null, expression);
}
