public EnumMember(LexicalInfo token, IntegerLiteralExpression initializer)
: base(token)
{
this.Initializer = initializer;
}
IntegerLiteralExpression CreateIntegerLiteral(long value)
{
IntegerLiteralExpression expression = new IntegerLiteralExpression(value);
Visit(expression);
return expression;
}
void AssertLiteralInRange(IntegerLiteralExpression literal, IType type)
{
bool ok = true;
if (type == TypeSystemServices.ByteType)
ok = (literal.Value >= byte.MinValue && literal.Value <= byte.MaxValue);
else if (type == TypeSystemServices.SByteType)
ok = (literal.Value >= sbyte.MinValue && literal.Value <= sbyte.MaxValue);
else if (type == TypeSystemServices.ShortType)
ok = (literal.Value >= short.MinValue && literal.Value <= short.MaxValue);
else if (type == TypeSystemServices.UShortType)
ok = (literal.Value >= ushort.MinValue && literal.Value <= ushort.MaxValue);
else if (type == TypeSystemServices.IntType)
ok = (literal.Value >= int.MinValue && literal.Value <= int.MaxValue);
else if (type == TypeSystemServices.UIntType)
ok = (literal.Value >= uint.MinValue && literal.Value <= uint.MaxValue);
else if (type == TypeSystemServices.LongType)
ok = (literal.Value >= long.MinValue && literal.Value <= long.MaxValue);
if (!ok)
Error(CompilerErrorFactory.ConstantCannotBeConverted(literal, type));
}
public EnumMember(IntegerLiteralExpression initializer)
{
this.Initializer = initializer;
}
public ArrayTypeReference(LexicalInfo lexicalInfo, TypeReference elementType, IntegerLiteralExpression rank) : base(lexicalInfo)
{
this.ElementType = elementType;
this.Rank = rank;
}
public override void OnIntegerLiteralExpression(IntegerLiteralExpression node)
{
if (node.IsLong)
MakeLiteralResult("System.Int64");
else
MakeResult(projectContent.SystemTypes.Int32);
}
public override bool Replace(Node existing, Node newNode)
{
if (base.Replace(existing, newNode))
{
return true;
}
if (_elementType == existing)
{
this.ElementType = (TypeReference)newNode;
return true;
}
if (_rank == existing)
{
this.Rank = (IntegerLiteralExpression)newNode;
return true;
}
return false;
}
override public object Clone()
{
IntegerLiteralExpression clone = new IntegerLiteralExpression();
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._isSynthetic = _isSynthetic;
clone._entity = _entity;
if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
clone._expressionType = _expressionType;
clone._value = _value;
clone._isLong = _isLong;
return clone;
}
public override void OnIntegerLiteralExpression(IntegerLiteralExpression node)
{
if (node.IsLong)
{
_il.Emit(OpCodes.Ldc_I8, node.Value);
PushType(TypeSystemServices.LongType);
}
else
{
switch (node.Value)
{
case -1L: _il.Emit(OpCodes.Ldc_I4_M1); break;
case 0L: _il.Emit(OpCodes.Ldc_I4_0); break;
case 1L: _il.Emit(OpCodes.Ldc_I4_1); break;
case 2L: _il.Emit(OpCodes.Ldc_I4_2); break;
case 3L: _il.Emit(OpCodes.Ldc_I4_3); break;
case 4L: _il.Emit(OpCodes.Ldc_I4_4); break;
case 5L: _il.Emit(OpCodes.Ldc_I4_5); break;
case 6L: _il.Emit(OpCodes.Ldc_I4_6); break;
case 7L: _il.Emit(OpCodes.Ldc_I4_7); break;
case 8L: _il.Emit(OpCodes.Ldc_I4_8); break;
default:
{
_il.Emit(OpCodes.Ldc_I4, (int)node.Value);
break;
}
}
PushType(TypeSystemServices.IntType);
}
}
public override void OnIntegerLiteralExpression(IntegerLiteralExpression node)
{
ReplaceWithCallToExpressionConstant(node);
}
public override void OnIntegerLiteralExpression(IntegerLiteralExpression node)
{
if (node.IsLong || node.Value < int.MinValue || node.Value > int.MaxValue)
_expression = new CodePrimitiveExpression(node.Value);
else
_expression = new CodePrimitiveExpression((int)node.Value);
}
void ExpandComplexArraySlicing(SlicingExpression node)
{
if (node.Indices.Count > 1)
{
MethodInvocationExpression mie = null;
var computeEnd = new ArrayLiteralExpression();
var collapse = new ArrayLiteralExpression();
var ranges = new ArrayLiteralExpression();
for (int i = 0; i < node.Indices.Count; i++)
{
ranges.Items.Add(node.Indices[i].Begin);
if (node.Indices[i].End == null )
{
var end = new BinaryExpression(BinaryOperatorType.Addition, node.Indices[i].Begin, new IntegerLiteralExpression(1));
ranges.Items.Add(end);
BindExpressionType(end, GetExpressionType(node.Indices[i].Begin));
computeEnd.Items.Add(new BoolLiteralExpression(false));
collapse.Items.Add(new BoolLiteralExpression(true));
}
else if (node.Indices[i].End == OmittedExpression.Default)
{
var end = new IntegerLiteralExpression(0);
ranges.Items.Add(end);
BindExpressionType(end, GetExpressionType(node.Indices[i].Begin));
computeEnd.Items.Add(new BoolLiteralExpression(true));
collapse.Items.Add(new BoolLiteralExpression(false));
}
else
{
ranges.Items.Add(node.Indices[i].End);
computeEnd.Items.Add(new BoolLiteralExpression(false));
collapse.Items.Add(new BoolLiteralExpression(false));
}
}
mie = CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetMultiDimensionalRange1, node.Target, ranges);
mie.Arguments.Add(computeEnd);
mie.Arguments.Add(collapse);
BindExpressionType(ranges, TypeSystemServices.Map(typeof(int[])));
BindExpressionType(computeEnd, TypeSystemServices.Map(typeof(bool[])));
BindExpressionType(collapse, TypeSystemServices.Map(typeof(bool[])));
node.ParentNode.Replace(node, mie);
}
else
{
var slice = node.Indices[0];
var mie = IsNullOrOmitted(slice.End)
? CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange1, node.Target, slice.Begin)
: CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange2, node.Target, slice.Begin, slice.End);
node.ParentNode.Replace(node, mie);
}
}
public override void OnIntegerLiteralExpression(IntegerLiteralExpression e)
{
Write(e.Value.ToString());
if (e.IsLong)
{
Write("L");
}
}
public override void OnIntegerLiteralExpression(IntegerLiteralExpression node)
{
IType type = node.ExpressionType ?? TypeSystemServices.IntType;
EmitLoadLiteral(type, node.Value);
PushType(type);
}
public ArrayTypeReference(TypeReference elementType, IntegerLiteralExpression rank) : this(LexicalInfo.Empty, elementType, rank)
{
}
public override void OnIntegerLiteralExpression(IntegerLiteralExpression node)
{
BindExpressionType(node, node.IsLong ? TypeSystemServices.LongType : TypeSystemServices.IntType);
}
public IntegerLiteralExpression CreateIntegerLiteral(long value)
{
IntegerLiteralExpression integer = new IntegerLiteralExpression(value);
integer.ExpressionType = _tss.LongType;
return integer;
}
