| private IsLongOnly ( TypeRefMask tmask ) : bool | ||
| tmask | TypeRefMask | |
| return | bool | |
internal static TypeSymbol EmitBitOr(CodeGenerator cg, BoundExpression left, BoundExpression right)
{
// most common cases:
if (cg.IsLongOnly(left.TypeRefMask) || cg.IsLongOnly(right.TypeRefMask))
{
// i64 | i64 : i64
cg.EmitConvert(left, cg.CoreTypes.Long);
cg.EmitConvert(right, cg.CoreTypes.Long);
cg.Builder.EmitOpCode(ILOpCode.Or);
return cg.CoreTypes.Long;
}
//
return EmitBitOr(cg, cg.Emit(left), right);
}
internal override TypeSymbol Emit(CodeGenerator cg)
{
Debug.Assert(this.Access.IsRead || this.Access.IsNone);
//
TypeSymbol returned_type;
if (UsesOperatorMethod)
{
throw new NotImplementedException(); // call this.Operator(Left, Right)
}
switch (this.Operation)
{
#region Arithmetic Operations
case Operations.Add:
returned_type = (cg.IsLongOnly(this.TypeRefMask)) ? cg.CoreTypes.Long.Symbol : this.Access.TargetType;
returned_type = EmitAdd(cg, Left, Right, returned_type);
break;
case Operations.Sub:
//Template: "x - y" Operators.Subtract(x,y) [overloads]
returned_type = EmitSub(cg, Left, Right, this.Access.TargetType);
break;
case Operations.Div:
//Template: "x / y"
returned_type = EmitDivision(cg);
break;
case Operations.Mul:
//Template: "x * y"
returned_type = EmitMultiply(cg);
break;
case Operations.Pow:
//Template: "x ** y"
returned_type = EmitPow(cg);
break;
case Operations.Mod:
//Template: "x % y" Operators.Remainder(x,y)
//codeGenerator.EmitBoxing(node.LeftExpr.Emit(codeGenerator));
//ro_typecode = node.RightExpr.Emit(codeGenerator);
//switch (ro_typecode)
//{
// case PhpTypeCode.Integer:
// returned_typecode = codeGenerator.EmitMethodCall(Methods.Operators.Remainder.Object_Int32);
// break;
// default:
// codeGenerator.EmitBoxing(ro_typecode);
// returned_typecode = codeGenerator.EmitMethodCall(Methods.Operators.Remainder.Object_Object);
// break;
//}
//break;
throw new NotImplementedException();
case Operations.ShiftLeft:
//// LOAD Operators.ShiftLeft(box left, box right);
//codeGenerator.EmitBoxing(node.LeftExpr.Emit(codeGenerator));
//codeGenerator.EmitBoxing(node.RightExpr.Emit(codeGenerator));
//returned_typecode = codeGenerator.EmitMethodCall(Methods.Operators.ShiftLeft);
//break;
throw new NotImplementedException();
case Operations.ShiftRight:
//// LOAD Operators.ShiftRight(box left, box right);
//codeGenerator.EmitBoxing(node.LeftExpr.Emit(codeGenerator));
//codeGenerator.EmitBoxing(node.RightExpr.Emit(codeGenerator));
//returned_typecode = codeGenerator.EmitMethodCall(Methods.Operators.ShiftRight);
//break;
throw new NotImplementedException();
#endregion
#region Boolean and Bitwise Operations
case Operations.And:
returned_type = EmitBinaryBooleanOperation(cg, true);
break;
case Operations.Or:
returned_type = EmitBinaryBooleanOperation(cg, false);
break;
case Operations.Xor:
returned_type = EmitBinaryXor(cg);
break;
case Operations.BitAnd:
returned_type = EmitBitAnd(cg, Left, Right);
break;
case Operations.BitOr:
returned_type = EmitBitOr(cg, Left, Right);
break;
case Operations.BitXor:
//returned_typecode = EmitBitOperation(node, codeGenerator, Operators.BitOp.Xor);
//break;
throw new NotImplementedException();
#endregion
#region Comparing Operations
case Operations.Equal:
returned_type = EmitEquality(cg);
break;
case Operations.NotEqual:
EmitEquality(cg);
cg.EmitLogicNegation();
returned_type = cg.CoreTypes.Boolean;
break;
case Operations.GreaterThan:
returned_type = EmitLtGt(cg, false);
break;
case Operations.LessThan:
returned_type = EmitLtGt(cg, true);
break;
case Operations.GreaterThanOrEqual:
// template: !(LessThan)
returned_type = EmitLtGt(cg, true);
cg.EmitLogicNegation();
break;
case Operations.LessThanOrEqual:
// template: !(GreaterThan)
returned_type = EmitLtGt(cg, false);
cg.EmitLogicNegation();
break;
case Operations.Identical:
// Left === Right
returned_type = EmitStrictEquality(cg);
break;
case Operations.NotIdentical:
// ! (Left === Right)
returned_type = EmitStrictEquality(cg);
cg.EmitLogicNegation();
break;
#endregion
default:
throw ExceptionUtilities.Unreachable;
}
//
switch (Access.Flags)
{
case AccessMask.Read:
// Result is read, do nothing.
Debug.Assert(returned_type.SpecialType != SpecialType.System_Void);
break;
case AccessMask.None:
// Result is not read, pop the result
cg.EmitPop(returned_type);
returned_type = cg.CoreTypes.Void;
break;
}
//
return returned_type;
}