Build relocation for strings.
961055
def c_self_relocs(self):
        """"""
        relocs = []
        if not callable(self.opts.hash_func):
            relocs = [
                reloc_ptr(
                    self.opts.prefix + name, self.opts.reloc_delta,
                    'char *'
                )
                for name, dummy_args in self.funcs
            ]
        if self.name != 'kernel32':
            relocs = [
                reloc_ptr(
                    self.opts.prefix + self.name,
                    self.opts.reloc_delta, 'char *'
                )
            ] + relocs
        return relocs
762837
def aux_moveTree(offset, tree):
	""""""
	if tree.x1 != None and tree.x2 != None :
		tree.x1, tree.x2 = tree.x1+offset, tree.x2+offset
		
	for c in tree.children:
		aux_moveTree(offset, c)
96745
def build(self, input_path, output_paths):
        """"""
        for output in output_paths:
            shutil.copy(input_path, output_paths)
1285346
function move(src, dest) {
	return rename(src, dest).catch((err) => {
		// try copying
		return copy(src, dest).then(() => {
			// delete source
			return unlink(src);
		});
	});
}
901361
@Override
	public void relocate()
	{

		int w = 310, h = 255;
		int x = (this.getWidth() - w) / 2, y = (this.getHeight() - h) / 2;

		taskLimitationsLabel.setLocation(x, y);
		articleTaskLabel.setLocation(x, y + 30);
		articleTaskLimitField.setLocation(x + 110, y + 30);
		diffTaskLabel.setLocation(x, y + 60);
		diffTaskLimitField.setLocation(x + 110, y + 60);

		sqlProducerLimitationsLabel.setLocation(x, y + 100);
		maxAllowedPacketLabel.setLocation(x, y + 130);
		maxAllowedPacketField.setLocation(x + 170, y + 130);
	}
967013
private static <I, D> void moveIncoming(AbstractBaseDTNode<I, D> newNode,
                                            AbstractBaseDTNode<I, D> oldNode,
                                            D label) {
        newNode.getIncoming().insertAllIncoming(oldNode.getSplitData().getIncoming(label));
    }
903512
private void moveToNext() {
        if (controller != null) {
            currentItemIndex = controller.nextItem(this, currentItemIndex);
        } else {
            currentItemIndex = defaultController.nextItem(this, currentItemIndex);
        }
    }
563783
function moveImports(code, imports) {
    return code.replace(RE_IMPORTS, function (_, indent, imprt) {
        imprt = imprt.trim();
        if (imprt.slice(-1) !== ';') {
            imprt += ';';
        }
        imports.push(imprt);
        return indent; // keep only the indentation
    });
}
5503
@Override
	public void relocate()
	{

		int w = 550, h = 210;

		int x = (this.getWidth() - w) / 2;
		int y = (this.getHeight() - h) / 2;

		// 10, 10 <-> 580, 185
		executablePathLabel.setLocation(x, y);

		sevenZipEnableBox.setLocation(x, y + 35);
		sevenZipLabel.setLocation(x + 30, y + 35);
		sevenZipPathField.setLocation(x + 160, y + 35);
		sevenZipSearchButton.setLocation(x + 470, y + 35);

	}
641996
function( url, wc, options, callback ) {
	if ( typeof options === 'function' ) {
		callback = options;
		options = null;
	}
	options = options || {};
	executeSvn( [ 'relocate', url, wc ], options, callback );
}
761195
def prepend_string(t, string):
    """"""
    node = t.tree
    if node.text is not None:
        node.text += string
    else:
        node.text = string
598180
def set_string(self, string):
        """"""
        self.string = string
        self.length = len(string)
        self.reset_position()
218568
def move(self, src_url, dst_url):
        """"""
        self.copy(src_url, dst_url)
        self.destroy(src_url)
389121
def move(self, source, destination):
        
        if source.isfile():
            source.copy(destination)
            source.remove()
        else:
            source.copy(destination, recursive=True)
            source.remove('r')
91377
def relocate(self):
        """"""

        name = self.SearchVar.get()
        if self.kbos.has_key(name):
            kbo = self.kbos[name]
            assert isinstance(kbo, orbfit.Orbfit)
            this_time = Time(self.date.get(), scale='utc')
            try:
                kbo.predict(this_time)
                self.recenter(kbo.coordinate.ra.radian, kbo.coordinate.dec.radian)
                self.create_point(kbo.coordinate.ra.radian, kbo.coordinate.dec.radian, color='blue', size=4)
            except:
                logging.error("failed to compute KBO position")
1071550
def _expand(self, str, local_vars={}):
        """"""
        return ninja_syntax.expand(str, self.vars, local_vars)
144530
def move(ctx, client, sources, destination):
    """"""
    from renku.api._git import _expand_directories

    dst = Path(destination)

    def fmt_path(path):
        """Format path as relative to the client path."""
        return str(Path(path).absolute().relative_to(client.path))

    files = {
        fmt_path(source): fmt_path(file_or_dir)
        for file_or_dir in sources
        for source in _expand_directories((file_or_dir, ))
    }

    def fmt_dst(path):
        """Build a destination path for a source path."""
        return str(dst / os.path.relpath(path, start=files[path]))

    destinations = {source: fmt_dst(source) for source in files}

    # 1. Check .gitignore.
    ignored = client.find_ignored_paths(*destinations.values())
    if ignored:
        click.echo(WARNING + 'Renamed files match .gitignore.\n')
        if click.confirm(
            'Do you want to edit ".gitignore" now?', default=False
        ):
            click.edit(filename=str(client.path / '.gitignore'))

    # 2. Update dataset metadata files.
    with progressbar(
        client.datasets.items(),
        item_show_func=lambda item: str(item[1].short_id) if item else '',
        label='Updating dataset metadata',
        width=0,
    ) as bar:
        for (path, dataset) in bar:
            renames = {}

            for file in dataset.files:
                filepath = fmt_path(os.path.normpath(str(path.parent / file)))

                if filepath in files:
                    renames[file] = os.path.relpath(
                        destinations[filepath], start=str(path.parent)
                    )

            if renames:
                dataset = dataset.rename_files(
                    lambda key: renames.get(key, key)
                )

                dataset.to_yaml()

    # 3. Manage .gitattributes for external storage.
    tracked = tuple(
        path for path, attr in client.find_attr(*files).items()
        if attr.get('filter') == 'lfs'
    )
    client.untrack_paths_from_storage(*tracked)
    existing = client.find_attr(*tracked)
    if existing:
        click.echo(WARNING + 'There are custom .gitattributes.\n')
        if click.confirm(
            'Do you want to edit ".gitattributes" now?', default=False
        ):
            click.edit(filename=str(client.path / '.gitattributes'))

    client.track_paths_in_storage(*(destinations[path] for path in tracked))

    # 4. Handle symlinks.
    dst.parent.mkdir(parents=True, exist_ok=True)

    for source, target in destinations.items():
        src = Path(source)
        if src.is_symlink():
            Path(target).parent.mkdir(parents=True, exist_ok=True)
            Path(target).symlink_to(
                os.path.relpath(
                    str(src.resolve()), start=os.path.dirname(target)
                )
            )
            src.unlink()
            del files[source]

    # Finally move the files.
    final_sources = list(set(files.values()))
    if final_sources:
        run(['git', 'mv'] + final_sources + [destination], check=True)