Substituir string em arquivo sem arquivo temporário

Só por diversão, tentei um script bash de substituição no local, myreplace. Obviamente, não use isso sem salvar seus dados originais primeiro e fazer testes extensivos. Pode ter problemas com arquivos com mais de 4 GB, embora os números sejam maiores que 32 bits. Além disso, se houver milhões de correspondências, tacvai usar memória ou espaço de arquivo temporário. Também tive que hackear um pequeno script perl para fazer um seek(2), mas já deve haver um em algum lugar.

#!/bin/bash
# https://unix.stackexchange.com/q/784361/119298
file=${1?}
str1=utf8mb4_0900_ai_ci
str2=utf8mb4_unicode_520_ci

len1=${#str1}
len2=${#str2}
let len3=len2-len1
if [ "$len3" -lt 0 ]
then echo "bad len $len3. dont need this script"; exit 1
fi
echo "2nd str bigger by $len3"

# grep -c counts lines so ignores 2 matches on a line, not what we want
nummatches=$(grep -a -o -b -F "$str1" "$file" | wc -l)
let need=nummatches*len3
echo "$nummatches matches, need $need bytes"
filesize=$(stat --format=%s "$file")
echo "filesize $filesize"
let src=filesize
let dest=filesize+need
let i=nummatches

# open 2 filedescriptors on same file, to read from and write at
exec {fdr}<"$file" {fdw}<>"$file"
seek <&$fdr $src; seek <&$fdw $dest # seek to both eofs

blocksize=10240 # arbitrary optimisation
# move overlapping from,to,numbytes
domove(){
    local from=${1?} to=${2?} numbytes=${3?} partlen
    while [ $numbytes -gt 0 ]
    do  if [ $numbytes -gt $blocksize ]
        then    partlen=$blocksize
        else    partlen=$numbytes
        fi
        seek <&$fdr -$partlen; seek <&$fdw -$partlen
        dd <&$fdr >&$fdw ibs=$partlen count=1 iflag=fullblock status=none
        seek <&$fdr -$partlen; seek <&$fdw -$partlen
        let numbytes=numbytes-partlen
    done
    seek <&$fdw -$len2
    printf "%s" "$str2" >&$fdw
    seek <&$fdw -$len2
    seek <&$fdr -$len1
}

grep -a -o -b -F "$str1" "$file" |
sed 's/:.*//' |
tac |
while read offset
do  echo "match $i at src $offset"
    let tomove="src-(offset+len1)"
    echo "move all from $offset+$len1 .. $src ($tomove bytes) to $dest-$tomove"
    echo "insert $len2 bytes of 2nd string to $dest-$tomove-$len2"
    echo "skip back over $len1 bytes of 1st string"
    domove $(($offset+$len1)) $(($dest-$tomove)) $tomove
    let src=$offset
    let dest=dest-tomove-len2
    let i=i-1
done

O princípio é usar greppara encontrar os deslocamentos de bytes das correspondências, então usar tacpara reverter essa lista para que comecemos no final. Abrimos 2 descritores de arquivo no arquivo. fdrserá nossa posição de leitura atual e fdwnossa posição de gravação. Ambos começam no final do arquivo, mas fdwestão no novo final nocional, que está mais adiante por nummatchestimes len3, a diferença no comprimento da string de substituição.

Usamos a função domovepara buscar de volta no leitor por uma quantia, buscar de volta no escritor pela mesma quantia, ler e copiar a quantia para o escritor. Então precisamos buscar de volta novamente para nossas novas posições.

Buscamos de volta no leitor para pular a string antiga. No escritor buscamos de volta, escrevemos a string de substituição e buscamos de volta sobre ela.

Criei um arquivo de demonstração para testar ( str1está no script):

file=/tmp/myfile
man bash | sed 's/ brace / '"$str1"' /g' >"$file"
cp "$file" /tmp/orig
./myreplace "$file"
diff -u /tmp/orig "$file"

Meu perl está um pouco enferrujado, mas aqui está o script perl "seek":

#!/usr/bin/perl
# seek on stdin to given position
use strict;
use Fcntl 'SEEK_SET','SEEK_CUR';
sub usage{
    printf STDERR "usage: [+|-]9999  where sign means relative\n";
    exit 1;
}
my $offset = shift @ARGV;
my $flag = SEEK_SET;
my $sign = 1;
if($offset =~ s/^-//){$flag = SEEK_CUR; $sign = -1;}
elsif($offset =~ s/^\+//){$flag = SEEK_CUR;}
if($offset!~/^\d+$/){ usage(); }
usage() if(scalar @ARGV!=0);
$offset *= $sign;
if(!seek(STDIN,$offset,$flag)){
    printf STDERR "failed to seek to $offset: $!\n";
    exit 2;
}