Creation of a processing instruction element.
182365
def newDocPI(self, name, content):
        
        ret = libxml2mod.xmlNewDocPI(self._o, name, content)
        if ret is None:raise treeError('xmlNewDocPI() failed')
        __tmp = xmlNode(_obj=ret)
        return __tmp
1149686
public void processingInstruction(String target, String data)
        throws SAXException
    {
        if (m_firstTagNotEmitted)
        {
            flush();
        }

        m_handler.processingInstruction(target, data);
    }
48287
private void processStartTag(final StartElement paramElem) throws IOException, XMLStreamException,
        TTException {
        assert paramElem != null;

        // Initialize variables.
        initializeVars();

        // Main algorithm to determine if same, insert or a delete has to be
        // made.
        algorithm(paramElem);

        if (mFound && mIsRightSibling) {
            mDelete = EDelete.ATSTARTMIDDLE;
            deleteNode();
        } else if (!mFound) {
            // Increment levels.
            mLevelInToShredder++;

            insertElementNode(paramElem);
        } else if (mFound) {
            // Increment levels.
            mLevelInToShredder++;

            sameElementNode();
        }
    }
1032869
private void processElement(final DeclarationScopeResolver resolver,
                                final Stack<RuleConditionElement> contextStack,
                                final RuleConditionElement element) {
        if ( element instanceof Pattern ) {
            Pattern pattern = (Pattern) element;
            for ( RuleConditionElement ruleConditionElement : pattern.getNestedElements() ) {
                processElement( resolver,
                                contextStack,
                                ruleConditionElement );
            }
            for (Constraint constraint : pattern.getConstraints()) {
                if (constraint instanceof Declaration) {
                    continue;
                }
                replaceDeclarations( resolver, pattern, constraint );
            }

        } else if ( element instanceof EvalCondition ) {
            processEvalCondition(resolver, (EvalCondition) element);

        } else if ( element instanceof Accumulate ) {
            for ( RuleConditionElement rce : element.getNestedElements() ) {
                processElement( resolver, contextStack, rce );
            }
            Accumulate accumulate = (Accumulate)element;
            replaceDeclarations( resolver, accumulate );

        } else if ( element instanceof From ) {
            DataProvider provider = ((From) element).getDataProvider();
            Declaration[] decl = provider.getRequiredDeclarations();
            for (Declaration aDecl : decl) {
                Declaration resolved = resolver.getDeclaration(aDecl.getIdentifier());
                if (resolved != null && resolved != aDecl) {
                    provider.replaceDeclaration(aDecl, resolved);
                } else if (resolved == null) {
                    // it is probably an implicit declaration, so find the corresponding pattern
                    Pattern old = aDecl.getPattern();
                    Pattern current = resolver.findPatternByIndex(old.getIndex());
                    if (current != null && old != current) {
                        resolved = new Declaration(aDecl.getIdentifier(), aDecl.getExtractor(), current);
                        provider.replaceDeclaration(aDecl, resolved);
                    }
                }
            }

        } else if ( element instanceof QueryElement ) {
            QueryElement qe = ( QueryElement ) element;
            Pattern pattern = qe.getResultPattern();

            for ( Entry<String, Declaration> entry : pattern.getInnerDeclarations().entrySet() ) {
                Declaration resolved = resolver.getDeclaration( entry.getValue().getIdentifier() );
                if ( resolved != null && resolved != entry.getValue() && resolved.getPattern() != pattern ) {
                    entry.setValue( resolved );
                }
            }

            List<Integer> varIndexes = asList( qe.getVariableIndexes() );
            for (int i = 0; i < qe.getArguments().length; i++) {
                if (!(qe.getArguments()[i] instanceof QueryArgument.Declr)) {
                    continue;
                }
                Declaration declr = ((QueryArgument.Declr) qe.getArguments()[i]).getDeclaration();
                Declaration resolved = resolver.getDeclaration( declr.getIdentifier() );
                if ( resolved != declr && resolved.getPattern() != pattern ) {
                    qe.getArguments()[i] = new QueryArgument.Declr(resolved);
                }

                if( ClassObjectType.DroolsQuery_ObjectType.isAssignableFrom( resolved.getPattern().getObjectType() ) ) {
                    // if the resolved still points to DroolsQuery, we know this is the first unification pattern, so redeclare it as the visible Declaration
                    declr = pattern.addDeclaration( declr.getIdentifier() );

                    // this bit is different, notice its the ArrayElementReader that we wire up to, not the declaration.
                    ArrayElementReader reader = new ArrayElementReader( new SelfReferenceClassFieldReader(Object[].class),
                                                                        i,
                                                                        resolved.getDeclarationClass() );
                    declr.setReadAccessor( reader );

                    varIndexes.add( i );
                }
            }
            qe.setVariableIndexes( toIntArray( varIndexes ) );

        }  else if ( element instanceof ConditionalBranch ) {
            processBranch( resolver, (ConditionalBranch) element );

        } else {
            contextStack.push( element );
            for (RuleConditionElement ruleConditionElement : element.getNestedElements()) {
                processElement(resolver,
                        contextStack,
                        ruleConditionElement);
            }
            contextStack.pop();
        }
    }
232120
@Override
    public void handleProcessingInstruction(
            final char[] buffer,
            final int targetOffset, final int targetLen, final int targetLine, final int targetCol,
            final int contentOffset, final int contentLen, final int contentLine, final int contentCol,
            final int outerOffset, final int outerLen, final int line, final int col)
            throws ParseException {

        this.someSelectorsMatch = false;
        for (int i = 0; i < this.selectorsLen; i++) {

            this.selectorMatches[i] =
                    this.selectorFilters[i].matchProcessingInstruction(false, this.markupLevel, this.markupBlocks[this.markupLevel]);
            if (this.selectorMatches[i]) {
                this.someSelectorsMatch = true;
            }

        }

        if (this.someSelectorsMatch) {
            markCurrentSelection();
            this.selectedHandler.handleProcessingInstruction(
                    buffer,
                    targetOffset, targetLen, targetLine, targetCol,
                    contentOffset, contentLen, contentLine, contentCol,
                    outerOffset, outerLen, line, col);
            unmarkCurrentSelection();
            return;
        }

        unmarkCurrentSelection();
        this.nonSelectedHandler.handleProcessingInstruction(
                buffer,
                targetOffset, targetLen, targetLine, targetCol,
                contentOffset, contentLen, contentLine, contentCol,
                outerOffset, outerLen, line, col);

    }
1275251
function parseElementBlock(stream, state) {
        if(stream.eat("<")) {
            if(stream.match("?")) {
                pushContext(state, TAG_INSTRUCTION);
                state.tokenize = parseProcessingInstructionStartTag;
                return STYLE_INSTRUCTION;
            } else if(stream.match("!--")) {
                // new context: comment
                pushContext(state, TAG_COMMENT);
                return chain(stream, state, inBlock(STYLE_COMMENT, "-->",
                    state.context == null ? parseDocument : parseElementBlock));
            } else if(stream.match("![CDATA[")) {
                // new context: CDATA section
                pushContext(state, TAG_CDATA);
                return chain(stream, state, inBlock(STYLE_TEXT, "]]>",
                    state.context == null ? parseDocument : parseElementBlock));
            } else if(stream.eatSpace() || stream.eol() ) {
                stream.skipToEnd();
                return STYLE_ERROR;
            } else {
                // element
                state.tokenize = parseElementTagName;
                return STYLE_ELEMENT_NAME;
            }
        } else if(stream.eat("&")) {
            stream.eatWhile(/[^;]/);
            stream.eat(";");
            return STYLE_ENTITIES;
        } else {
            // new context: text
            pushContext(state, TAG_TEXT);
            state.tokenize = parseText;
            return null;
        }
        
        state.tokenize = state.context == null ? parseDocument : parseElementBlock;
        stream.skipToEnd();
        return null;
    }
757010
function addCoreInstructions() {
  this._validateInstruction = this.ajv.compile(require('jsonscript/schema/instruction.json'));
  coreInstructions.forEach(function (inst) {
    this.addInstruction(inst, instructionKeywords[inst.evaluate.validatorKeyword], false);
  }, this);
}
1050038
def asm(self, ftype, asm, constraint, args, side_effect, name=''):
        
        asm = instructions.InlineAsm(ftype, asm, constraint, side_effect)
        return self.call(asm, args, name)
189794
def parse_instruction(string, location, tokens):
    
    prefix_str = tokens.get("prefix", None)
    mnemonic_str = tokens.get("mnemonic")
    operands = [op for op in tokens.get("operands", [])]

    infer_operands_size(operands)

    # Quick hack: Capstone returns rep instead of repe for cmps and scas
    # instructions.
    if prefix_str == "rep" and (mnemonic_str.startswith("cmps") or mnemonic_str.startswith("scas")):
        prefix_str = "repe"

    instr = X86Instruction(
        prefix_str,
        mnemonic_str,
        operands,
        arch_info.architecture_mode
    )

    return instr
1341735
def insert_element(self, vector, value, idx, name=''):
        
        instr = instructions.InsertElement(self.block, vector, value, idx,
                                           name=name)
        self._insert(instr)
        return instr
1275729
private static InstructionHandle getDeepFirstInstruction(CFG cfg, BasicBlock bb) {
        InstructionHandle ih = bb.getFirstInstruction();
        if (ih != null) {
            return ih;
        }
        Iterator<Edge> iei = cfg.outgoingEdgeIterator(bb);
        while (iei.hasNext()) {
            Edge e = iei.next();
            if (EdgeTypes.FALL_THROUGH_EDGE == e.getType()) {
                return getDeepFirstInstruction(cfg, e.getTarget());
            }
        }
        return null;
    }
1316568
def _extract_programming_immediate_instructions_text(self, element_id):
        
        dom = get_page(self._session, OPENCOURSE_PROGRAMMING_IMMEDIATE_INSTRUCTIOINS_URL,
                       json=True,
                       course_id=self._course_id,
                       element_id=element_id)

        return [element['assignmentInstructions']['definition']['value']
                for element in dom['elements']]
1075744
private void processElement(Element element) {
    context.setCurrentSegment(element);
    currentProp = null;
    currentAttribute = null;

    // Process attributes
    boolean shouldPopContext = processElementAttributes(element);

    // Process text segments
    StreamSupport
        .stream(((Iterable<Segment>) element::getNodeIterator).spliterator(), false)
        .filter(segment -> !(segment instanceof Tag)
            && !(segment instanceof CharacterReference))
        .filter(segment -> {
          for (Element child : element.getChildElements()) {
            if (child.encloses(segment)) {
              return false;
            }
          }
          return true;
        })
        .forEach(this::processTextNode);

    // Recurse downwards
    element.getChildElements().
        forEach(this::processElement);

    // After downward recursion, pop the context layer if necessary
    if (shouldPopContext) {
      context.popContextLayer();
    }
  }
956264
function () {
                    var elements = [], e, c, args, delim, arg, index = i, s = input.charAt(i), important = false;

                    if (s !== '.' && s !== '#') { return }

                    save(); // stop us absorbing part of an invalid selector

                    while (e = $(/^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/)) {
                        elements.push(new(tree.Element)(c, e, i));
                        c = $('>');
                    }
                    if ($('(')) {
                        args = this.mixin.args.call(this, true).args;
                        expect(')');
                    }

                    args = args || [];

                    if ($(this.important)) {
                        important = true;
                    }

                    if (elements.length > 0 && ($(';') || peek('}'))) {
                        return new(tree.mixin.Call)(elements, args, index, env.currentFileInfo, important);
                    }

                    restore();
                }
668732
def _add_instruction(self, instruction, value):
        
        if (instruction == 'LABEL' or instruction == 'ENV') and len(value) == 2:
            new_line = instruction + ' ' + '='.join(map(quote, value)) + '\n'
        else:
            new_line = '{0} {1}\n'.format(instruction, value)
        if new_line:
            lines = self.lines
            if not lines[len(lines) - 1].endswith('\n'):
                new_line = '\n' + new_line
            lines += new_line
            self.lines = lines
1075060
def step(self):
        """"""
        op = self.code[self.instruction_pointer]
        self.instruction_pointer += 1
        op(self)
1088674
private void simulateSizeChange(final SizeChangingInstruction instruction) {
        IntStream.range(0, instruction.getNumberOfPops()).forEach(i -> runtimeStack.pop());
        IntStream.range(0, instruction.getNumberOfPushes()).forEach(i -> runtimeStack.push(new Element()));
    }