Enter a binary operation, as above but with two opcodes,
which get encoded as
{@code (opcode1 << ByteCodeTags.preShift) + opcode2 }.
@param opcode1     First opcode.
@param opcode2     Second opcode.
424121
private void enterBinop(String name,
                            Type left, Type right, Type res,
                            int opcode1, int opcode2) {
        enterBinop(
            name, left, right, res, (opcode1 << ByteCodes.preShift) | opcode2);
    }
1201435
public Instruction read(int opcode, Input src, int ofs) throws IOException {
        switch (opcode) {
        case WIDE:
            return readWide(src, ofs);
        case TABLESWITCH:
            return readTableSwitch(src, ofs);
        case LOOKUPSWITCH:
            return readLookupSwitch(src, ofs);
        default:
            return readNormal(src, ofs);
        }
    }
177043
static void checkOpcode(final int opcode, final int type) {
        if (opcode < 0 || opcode > 199 || TYPE[opcode] != type) {
            throw new IllegalArgumentException("Invalid opcode: " + opcode);
        }
    }
713392
final void setOperationCode (final ProtocolDataUnit protocolDataUnit, final OperationCode initOperationCode) {

        operationCode = initOperationCode;
        parser = MessageParserFactory.getParser(protocolDataUnit, initOperationCode);
    }
1116834
int encode(int a, Buffer b) {
        b.write(codelist[a], c.lengthlist[a]);
        return (c.lengthlist[a]);
    }
280272
OperatorSymbol resolveBinary(DiagnosticPosition pos, JCTree.Tag tag, Type op1, Type op2) {
        return resolve(tag,
                binaryOperators,
                binop -> binop.test(op1, op2),
                binop -> binop.resolve(op1, op2),
                () -> reportErrorIfNeeded(pos, tag, op1, op2));
    }
1336419
@SuppressWarnings("unchecked")
   public CDB decode(ByteBuffer input) throws IOException
   {
      byte[] opcode = new byte[1];
      input.duplicate().get(opcode); // Read in the operation code without changing the position
      DataInputStream in = new DataInputStream(new ByteArrayInputStream(opcode));

      int operationCode = in.readUnsignedByte();

      if (!_cdbs.containsKey(operationCode))
      {
         throw new IOException(String.format(
               "Could not create new cdb with unsupported operation code: %x", operationCode));
      }

      try
      {
         CDB cdb = _cdbs.get(operationCode).newInstance();
         cdb.decode(null, input);
         return cdb;
      }
      catch (InstantiationException e)
      {
         throw new IOException("Could not create new cdb parser: " + e.getMessage());
      }
      catch (IllegalAccessException e)
      {
         throw new IOException("Could not create new cdb parser: " + e.getMessage());
      }
   }
97277
public void join(SelectableBySelector ch1, SelectableBySelector ch2) throws IOException
    {
        join(ch1.getSelector(), ch2.getSelector(), (ByteChannel)ch1, (ByteChannel)ch2);
    }
264788
@Override
    public void handleInstruction(int opcode, int index) {
        bytecodeSet.set(opcode);
        offsetToOpcodeMap[index] = (short) opcode;
    }
784384
public static final void merge(InputStream in1, InputStream in2, OutputStream out, boolean closeIS1, boolean closeIS2, boolean closeOS) throws IOException {
	try {
	    merge(in1, in2, out, 0xffff);
	}
	finally {
	    if (closeIS1) closeEL(in1);
	    if (closeIS2) closeEL(in2);
	    if (closeOS) closeEL(out);
	}
    }
802322
public static CodeRangeBuffer orCodeRangeBuff(ScanEnvironment env, CodeRangeBuffer bbuf1, boolean not1,
                                                                CodeRangeBuffer bbuf2, boolean not2) {
        CodeRangeBuffer pbuf = null;

        if (bbuf1 == null && bbuf2 == null) {
            if (not1 || not2) {
                return setAllMultiByteRange(env, pbuf);
            }
            return null;
        }

        if (bbuf2 == null) {
            CodeRangeBuffer tbuf;
            boolean tnot;
            // swap
            tnot = not1; not1 = not2; not2 = tnot;
            tbuf = bbuf1; bbuf1 = bbuf2; bbuf2 = tbuf;
        }

        if (bbuf1 == null) {
            if (not1) {
                return setAllMultiByteRange(env, pbuf);
            } else {
                if (!not2) {
                    return bbuf2.clone();
                } else {
                    return notCodeRangeBuff(env, bbuf2);
                }
            }
        }

        if (not1) {
            CodeRangeBuffer tbuf;
            boolean tnot;
            // swap
            tnot = not1; not1 = not2; not2 = tnot;
            tbuf = bbuf1; bbuf1 = bbuf2; bbuf2 = tbuf;
        }

        if (!not2 && !not1) { /* 1 OR 2 */
            pbuf = bbuf2.clone();
        } else if (!not1) { /* 1 OR (not 2) */
            pbuf = notCodeRangeBuff(env, bbuf2);
        }

        int[]p1 = bbuf1.p;
        int n1 = p1[0];

        for (int i=0; i<n1; i++) {
            int from = p1[i * 2 + 1];
            int to = p1[i * 2 + 2];
            pbuf = addCodeRangeToBuff(pbuf, env, from, to);
        }

        return pbuf;
    }
509235
def compare(self, operand1, operand2):
        
        typ = self.symtab.get_type(operand1)
        self.free_if_register(operand1)
        self.free_if_register(operand2)
        self.newline_text("CMP{0}\t{1},{2}".format(self.OPSIGNS[typ], self.symbol(operand1), self.symbol(operand2)), True)
774865
@Pure
	@Inline(value="($1 & $2)", constantExpression=true)
	public static int bitwiseAnd(int a, int b) {
		return a & b;
	}
1266451
final void _emitOpCode(int opCode) {
        // instruction prefix
        if ((opCode & 0xFF000000) != 0) {
            _emitByte((byte) ((opCode & 0xFF000000) >> 24));
        }
        // instruction opcodes
        if ((opCode & 0x00FF0000) != 0) {
            _emitByte((byte) ((opCode & 0x00FF0000) >> 16));
        }
        if ((opCode & 0x0000FF00) != 0) {
            _emitByte((byte) ((opCode & 0x0000FF00) >> 8));
        }
        // last opcode is always emitted (can be also 0x00)
        _emitByte((byte) (opCode & 0x000000FF));
    }
849084
public void encode(AsnOutputStream aos) throws EncodeException {

        if (this.nationalOperationCode == null && this.privateOperationCode == null)
            throw new EncodeException("Operation code: No Operation code set!");

        try {
            if (this.type == OperationCodeType.National && this.nationalOperationCode != null) {
                aos.writeInteger(Tag.CLASS_PRIVATE, OperationCode._TAG_NATIONAL, this.nationalOperationCode);
            } else if (this.type == OperationCodeType.Private && this.privateOperationCode != null) {
                aos.writeInteger(Tag.CLASS_PRIVATE, OperationCode._TAG_PRIVATE, this.privateOperationCode);
            } else {
                throw new EncodeException("Operation code: No Operation code set!");
            }

        } catch (IOException e) {
            throw new EncodeException("IOException while encoding OperationCode: " + e.getMessage(), e);
        } catch (AsnException e) {
            throw new EncodeException("AsnException while encoding OperationCode: " + e.getMessage(), e);
        }
    }
147483
private void writeUShort(int s) {
        byte b1 = (byte)((s >> 8) & 0xff);
        byte b2 = (byte)(s & 0xff);
        writeByte(b1);
        writeByte(b2);
    }
364690
private byte[] concat(final byte[] input1, final byte[] input2, final int position) {
        // Preconition checks
        assert input1 != null : "Input 1 must be specified";
        assert input2 != null : "Input 2 must be specified";
        assert position >= 0 : "Position must be 0 or higher";
        // Allocate a new array of enough space (either current size or position + input2.length, whichever is greater)
        final int newSize = position < input1.length ? input1.length + input2.length : position + input2.length;
        final byte[] merged = new byte[newSize];
        // Copy in the contents of input 1 with 0 offset
        System.arraycopy(input1, 0, merged, 0, input1.length);
        // Copy in the contents of input2 with offset the length of input 1
        System.arraycopy(input2, 0, merged, position, input2.length);
        return merged;
    }