//
// Returns a stringified representation of the Operator
//
public static string OperName (Operator oper)
{
switch (oper) {
case Operator.UnaryPlus:
return "+";
case Operator.UnaryNegation:
return "-";
case Operator.LogicalNot:
return "!";
case Operator.OnesComplement:
return "~";
case Operator.AddressOf:
return "&";
}
throw new NotImplementedException (oper.ToString ());
}
public static void EmitOperatorOpcode (EmitContext ec, Operator oper, Type l)
{
OpCode opcode;
ILGenerator ig = ec.ig;
switch (oper){
case Operator.Multiply:
if (ec.HasSet (EmitContext.Options.CheckedScope)) {
if (l == TypeManager.int32_type || l == TypeManager.int64_type)
opcode = OpCodes.Mul_Ovf;
else if (!IsFloat (l))
opcode = OpCodes.Mul_Ovf_Un;
else
opcode = OpCodes.Mul;
} else
opcode = OpCodes.Mul;
break;
case Operator.Division:
if (IsUnsigned (l))
opcode = OpCodes.Div_Un;
else
opcode = OpCodes.Div;
break;
case Operator.Modulus:
if (IsUnsigned (l))
opcode = OpCodes.Rem_Un;
else
opcode = OpCodes.Rem;
break;
case Operator.Addition:
if (ec.HasSet (EmitContext.Options.CheckedScope)) {
if (l == TypeManager.int32_type || l == TypeManager.int64_type)
opcode = OpCodes.Add_Ovf;
else if (!IsFloat (l))
opcode = OpCodes.Add_Ovf_Un;
else
opcode = OpCodes.Add;
} else
opcode = OpCodes.Add;
break;
case Operator.Subtraction:
if (ec.HasSet (EmitContext.Options.CheckedScope)) {
if (l == TypeManager.int32_type || l == TypeManager.int64_type)
opcode = OpCodes.Sub_Ovf;
else if (!IsFloat (l))
opcode = OpCodes.Sub_Ovf_Un;
else
opcode = OpCodes.Sub;
} else
opcode = OpCodes.Sub;
break;
case Operator.RightShift:
if (IsUnsigned (l))
opcode = OpCodes.Shr_Un;
else
opcode = OpCodes.Shr;
break;
case Operator.LeftShift:
opcode = OpCodes.Shl;
break;
case Operator.Equality:
opcode = OpCodes.Ceq;
break;
case Operator.Inequality:
ig.Emit (OpCodes.Ceq);
ig.Emit (OpCodes.Ldc_I4_0);
opcode = OpCodes.Ceq;
break;
case Operator.LessThan:
if (IsUnsigned (l))
opcode = OpCodes.Clt_Un;
else
opcode = OpCodes.Clt;
break;
case Operator.GreaterThan:
if (IsUnsigned (l))
opcode = OpCodes.Cgt_Un;
else
opcode = OpCodes.Cgt;
break;
case Operator.LessThanOrEqual:
if (IsUnsigned (l) || IsFloat (l))
ig.Emit (OpCodes.Cgt_Un);
else
ig.Emit (OpCodes.Cgt);
ig.Emit (OpCodes.Ldc_I4_0);
opcode = OpCodes.Ceq;
break;
case Operator.GreaterThanOrEqual:
if (IsUnsigned (l) || IsFloat (l))
ig.Emit (OpCodes.Clt_Un);
else
ig.Emit (OpCodes.Clt);
ig.Emit (OpCodes.Ldc_I4_0);
opcode = OpCodes.Ceq;
break;
case Operator.BitwiseOr:
opcode = OpCodes.Or;
break;
case Operator.BitwiseAnd:
opcode = OpCodes.And;
break;
case Operator.ExclusiveOr:
opcode = OpCodes.Xor;
break;
default:
throw new InternalErrorException (oper.ToString ());
}
ig.Emit (opcode);
}
static string GetOperatorMetadataName (Operator op)
{
CSharp.Operator.OpType op_type;
switch (op) {
case Operator.Addition:
op_type = CSharp.Operator.OpType.Addition; break;
case Operator.BitwiseAnd:
op_type = CSharp.Operator.OpType.BitwiseAnd; break;
case Operator.BitwiseOr:
op_type = CSharp.Operator.OpType.BitwiseOr; break;
case Operator.Division:
op_type = CSharp.Operator.OpType.Division; break;
case Operator.Equality:
op_type = CSharp.Operator.OpType.Equality; break;
case Operator.ExclusiveOr:
op_type = CSharp.Operator.OpType.ExclusiveOr; break;
case Operator.GreaterThan:
op_type = CSharp.Operator.OpType.GreaterThan; break;
case Operator.GreaterThanOrEqual:
op_type = CSharp.Operator.OpType.GreaterThanOrEqual; break;
case Operator.Inequality:
op_type = CSharp.Operator.OpType.Inequality; break;
case Operator.LeftShift:
op_type = CSharp.Operator.OpType.LeftShift; break;
case Operator.LessThan:
op_type = CSharp.Operator.OpType.LessThan; break;
case Operator.LessThanOrEqual:
op_type = CSharp.Operator.OpType.LessThanOrEqual; break;
case Operator.Modulus:
op_type = CSharp.Operator.OpType.Modulus; break;
case Operator.Multiply:
op_type = CSharp.Operator.OpType.Multiply; break;
case Operator.RightShift:
op_type = CSharp.Operator.OpType.RightShift; break;
case Operator.Subtraction:
op_type = CSharp.Operator.OpType.Subtraction; break;
default:
throw new InternalErrorException (op.ToString ());
}
return CSharp.Operator.GetMetadataName (op_type);
}
/// <summary>
/// Returns a stringified representation of the Operator
/// </summary>
string OperName (Operator oper)
{
string s;
switch (oper){
case Operator.Multiply:
s = "*";
break;
case Operator.Division:
s = "/";
break;
case Operator.Modulus:
s = "%";
break;
case Operator.Addition:
s = "+";
break;
case Operator.Subtraction:
s = "-";
break;
case Operator.LeftShift:
s = "<<";
break;
case Operator.RightShift:
s = ">>";
break;
case Operator.LessThan:
s = "<";
break;
case Operator.GreaterThan:
s = ">";
break;
case Operator.LessThanOrEqual:
s = "<=";
break;
case Operator.GreaterThanOrEqual:
s = ">=";
break;
case Operator.Equality:
s = "==";
break;
case Operator.Inequality:
s = "!=";
break;
case Operator.BitwiseAnd:
s = "&";
break;
case Operator.BitwiseOr:
s = "|";
break;
case Operator.ExclusiveOr:
s = "^";
break;
case Operator.LogicalOr:
s = "||";
break;
case Operator.LogicalAnd:
s = "&&";
break;
default:
s = oper.ToString ();
break;
}
if (is_compound)
return s + "=";
return s;
}
/// <summary>
/// Returns a stringified representation of the Operator
/// </summary>
static string OperName (Operator oper)
{
switch (oper){
case Operator.Multiply:
return "*";
case Operator.Division:
return "/";
case Operator.Modulus:
return "%";
case Operator.Addition:
return "+";
case Operator.Subtraction:
return "-";
case Operator.LeftShift:
return "<<";
case Operator.RightShift:
return ">>";
case Operator.LessThan:
return "<";
case Operator.GreaterThan:
return ">";
case Operator.LessThanOrEqual:
return "<=";
case Operator.GreaterThanOrEqual:
return ">=";
case Operator.Equality:
return "==";
case Operator.Inequality:
return "!=";
case Operator.BitwiseAnd:
return "&";
case Operator.BitwiseOr:
return "|";
case Operator.ExclusiveOr:
return "^";
case Operator.LogicalOr:
return "||";
case Operator.LogicalAnd:
return "&&";
}
return oper.ToString ();
}
/// <summary>
/// Returns a stringified representation of the Operator
/// </summary>
static public string OperName (Operator oper)
{
switch (oper){
case Operator.UnaryPlus:
return "+";
case Operator.UnaryNegation:
return "-";
case Operator.LogicalNot:
return "!";
case Operator.OnesComplement:
return "~";
case Operator.AddressOf:
return "&";
case Operator.Indirection:
return "*";
}
return oper.ToString ();
}
