call op from page 2 or 3
170080
def instruction_PAGE(self, opcode):
        
        op_address, opcode2 = self.read_pc_byte()
        paged_opcode = opcode * 256 + opcode2
#        log.debug("$%x *** call paged opcode $%x" % (
#            self.program_counter, paged_opcode
#        ))
        self.call_instruction_func(op_address - 1, paged_opcode)
939763
function tiCalls( content, tmpl, data, options ) {
		if ( !content ) {
			return stack.pop();
		}
		stack.push({ _: content, tmpl: tmpl, item:this, data: data, options: options });
	}
383716
function runCall(name, call, input) {
    return web.post(connectorsUrl + '/' + name + '/' + call, input);
}
1102316
def _call(self, x, out):
        """"""
        with writable_array(out) as out_arr:
            resize_array(x.asarray(), self.range.shape, offset=self.offset,
                         pad_mode=self.pad_mode, pad_const=self.pad_const,
                         direction='forward', out=out_arr)
92791
def _handle_call(self, ufunc, input_args, outputs):
        '''
        
        '''
        # if output is not None, choose the first one - since we don't support any ops with
        # multiple outputs.
        if outputs: output = outputs[0]
        else: output = None

        # check for supported ops.
        if ufunc.__name__ in UNARY_OPS:
            assert(len(input_args) == 1)
            return self._unary_op(UNARY_OPS[ufunc.__name__], result=output)

        if ufunc.__name__ in BINARY_OPS:
            # weldarray can be first or second arg.
            if isinstance(input_args[0], weldarray):
                # first arg is weldarray, must be self
                assert input_args[0].name == self.name
                other_arg = input_args[1]
            else:
                other_arg = input_args[0]
                assert input_args[1].name == self.name

            return self._binary_op(other_arg, BINARY_OPS[ufunc.__name__], result=output)
154413
def call_me(iocb):
    
    if _debug: call_me._debug("callback_function %r", iocb)

    # it will be successful or have an error
    print("call me, %r or %r" % (iocb.ioResponse, iocb.ioError))
1206178
def _getPageObjNumber(self, pno):
        """"""
        if self.isClosed:
            raise ValueError("operation illegal for closed doc")

        return _fitz.Document__getPageObjNumber(self, pno)
727743
def call_or_yield(object)
      caller_method = caller_locations(1,1)[0].label
      if object.respond_to?(caller_method)
        object.public_send(caller_method)
      else
        yield
      end
    end
814128
def op(cls,text,*args,**kwargs):
        
        return cls.fn(text,*args,**kwargs)
835067
private Ref divMultiOp() throws PageException {
	Ref ref = expoOp();

	while (!cfml.isLast()) {
	    // Multiply Operation
	    if (cfml.forwardIfCurrent('*')) {
		ref = _multi(ref);
	    }
	    // Divide Operation
	    else if (cfml.isCurrent('/') && (!cfml.isCurrent("/>"))) {
		cfml.next();
		ref = _div(ref);
	    }
	    // Divide Operation
	    else if (cfml.isCurrent('\\')) {
		cfml.next();
		ref = _intdiv(ref);
	    }
	    else {
		break;
	    }
	}
	return ref;
    }
1197997
function callee(method, href, params, opt, cb, userData){
		cb = cb || ((err)=>{
			if (err) console.error(method, href, params, opt, userData, err)
		})
		if (!href) return cb('url not defined')
		opt=opt||{}

		const urlobj = url.parse(href)
		let protocol

		switch(urlobj.protocol){
		case 'http:': protocol=http; break
		case 'https:': protocol=https; break
		default:
			if (opt.socketPath){
				protocol=http
				urlobj.protocol = 'http:'
				urlobj.socketPath = opt.socketPath
				break
			}
			fs.readFile(href, 'utf8', (err, data)=>{
				cb(err, 4, data, userData)
			}); return
		}

		const isGet = 'GET' === (urlobj.method = method.toUpperCase())
		let body = Array.isArray(params) ? pObj.extends({}, params, {tidy:1, mergeArr:1}) : params || ''

		if (isGet){
			urlobj.path += body ? '?' + qs.stringify(body) : body
			urlobj.headers = opt.headers||{}
		}else{
			urlobj.headers = Object.assign({
				'Content-Type': 'application/x-www-form-urlencoded'
			},opt.headers||{})
			switch(urlobj.headers['Content-Type']){
			case 'application/json': body = JSON.stringify(body); break
			case 'plain/text': body = body.toString(); break
			default: body = qs.stringify(body); break
			}
		}

		const req = protocol.request(urlobj, res => {
			const st=res.statusCode
			const loc=res.headers.location
			if (st>=300 && st<400 && loc) return callee(method,loc,params,opt,cb,userData)
			res.setEncoding('utf8')
			const err=(300>st || !st) ? null : {error:res.statusMessage,code:st,params:arguments}
			cb(err, 2, null, userData)
			let data = ''
			res.on('data', (chunk)=>{
				data += chunk
				cb(err, 3, data, userData)
			})
			res.on('end', ()=>{
				cb(err, 4, data, userData)
			})
		})

		req.setTimeout(opt.timeout||0, err => {
			cb({error:err.message,code:599,src:err,params:arguments}, 4, null, userData)
		})
		req.on('error', err => {
			cb({error:err.message,code:500,src:err,params:arguments}, 4, null, userData)
		})

		if (isGet) req.end()
		else req.end(body)
		return req
	}
1358150
def on_binop(self, node):    # ('left', 'op', 'right')
        """"""
        return op2func(node.op)(self.run(node.left),
                                self.run(node.right))
1135120
void onClickOk() {

        CmsContainerPageCopier copier = new CmsContainerPageCopier(m_context.getCms());
        try {
            CmsContainerPageCopier.CopyMode mode = (CmsContainerPageCopier.CopyMode)(m_copyMode.getValue());
            copier.setCopyMode(mode);
            TargetInfo info = new TargetInfo(m_context.getCms(), m_targetSelect.getValue());
            if (!info.isValid()) {
                Type type = Type.ERROR_MESSAGE;
                String error = CmsVaadinUtils.getMessageText(Messages.GUI_COPYPAGE_INVALID_TARGET_0);
                Notification.show(error, type);
                return;
            }
            CmsResource targetFolder = info.getTargetFolder();
            copier.run(m_context.getResources().get(0), targetFolder, info.getTargetName());
            m_context.finish(
                Arrays.asList(
                    copier.getTargetFolder().getStructureId(),
                    copier.getCopiedFolderOrPage().getStructureId()));
        } catch (CmsException e) {
            m_context.error(e);
        } catch (NoCustomReplacementException e) {
            String errorMessage = CmsVaadinUtils.getMessageText(
                Messages.GUI_COPYPAGE_NO_REPLACEMENT_FOUND_1,
                e.getResource().getRootPath());
            CmsErrorDialog.showErrorDialog(errorMessage, e);
        }
    }
464863
def doc_browse(self, args, range=None):
        """"""
        self.log.debug('browse: in')
        self.call_options[self.call_id] = {"browse": True}
        self.send_at_position("DocUri", False, "point")
454176
def call(__self, __context, __obj, *args, **kwargs):
        """"""
        fmt = inspect_format_method(__obj)
        if fmt is not None:
            return __self.format_string(fmt, args, kwargs)

        # the double prefixes are to avoid double keyword argument
        # errors when proxying the call.
        if not __self.is_safe_callable(__obj):
            raise SecurityError('%r is not safely callable' % (__obj,))
        return __context.call(__obj, *args, **kwargs)
192987
function callFn(tpl, scope, option, buffer, parts, depth) {
  var caller, fn, command1;
  if (!depth) {
    command1 = findCommand(tpl.runtime.commands, tpl.root.config.commands, parts);
  }
  if (command1) {
    return command1.call(tpl, scope, option, buffer);
  } else if (command1 !== false) {
    caller = scope.resolve(parts.slice(0, -1), depth);
    fn = caller[parts[parts.length - 1]];
    if (fn) {
      // apply(x, undefined) error in ie8
      try {
        return fn.apply(caller, option.params || []);
      } catch (err) {
        buffer.error('Execute function `' + parts.join('.') + '` Error: ' + err.message);
        return buffer;
      }
    }
  }
  buffer.error('Command Not Found: ' + parts.join('.'));
  return buffer;
}
1335173
def page_up(self, n=1, interval=0, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.tap_key(self.k.page_up_key, n, interval)
        self.delay(post_dl)