public BinaryOperation(string sOp, Expression x, Expression y)
 {
     operation = sOp;
     opcode = StringToOpCode(sOp);
     operand1 = x;
     operand2 = y;
 }

 protected Packet( OpCode opCode )
 {
     if( !Enum.IsDefined( typeof( OpCode ), OpCode ) ) {
         throw new ArgumentOutOfRangeException( "opCode" );
     }
     OpCode = opCode;
 }

        //wicky.patch.start
        static OpCodes()
        {
            //Start from first index to ignore nop (onebyte)
            for (int i = 1; i < OneByteOpCode.Length; i++)
            {
                //arglist: FE 00
                if (OneByteOpCode[i].Op2 == 0x00 && OneByteOpCode[i].Code != Code.Arglist)
                {
                    OneByteOpCode[i] = new OpCode(
                        0xff << 0 | (byte)i << 8 | (byte)Code.Unused << 16 | (byte)FlowControl.Next << 24,
                        (byte)OpCodeType.Primitive << 0 | (byte)OperandType.InlineNone << 8 | (byte)StackBehaviour.Pop0 << 16 | (byte)StackBehaviour.Push0 << 24);
                }
            }

            //Start from first index to ignore arglist (twobyte)
            for (int i = 1; i < TwoBytesOpCode.Length; i++)
            {
                //arglist: FE 00
                if (TwoBytesOpCode[i].Op2 == 0x00 && TwoBytesOpCode[i].Code != Code.Arglist)
                {
                    TwoBytesOpCode[i] = new OpCode(
                    0xfe << 0 | (byte)i << 8 | (byte)Code.Unused << 16 | (byte)FlowControl.Next << 24,
                    (byte)OpCodeType.Primitive << 0 | (byte)OperandType.InlineNone << 8 | (byte)StackBehaviour.Pop0 << 16 | (byte)StackBehaviour.Push0 << 24);
                }
            }

        }

        public static void AddCodes(NodeBase caller, BlockBase parent, NodeBase target, OpModule codes, string op, Addr32 dest)
        {
            if (target is TypeOf) target = (target as TypeOf).Target;

            var v = target as Variant;
            if (v != null && parent.GetFunction(v.Name) == null)
            {
                var fpname = (target as Variant).Name;
                var fpt = Types.GetType(parent, fpname);
                if (fpt == null || !fpt.Check())
                    throw caller.Abort("undefined type: {0}", fpname);
                codes.AddCodesV(op, dest, codes.GetTypeObject(fpt));
                return;
            }

            var tt = target.Type;
            var tr = tt as TypeReference;
            var tts = tt.Type as TypeStruct;
            if (tr != null && (tr.IsArray || (tts != null && tts.IsClass)))
            {
                target.AddCodesV(codes, "mov", null);
                var label = new OpCode();
                codes.Add(I386.Test(Reg32.EAX, Reg32.EAX));
                codes.Add(I386.Jcc(Cc.Z, label.Address));
                codes.Add(I386.MovRA(Reg32.EAX, Addr32.NewRO(Reg32.EAX, -16)));
                codes.Add(label);
                codes.AddCodes(op, dest);
            }
            else
                codes.AddCodesV(op, dest, codes.GetTypeObject(tt));
        }

 public static void WriteCodes(BinaryWriter bw, OpCode[] ops)
 {
     for (int i = 0; i < ops.Length; i++)
     {
         bw.Write(ops[i].GetCodes());
     }
 }

        public void Emit_UnknownOpCode_ThrowsNotSupportedException()
        {
            var ilGenerator = new ILGenerator(null);
            var opCode = new OpCode(-1);

            ExceptionAssert.Throws<NotSupportedException>(() => ilGenerator.Emit(opCode));
        }

 static bool IsCall(OpCode opCode)
 {
     return opCode == OpCodes.Call ||
            opCode == OpCodes.Callvirt ||
            opCode == OpCodes.Calli ||
            opCode == OpCodes.Ldftn;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="StobjInstruction"/> class.
 /// </summary>
 /// <param name="opcode">The opcode.</param>
 public StobjInstruction(OpCode opcode)
     : base(opcode)
 {
     switch (opcode) {
         case OpCode.Stind_i1:
             _valueType = new SigType(CilElementType.I1);
             break;
         case OpCode.Stind_i2:
             _valueType = new SigType(CilElementType.I2);
             break;
         case OpCode.Stind_i4:
             _valueType = new SigType(CilElementType.I4);
             break;
         case OpCode.Stind_i8:
             _valueType = new SigType(CilElementType.I8);
             break;
         case OpCode.Stind_r4:
             _valueType = new SigType(CilElementType.R4);
             break;
         case OpCode.Stind_r8:
             _valueType = new SigType(CilElementType.R8);
             break;
         case OpCode.Stind_i:
             _valueType = new SigType(CilElementType.I);
             break;
         case OpCode.Stind_ref: // FIXME: Really object?
             _valueType = new SigType(CilElementType.Object);
             break;
         default:
             throw new NotImplementedException();
     }
 }

 public CompiledByte(OpCode op, Value a, Value b)
 {
     ushort[] output = compile(op,a,b);
     for (int i = 0; i < output.Length; i++)
     {
         ;
     }
 }

        static void AssertOpCodeSequence(OpCode [] expected, MethodBody body)
        {
            var opcodes = body.Instructions.Select (i => i.OpCode).ToArray ();
            Assert.AreEqual (expected.Length, opcodes.Length);

            for (int i = 0; i < opcodes.Length; i++)
                Assert.AreEqual (expected [i], opcodes [i]);
        }

        private void AddJumpBack(OpCode jumpOp, string jumpLabel)
        {
            // pop the most recently-added jump with the label
            JumpPatch jump = mJumpBackPatches.Last(j => j.Label == jumpLabel);
            mJumpBackPatches.Remove(jump);

            mBytecode.Write(jumpOp, jump.Location);
        }

 public Instruction(byte[] code, int offset, int length, OpCode oc, TokenResolver resolver)
 {
     this.code = code;
     this.offset = offset;
     this.length = length;
     this.oc = oc;
     this.resolver = resolver;
 }

		public void Add(Token token, OpCode op, string stringValue, params int[] args)
		{
			List<int> nums = new List<int>(args);
			nums.Insert(0, (int)op);
			this.byteCode.Add(nums.ToArray());
			this.tokens.Add(token);
			this.stringArgs.Add(stringValue);
		}

        private void AddJump(OpCode jumpOp, string jumpLabel)
        {
            // add the jump and a blank space for the destination
            mBytecode.Write(jumpOp, 0);

            // patch the destination later
            mJumpPatches.Add(new JumpPatch(jumpLabel, mBytecode.Position - 4));
        }

        public Instruction(OpCode opcode, int index, params Operand[] operands)
        {
            OpCode = opcode;

            Operands = operands;

            Index = index;
        }

 public ScriptElement(OpCode opCode, Byte[] data = null)
 {
     this.opCode = opCode;
     this.data = data;
     if (opCode == OpCode.OP_0)
         this.data = new ScriptVarInt(0).ToBytes();
     else if (opCode == OpCode.OP_1NEGATE || (OpCode.OP_1 <= opCode && opCode <= OpCode.OP_16))
         this.data = new ScriptVarInt((int)opCode - ((int)OpCode.OP_1 - 1)).ToBytes();
 }

        /// <summary>
        ///     Adds a binary operator.
        /// </summary>
        /// <param name="operator">The operator's operation code.</param>
        /// <param name="supportedTypes">The supported types on both sides of the operator.</param>
        /// <param name="func">The logic to perform this operator.</param>
        /// <param name="order">The order the left/right values may appear in.</param>
        /// <exception cref="System.ArgumentNullException">Thrown if <see cref="supportedTypes" /> or <see cref="func" /> is null.</exception>
        public void AddBinaryOperator(OpCode @operator, Type[] supportedTypes,
            Func<EarleValue, EarleValue, EarleValue> func,
            EarleOperatorParamOrder order = EarleOperatorParamOrder.Normal)
        {
            if (supportedTypes == null) throw new ArgumentNullException(nameof(supportedTypes));
            if (func == null) throw new ArgumentNullException(nameof(func));

            AddBinaryOperator(@operator, supportedTypes, supportedTypes, func, order);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LdobjInstruction"/> class.
        /// </summary>
        /// <param name="opcode">The opcode.</param>
        public LdobjInstruction(OpCode opcode)
            : base(opcode, 1)
        {
            switch (opcode)
            {
                case OpCode.Ldind_i1:
                    typeRef = BuiltInSigType.SByte;
                    break;

                case OpCode.Ldind_i2:
                    typeRef = BuiltInSigType.Int16;
                    break;

                case OpCode.Ldind_i4:
                    typeRef = BuiltInSigType.Int32;
                    break;

                case OpCode.Ldind_i8:
                    typeRef = BuiltInSigType.Int64;
                    break;

                case OpCode.Ldind_u1:
                    typeRef = BuiltInSigType.Byte;
                    break;

                case OpCode.Ldind_u2:
                    typeRef = BuiltInSigType.UInt16;
                    break;

                case OpCode.Ldind_u4:
                    typeRef = BuiltInSigType.UInt32;
                    break;

                case OpCode.Ldind_i:
                    typeRef = BuiltInSigType.IntPtr;
                    break;

                case OpCode.Ldind_r4:
                    typeRef = BuiltInSigType.Single;
                    break;

                case OpCode.Ldind_r8:
                    typeRef = BuiltInSigType.Double;
                    break;

                case OpCode.Ldind_ref: // FIXME: Really object?
                    typeRef = BuiltInSigType.Object;
                    break;

                case OpCode.Ldobj: // FIXME
                    typeRef = null; // BuiltInSigType.Object;
                    break;

                default:
                    throw new NotImplementedException();
            }
        }

		internal void Emit(ILGenerator ilgen, OpCode opcode)
		{
			if (local == null)
			{
				// it's a temporary local that is only allocated on-demand
				local = ilgen.DeclareLocal(type);
			}
			ilgen.Emit(opcode, local);
		}

		private BranchSet(OpCode brTrue, OpCode brFalse, OpCode brEq, OpCode brNe, OpCode brLt, OpCode brLtUn, OpCode brGt, OpCode brGtUn, OpCode brLe, OpCode brLeUn, OpCode brGe, OpCode brGeUn)
		{
			BrTrue = brTrue; BrFalse = brFalse;
			BrEq = brEq; BrNe = brNe;
			BrLt = brLt; BrLtUn = brLtUn;
			BrGt = brGt; BrGtUn = brGtUn;
			BrLe = brLe; BrLeUn = brLeUn;
			BrGe = brGe; BrGeUn = brGeUn;
		}