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; }