No emacs (ou outro editor) como exibir o byte offset do cursor?

Question

A pergunta indica minha preferência em usar o emacs, mas o problema principal é que eu quero fazer uma pesquisa de texto normal e de alguma forma ver / copiar e colar o byte-offset da correspondência texto.

Para ser claro, por byte-offset , não quero dizer o valor point do emac, que mostra o número de caracteres desde o início do buffer, por exemplo. em UTF-16LE, point considera \x0d\x00\x0a\x00 como 1 caractere, enquanto eu estou interessado nele como 4 bytes.

Qualquer outro editor (ou visualizador) que apresente essa informação básica enquanto exibe o texto de maneira "normalmente" legível e pesquisável vale a pena.

Mesmo uma visão hexadecimal com uma visão normal-text sincronizada estaria ok, mas um visualizador / editor de despejo hexadecimal típico não é o que eu estou procurando, já que eles (tipicamente) só exibem ASCII chars, e eu não encontrei um visualizador / editor FOSS Hex-dump que possa realizar uma busca simples no modo de texto para não ASCII UTF-8 ou para qualquer string UTF-16.

Estou principalmente preocupado com a legibilidade e a capacidade de pesquisa do texto, portanto, um programa de dump de Hex "normal" é apenas um substituto (que eu já estou usando).

    

Answer 1

Primeiro, caso você não saiba, o Emacs possui hexl-find-file , o que abre um arquivo no modo de edição hexadecimal. Eu sei que não é o que você pediu, mas se você já está usando um, e você está confortável com o Emacs, então é bom saber sobre isso para necessidades futuras.

Segundo, para este tipo de edição "raw" de um arquivo (o que costumo fazer com frequência), find-file-literally é realmente ótimo. Ele faz o que você espera que ele faça, e finge ser uma versão pré-unicode de si mesmo e abre o arquivo com escapes aparecendo para caracteres não-ascii (e controlando chars, etc.). É provável que isso faça o que você quer, embora tenha a desvantagem óbvia de não ser capaz de ler o texto se você tiver muito conteúdo não-ASCII.

Então, indo mais longe no suporte primitivo, há a variável enable-multibyte-characters e a função set-buffer-multibyte que é usada para alterná-lo. O bom disso é que ele muda a apresentação do buffer dinamicamente - por exemplo, tente isto:

(defun my-multi-toggle ()
  (interactive)
  (set-buffer-multibyte (not enable-multibyte-characters)))
(global-set-key (kbd "C-~") 'my-multi-toggle)

e agora você tem uma chave que alterna o modo bruto dinamicamente. Ele também tem a boa propriedade de deixar o cursor no mesmo lugar. Mas este modo bruto mostra a representação interna (que se parece com o UTF-8) e não o que o arquivo esteja usando como codificação. Deve ser possível fazer o que você está falando com algum hack (por exemplo, usar find-file-literally em um arquivo aberto perguntará sobre revisitar, mas isso redefine o local e recarrega o arquivo também) - mas soa como o acima já está bem. (Isto é, meu palpite é que você está tentando editar algum campo de texto em um arquivo binário de outra forma ...)

    

Answer 2

Eu consegui juntar um script elisp para mostrar o deslocamento de bytes no ponto (poff) (por meio de uma tecla de atalho).

Sua apresentação é atualmente muito difícil, mas funciona bem para UTF-16LE / CR-LF (testado no início do arquivo e no final do arquivo. UTF-16 foi o formato que me colocou nesse tema, e na verdade tem sido o mimplest para trabalhar com ..

O UTF-8 será um pouco mais complicado. como ele vai precisar de algum arquivo I / O ...

Aqui está o script.

(defun poff-zap ()
  "Get the byte offset of point - A prototye, tested minimally only with UTF-16LE" 
  (interactive)

  (let ((linect (- (line-number-at-pos) 1)) ;; line count to point
        (choncl (- (point) (point-at-bol))) ;; characters to point on current line
        (chrpnl 0) ;; chars per newline
        (bytpch 0) ;; bytes per char
        (bytpnl 0) ;; bytes per newline
        (offset 0) ;; the byte offset   
        (coding  (car (split-string (symbol-name buffer-file-coding-system) "-")))
        (format (cadr (split-string (symbol-name buffer-file-coding-system) "-"))))

    (case (coding-system-eol-type buffer-file-coding-system)
      ('0 (setq chrpnl 1)) ;; unix 
      ('1 (setq chrpnl 2)) ;; dos
      ('2 (setq chrpnl 1)) ;; mac
      (t))

    (if (> chrpnl 0) 
        (cond
        ((string= "utf" coding) 
            (cond
            ((string= "8" format) 
                (progn
                (setq bytpch -1)
                ;; need to do an actual byte count
                ;;   using a UTF-8 parser
                ;; ...plus a BOM check(?)
            ))
            ((or 
             (string= "16" format)  
             (string= "16le" format)) 
                (progn 
                (setq bytpch 2)
                (if (= 2 chrpnl) (setq offset linect))
                (setq offset (+ offset (point)))
                (setq offset (* offset bytpch))
            ))
            (t)))
        (t)))

     (message (concat 
      "poff-zap: " (number-to-string bytpch)  " bytes-per-char\n" 
      "          " (number-to-string chrpnl)  " chars-per-newliner\n"
      "          " (number-to-string bytpnl)  " bytes-per-newliner\n"
      "          " (number-to-string (point)) " point-emacs\n"
      "          " (number-to-string offset)  " offset poff-zap\n"
      "          " (symbol-name buffer-file-coding-system) ))  
))
(global-set-key (kbd "C-#") 'poff-zap)

    

Answer 3

Parece que você quer position-bytes . Você pode ver o byte offset do cursor ('point' na terminologia do Emacs):

M-: (1- (position-bytes (point)))

Observe que position-bytes é indexado 1, por isso, o 1- . Você pode incluir isso em um comando de conveniência:

(defun wh/byte-offset-at-point ()
  "Report the byte offset (0-indexed) in the file
corresponding to the position of point."
  (interactive)
  (message "byte offset: %d" (1- (position-bytes (point)))))

    

Answer 4

Vim

Em vim , g^G é exibido na parte inferior da tela como:

Col 1 of 3; Line 2 of 2; Word 2 of 2; Char 5 of 8; Byte 7 of 10

Para ter o deslocamento de byte do cursor sempre na linha de status, adicione %o à opção statusline :

:set statusline+=\ %o

(você pode precisar lançar um :set laststatus=2 para a linha de status para estar sempre visível mesmo quando a tela não está dividida. Para que o deslocamento seja exibido no tamanho certo, coloque %o à direita de uma %= em statusline ).

Veja também :go 123 ou 123go para posicionar o cursor mais próximo do byte 123 ^rd .